Programming Languages Hacks

According to this official Microsoft link you should not use “using” to dispose your wcf client.

Instead use this extension method:

namespace System.ServiceModel
{
    public static class Extensions
    {
        /// <summary>
        /// Release safely your WCF Client
        /// </summary>
        public static void UsingSafe<T>(this T client, Action<T> work)
            where T : ICommunicationObject
        {
            try
            {
                work(client);
            }
            finally
            {
                try
                {
                    client.Close();
                }
                catch (CommunicationException)
                {
                    client.Abort();
                }
                catch (TimeoutException)
                {
                    client.Abort();
                }
                catch (Exception)
                {
                    client.Abort();
                    throw;
                }
            }
        }
    }
}

Usage:

new SomeClient().UsingSafe(channel => {
    channel.Login(username, password);
});

In Ninject the method Rebind<T> does the following:

• Unbind<T>: removes all binding for that types, also named binding!
• Bind<T>: add the specified binding

This means that using Rebind<T>().To<U>().Named(“X”) you are not just replacing the binding named “X” but you are clearing all existing binding registered with T!

If you want to just replace it just use this:

Bind<T>().To<U>.Named("X").ReplaceExisting();

Here the source code to achieve this (works in Ninject 2+):
 

using System.Linq;
using Ninject.Planning.Bindings;
using Ninject.Syntax;

// ReSharper disable CheckNamespace
namespace System
// ReSharper restore CheckNamespace
{
    public static class ExtensionsNinject
    {
        /// <summary>
        /// Replace existing binding.
        /// To replace a binding you should never use rebind becauses unbind all existing
        /// binds and then bind yours.
        /// You should first configure the entire binding using Bind and only as last
        /// operation you should declare to replace it using this method.
        /// </summary>
        public static void ReplaceExisting<T>(this IBindingInSyntax<T> bindingInSyntax)
        {
            ReplaceExistingImpl<T>(bindingInSyntax);
        }

        /// <summary>
        /// Replace existing binding.
        /// To replace a binding you should never use rebind becauses unbind all existing
        /// binds and then bind yours.
        /// You should first configure the entire binding using Bind and only as last
        /// operation you should declare to replace it using this method.
        /// </summary>
        public static void ReplaceExisting<T>(this IBindingOnSyntax<T> bindingInSyntax)
        {
            ReplaceExistingImpl<T>(bindingInSyntax);
        }

        /// <summary>
        /// Replace existing binding.
        /// To replace a binding you should never use rebind becauses unbind all existing
        /// binds and then bind yours.
        /// You should first configure the entire binding using Bind and only as last
        /// operation you should declare to replace it using this method.
        /// </summary>
        public static void ReplaceExisting<T>(this IBindingWhenSyntax<T> bindingInSyntax)
        {
            ReplaceExistingImpl<T>(bindingInSyntax);
        }

        private static void ReplaceExistingImpl<T>(IBindingSyntax bindingInSyntax)
        {
            var kernel = bindingInSyntax.Kernel;
            var bindingsToRemove = kernel.GetBindings(typeof(T)).Where(b => string.Equals(b.Metadata.Name, bindingInSyntax.BindingConfiguration.Metadata.Name, StringComparison.Ordinal));
            foreach (var bindingToRemove in bindingsToRemove)
            {
                kernel.RemoveBinding(bindingToRemove);
            }

            var binding = new Binding(typeof(T), bindingInSyntax.BindingConfiguration);
            kernel.AddBinding(binding);
        }
    }
}

With nhibernate we can fetch entities using the fetch strategies explained in the link.

Now we consider only the use of fetching by join.

Scenario: I want to fetch by join the first 5 students with all the exams eagerly loaded.

If I write the QueryOver I end not with 5 results but with 100 results, almost all of these duplicated!

Why does this happen? The response is: count the rows! If you execute in SQL Server the query you ends with 5 results combinated with the corresponding exams. If every student has 20 exam, you ends with 100 students!

