public static SingletonThreadSafe GetInstancia(string value)
{
// Este condicional es necesario para evitar que los subprocesos tropiecen con el
// bloquear una vez que la instancia esté lista.
if (_instancia == null)
{
// Ahora, imagina que el programa acaba de lanzarse. Ya que
// todavía no hay una instancia de Singleton, varios subprocesos pueden
// pasar simultáneamente el condicional anterior y llegar a este
// punto casi al mismo tiempo. El primero de ellos adquirirá
// bloquear y continuará, mientras que el resto esperará aquí.
lock (_bloqueo)
{
// El primer hilo en adquirir el bloqueo, llega a este
// condicional, entra y crea la instancia del Singleton.
// Una vez que sale del bloque de bloqueo, un hilo que
// podría haber estado esperando la liberación de bloqueo puede entonces
// entrar en esta sección. Pero dado que el campo Singleton ya ha sid
// inicializado, el hilo no creará un nuevo objeto.
if (_instancia == null)
{
_instancia = new SingletonThreadSafe();
_instancia.Value = value;
}
}
}
return(_instancia);
}
public void TestThreadSafeSingleton()
{
SingletonThreadSafe threadSafe1 = SingletonThreadSafe.GetInstance();
SingletonThreadSafe threadSafe2 = SingletonThreadSafe.GetInstance();
Assert.AreSame(threadSafe1, threadSafe2);
}
private static void SingletonPattern()
{
SingletonClassic singletonClassic = SingletonClassic.getInstance();
Console.WriteLine(singletonClassic.getDescription());
SingletonThreadSafe singletonThreadSafe = SingletonThreadSafe.getInstance();
Console.WriteLine(singletonThreadSafe.getDescription());
}
/// <summary>
/// Gets the instance.
/// </summary>
/// <value>
/// The instance.
/// </value>
public static SingletonThreadSafe Instance()
{
if (instance == null)
{
lock (syncRoot)
{
if (instance == null)
{
instance = new SingletonThreadSafe();
}
}
}
return(instance);
}
public static SingletonThreadSafe getInstance()
{
if (instance == null)
{
lock (mutex)
{
if (instance == null)
{
instance = new SingletonThreadSafe();
}
}
}
return(instance);
}
public static SingletonThreadSafe GetInstance(string value)
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new SingletonThreadSafe();
_instance.Value = value;
}
}
}
return(_instance);
}
internal static void ExecuteSingleton()
{
//Intent
// • Ensure a class has only one instance, and provide a global point of access to it.
// • Encapsulated "just-in-time initialization" or "initialization on first use".
//Problem
// Application needs one, and only one, instance of an object.
// Additionally, lazy initialization and global access are necessary.
//NOTES
// In many ways, the Singleton Pattern is a convention for ensuring one and only one object is instantiated for a given class.
// Just ask yourself: how do I prevent more than one object from being instantiated? It’s not so obvious, is it?
// Let’s say you have an object that contains registry settings. You don’t want multiple copies of that object and its values running around
// – that would lead to chaos.By using an object you can assure that every object in your application is making use of the same global resource.
//SingletonFirstVersion sfv = new SingletonFirstVersion();
SingletonFirstVersion sfv2 = SingletonFirstVersion.Instance;
//SingletonThreadSafe sts = new SingletonThreadSafe();
SingletonThreadSafe sts2 = SingletonThreadSafe.Instance;
}
