Facendo oggi con Massimo il refactoring con generics della classe DotNetNuke.Common.Utilities.Null, sono nate alcune considerazioni sui tipi generici. Di seguito il post a 4 mani - si nota anche dall'italiano :-)
Avendo una classe static Foo che espone funzionalità generiche e più conveniente definire il type parameter per un metodo (Dummy) piuttosto che per la classe. Questo perché a runtime verrà generata un'unica classe Foo con più metodi Dummy anziché più classi Foo con un metodo Dummy ciascuna. Per esempio, il seguente snippet:
using System; class Foo<T>{ static Foo() { Console.WriteLine("Foo<{0}>", typeof(T)); } public static void Dummy() { }} class Foo{ static Foo() { Console.WriteLine("Foo"); } public static void Dummy<T>() { }} class Test{ static void Main() { Foo<int>.Dummy(); Foo<string>.Dummy(); Foo.Dummy<int>(); Foo.Dummy<string>(); }}
stampa a console:
Foo<System.Int32>
Foo<System.String>
Foo
Questo soprattutto se dobbiamo fare nella classe un'analisi del type parameter (come nel caso del refactoring della classe Null). Utilizzando questa soluzione il controllo verrà fatto soltanto una volta nella classe e non si troverà moltiplicato per ogni type parameter fornito.
Se la classe possedesse anche dei metodi non generici, con la classe Foo<T> dovremmo specificare obbligatoriamente un type parameter per T anche se i rispettivi metodi non lo utilizzerebbero.