A simple solution: change fetch strategy to select. But if you want join fetch to overcame to N+1 problem you should use the following fixes:

You can merge duplicates by setting a DistinctRootEntityResultTransformer in the QueryOver, but merging them means that you obtain just the merged result of the first 5 rows: a single student!

To obtain all the students you should first create a query with none eagerly loaded, and then use this query as subquery to obtain the remaining references to eagerly loaded.

You can follow this example:

                // this will hold the criterial for the query
                var subQuery = QueryOver.Of<Parent>();

               // we build the criteria here...

               // add paging id projection so we only get one page of ids
                var pageSubQuery = subQuery.Clone()
                    .OrderBy(p => p.Id).Asc
                    .Select(p => p.Id)
                    .Skip(index ?? 0)
                    .Take(itemsPerPage ?? 20)
                    ;

                var items = session.QueryOver<Parent>()
                    .WithSubquery.WhereProperty(p => p.Id).In(pageSubQuery)
                    .OrderBy(p => p.Id).Asc // important to have the same order as above!
                    .Fetch(p => p.Children).Eager
                    .TransformUsing(new DistinctRootEntityResultTransformer())
                    .Future()
                    ;

                // Count
                var count = subQuery.GetExecutableQueryOver(session)
                    .Select(Projections.CountDistinct<Parent>(p => p.Id))
                    .FutureValue<int>();

Other solutions from the official post in nhforge.

Based on separation between ViewModel and View when you want to display a Dropdown you should configure allowedvalues for a certain type inside the ViewModel instead of the Controller or the View.

For this reason, after long searches, I decided to implement my own solution based on convention.

This is the ideally expected result:

    public class UserViewModel
    {
        // the enum type is already handled specializing the string template
        public AreaEnumType AreaId { get; set; }

        [MultivalueAllowed]
        public int? CityId { get; set; }

        public IEnumerable<SelectListItem> CityIdAllowedValues()
        {
            var cities = getCitiesByRegion(this.AreaId);
            foreach(var city in cities) {
                yield return new SelectListItem { Text = city.Text, Value = city.Id, Selected = this.CityId == city.Id };
            }
        }
    }

In other words:

if you have a property that is to view as a dropdown, just add the attribute MultivalueAllowed and implement an instance method using the convention PropNameAllowedValues: you can also access to every instance property inside it!!!

These are the files to modify to achieve this (I’m using extension methods, reflection, UIHintAttribute, EditorTemplates, Razor):

/********** MultivalueAllowedAttribute.cs **********/
    public class MultivalueAllowedAttribute : UIHintAttribute
    {
        public MultivalueAllowedAttribute(bool allValuesVisibleFromStart = false)
            : base(getUiHintFromConfiguration(allValuesVisibleFromStart))
        {
        }
        private static string getUiHintFromConfiguration(bool allValuesVisibleFromStart)
        {
            return allValuesVisibleFromStart ? "Combobox" : "Dropdown";
        }
    }

/********** global.asax.cs **********/
protected override void OnApplicationStarted()
{
     ModelMetadataProviders.Current = new CustomMetadataProvider();
}

/********** CustomMetadataProvider.cs **********/
namespace MvcExtensions
{
    public class CustomMetadataProvider : DataAnnotationsModelMetadataProvider
    {
        protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            var modelMetadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName);

            // add container instance
            if(modelAccessor != null && modelAccessor.Target != null)
            {
                var containerField = modelAccessor.Target.GetType().GetField("container");
                if(containerField != null)
                {
                    var containerValue = containerField.GetValue(modelAccessor.Target);
                    modelMetadata.SetContainerInstance(containerValue);
                }
            }

            return modelMetadata;
        }
    }
}

namespace System
{

    public static class ModelMetadataExtensions
    {
        private static void addSafe(ModelMetadata modelMetadata, string key, object value)
        {
            modelMetadata.AdditionalValues.Add(key, value);
        }

