Dacă ești programator probabil că "Best Practice" sau "Design Pattern" înseamnă ceva. De curând m-am apucat să citesc cartea "C# 3.0 Design Patterns". Am găsit multe patternuri interesante și chiar vă recomand să o citiți, însă nu am scris această însemnare pentru a vă recomanda cartea ci pentru a expune o idee excelentă de pattern.

Singleton generic.

Codul este extrem de simplu, la obiect, thread safe(f important) și generic(și mai important).

public class Singleton<T> where T: class, new()
{
Singleton() { }
class SingletonCreator
{
internal static readonly T instance = new T();
static SingletonCreator()
{
}
}
     public static T UniqueInstance
{
get
{
     return SingletonCreator.instance;
}
}
}

Cam ce știe să facă această clasă?

Știe să păstreze o singură instanță a unei clase. Mai bine vedem o clasă de test și un mod de folosire..

Clasa ce va fi instanțiată o singură dată:

public class TestClass
{
public string Mesaj
{
get;
set;
}
public TestClass()
{
Mesaj = "Initial";
}
}

Și o metodă de test.

public void TestUniqueInstance()
{
TestClass prima = Singleton<TestClass>.UniqueInstance;
Console.WriteLine(prima.Mesaj);
TestClass aDoua = Singleton<TestClass>.UniqueInstance;
prima.Mesaj = "Mesaj schimbat";
Console.WriteLine(aDoua.Mesaj);
}

De ce mi s-a părut atat de bună această implementare?

Pentru că este cu adevărat refolosibilă.

Pentru că nu folosește un test de genul instance == null ce ar fi însemnat că aceasă clasă nu ar mai fi thread safe(decât dacă s-ar fi folosit mecanisme de sincronizare).

Pentru că modul de instanțiere este lazy(leneș în română?), adică instanțierea instanței unice se face doar dacă este cerut acest lucru.