        private static T getSafe<T>(ModelMetadata modelMetadata, string key)
        {
            object value;
            if(modelMetadata.AdditionalValues.TryGetValue(key, out value))
                return (T)value;
            return default(T);
        }

        public static void SetContainerInstance(this ModelMetadata modelMetadata, object value)
        {
            addSafe(modelMetadata, "containerInstance", value);
        }

        public static object GetContainerInstance(this ModelMetadata modelMetadata)
        {
            return getSafe<object>(modelMetadata, "containerInstance");
        }
    }
}

/********** Views/Shared/EditorTemplates/Dropdown.cshtml **********/
@model System.Object

@if (ViewData.ModelMetadata.DisplayName != null)
{
    @Html.LabelForModel()
}
@Html.DropDownListByConvention("")
@Html.Description("", new { @class = "description" })
@Html.ValidationMessage("", null, new { @class = "ym-message" })

        /********** HtmlHelperExtensions.cs **********/
        public static MvcHtmlString DropDownListByConvention<TModel>(this HtmlHelper<TModel> htmlHelper, string expression)
        {
            var metadata = ModelMetadata.FromStringExpression(expression, htmlHelper.ViewData);
            var containerInstance = metadata.GetContainerInstance();
            var containerType = metadata.ContainerType;
            var items = containerInstance.GetAllowedValues(containerType, metadata.PropertyName);
            if (metadata.IsNullableValueType)
            {
                items = SingleEmptyItem.Concat(items);
            }

            return htmlHelper.DropDownList(expression, items);
        }

        public static IEnumerable<SelectListItem> GetAllowedValues(this object instance, Type instanceType, string propertyName)
        {
            var allowedValuesMethodName = propertyName + "AllowedValues";
            var allowedValuesMethod = instanceType.GetMethod(allowedValuesMethodName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

            if(allowedValuesMethod == null)
            {
                throw new Exception("Unable to find instance method " + instanceType.Name + "." + allowedValuesMethodName);
            }

            var result = allowedValuesMethod.Invoke(instance, null);
            return (IEnumerable<SelectListItem>)result;
        }

Come al solito… articolo condensato per non perdere tempo…!

Perché scegliere Git rispetto agli altri controlli versione come Svn, Cvs, …? Di seguito un elenco delle cose che Git consente in più rispetto agli altri sistemi:

1. git è distribuito: ogni client non ottiene l’ultima versione disponibile (come in Svn) ma un clone dell’intero repository con tutto lo storico. Questo abilita un uso completo offline di tutte le funzionalità (commit, diff, log, branch, merge, annotation) in modo istantaneo. Inoltre il sistema non avrà un Single Point of Failure poiché ogni client avrà il full backup del progetto. Infine si può articolare una struttura di workflow in cui si mantengono dei repository separati con diversi permessi di lettura/scrittura che vengono integrati in un workflow “gold” (si veda questo articolo) [in TFS strutturare in questo modo è possibile grazie a un uso corretto dei permessi e delle policy].
2. branch semplici: creare un branch ed eseguire lo switch a un branch sono operazioni che impiegano qualcosa come 0.1 secondi. Tale velocità cambia l’aspetto psicologico del branch: diventa un’operazione comune per qualunque cosa su cui si lavora: ogni feature, idea, bugfix, senza essere online con la possibilità di annullare un branch e cambiare contesto quasi in modo istantaneo. Il merge inoltre è a 3 vie e riduce al minimo le probabilità di conflitti.
3. commit organizzate per feature: a differenza di altri sistemi come Svn, in Git i file locali non vengono inviati direttamente nel repository ma passano prima per una staging area (o index) che consente di specificare nel dettaglio quali file (e quali porzioni di file) si andranno a committare, in modo da risolvere il problema della “copia di lavoro intricata” e mantenere ogni commit un evento con il preciso scopo di riportare i file modificati impattati dopo aver implementato una determinata feature. Questa separazione consente di eseguire ad esempio il merge solo di determinate feature, lasciandone indietro altre.
   Infatti Git viene definito un “change control” invece di un “version control”: invece di presentare il progetto linearmente (mentalità dell’”undo”) Git vede solo un manipolo di commit pronti per essere rimescolati o amalgamati insieme
4. utile a te: spesso si sceglie di non usare Git poiché non si fa parte di un team numeroso. In realtà Git aiuta te, non il tuo team: il branch locale, il context switching, le commit come feature, aiutano l’individuo, non il team. Velocità e backup sono sempre una buona cosa, sia in team che non.

It’s very useful to express everything in JQuery instead of ASP.NET AJAX events system: in this way we can use a lot of useful JQuery controls.

To achieve this just add this snippet of javascript code:

<script type="text/javascript">
	Sys.WebForms.PageRequestManager.getInstance().add_beginRequest(BeginRequest);
	Sys.WebForms.PageRequestManager.getInstance().add_endRequest(EndRequest);
	function BeginRequest(sender, args) {
		jQuery.event.trigger('ajaxSend');
	}
	function EndRequest(sender, args) {
		jQuery.event.trigger('ajaxComplete');
	}
</script>

In this way you can capture standard JQuery event to obtain for example a modal progress feedback both in case of JQuery ajax POST and in case of ASP.NET UpdatePanel events:

<script type="text/javascript">
	$(document).bind("ajaxSend", function () {
		$("#loadingAjax").dialog({ modal: true });
	}).bind("ajaxComplete", function () {
		$("#loadingAjax").dialog("close");
	});
</script>

Scenario:

I want to localize my app AllSync but I was taken by a little frustration.

Following this good guide you can see that there are two main way to localize your iOS (iPhone/iPad) app:

• localize strings using Localizable.strings
• localize single nib file creating one version for each

I want to localize my nib files in the same way of using Localizable.strings

A possible solution can be to externalize in code every text setting but is a tedious process and you can’t use the flexibility of xcode 4. The real solution I hope will be used by many of you is this:

The solution:

Create an extended version of iOS user control that automatically translates every single text

Simple to obtain: just see this extended UIButton

@interface UIButtonThemed : UIButton
@end

@implementation UIButtonThemed
- (id)initWithCoder:(NSCoder *)aDecoder {
    if ((self = [super initWithCoder:aDecoder]))
	{
        self.titleLabel.adjustsFontSizeToFitWidth = YES;
        NSString* text = NSLocalizedString(self.titleLabel.text, nil);
        [self setTitle:text forState:UIControlStateNormal];
        [self setTitle:text forState:UIControlStateHighlighted];
        [self setTitle:text forState:UIControlStateDisabled];
        [self setTitle:text forState:UIControlStateSelected];
	}
	return self;
}
@end

You can use it inside xcode 4 configuring the base class for your control:

"Sync" = "Sincronizza";
"Settings" = "Impostazioni";
"Help" = "Guida";
"Share" = "Condividi";
"Rate us" = "Votaci";
"Follow us" = "Seguici";

jQuery allows only to do a global form submit using

$("form").submit()

This method doesn’t allow to do a specific form submit when multiple <input type=”submit”> exists, like in many ASP.NET sites, where there are a single form with many buttons.

To achieve this and obtain an ASP.NET POSTBACK behavior simply use this snippet of jQuery code that builds a “submit simulation from input”:

// simulate submit from button "myButton"
var input = $("<input>").attr("type", "hidden").attr("name", $('#myButton').attr("name")).val("");
$('form').append($(input));
$('form').submit();

Il pattern Flyweight consente di riutilizzare gli oggetti in modo da poter evitare allocazioni. Questo risulta utile se:

1. gli oggetti da creare richiedono molta memoria
2. gli oggetti da creare sono molti
3. gli oggetti da creare sono costosi da creare (e distruggere) dal punto di vista computazionale
4. i vincoli impongono un sistema che non abbia cali improvvisi di performance, derivanti ad esempio dall’inizializzazione pesante di un oggetto
5. i vincoli impongono un utilizzo molto attento delle risorse