Singleton con los parámetros

Question

Necesito una clase singleton para crear una instancia con algunos argumentos. La forma en que estoy haciendo ahora es:

class SingletonExample 
{ 
    private SingletonExample mInstance; 
    //other members... 
    private SingletonExample() 
    { 

    } 
    public SingletonExample Instance 
    { 
     get 
     { 
       if (mInstance == null) 
       { 
        throw new Exception("Object not created"); 
       } 
       return mInstance; 
     } 
    } 

    public void Create(string arg1, string arg2) 
    { 
     mInstance = new SingletonExample(); 
     mInstance.Arg1 = arg1; 
     mInstance.ObjectCaller = new ObjectCaller(arg2); 
     //etc... basically, create object... 
    } 
} 

la instancia se crea 'tarde', lo que significa que no tengo todos los argumentos necesarios en el arranque de aplicaciones.

En general, no me gusta forzar un pedido de llamadas a métodos, pero no veo otra manera aquí. El IoC tampoco lo resolvería, ya que donde puedo registrarlo en el contenedor, también puedo llamar a Crear() ...

¿Considera que es un buen escenario? ¿Tienes alguna otra idea?

edición: Yo sé que lo que escribí como un ejemplo que no es hilo de seguridad, hilo de seguridad no es parte de la pregunta

Answer 1

un producto único con parámetros huele mal a mí.

Consideremos la respuesta de whateva y el siguiente código:

Singleton x = Singleton.getInstance("hello", "world"); 
Singleton y = Singleton.getInstance("foo", "bar"); 

Obviamente, x == obras Y e Y con los parámetros de creación de x, mientras que los parámetros de creación de Y son simplemente ignorados. Los resultados son probablemente ... confusos al menos.

Si realmente, realmente sentir como si tiene que hacerlo, hacerlo de esta manera:

class SingletonExample 
{ 
    private static SingletonExample mInstance; 
    //other members... 
    private SingletonExample() 
    { // never used 
     throw new Exception("WTF, who called this constructor?!?"); 
    } 
    private SingletonExample(string arg1, string arg2) 
    { 
     mInstance.Arg1 = arg1; 
     mInstance.ObjectCaller = new ObjectCaller(arg2); 
     //etc... basically, create object...  
    } 
    public static SingletonExample Instance 
    { 
     get 
     { 
       if (mInstance == null) 
       { 
        throw new Exception("Object not created"); 
       } 
       return mInstance; 
     } 
    } 

    public static void Create(string arg1, string arg2) 
    { 
     if (mInstance != null) 
     { 
      throw new Exception("Object already created"); 
     } 
     mInstance = new SingletonExample(arg1, arg2);    
    } 
} 

En un entorno multihilo, añadir la sincronización para evitar condiciones de carrera.

Answer 2

En realidad no puedo ver un producto único en su código. Utilice un método getInstance estático y parametrizado que devuelve el singleton y lo crea si no se utilizó antes.

Answer 3

Mejor respuesta:

1. crear una interfaz: ISingleton (que contiene cualquier acción que desea que haga a)

2. Y su tipo: Singleton : ISingleton

3. suponiendo que tiene acceso a una UnityContainer:

IUnityContainer _singletonContainer = new UnityContainer(); // or whatever code to initialize the container

1. Cuando esté listo para crear su utilización tipo (suponiendo que está utilizando la Unidad de DI):

_singletonContainer.RegisterType(typeof(ISingleton), new Singleton(params));

1. Si quiere agarrar el singleton sólo tiene que utilizar:

var localSingletonVar = _singletonContainer.Resolve<ISingleton>();

Nota: Si el contenedor no tiene un tipo registrado para la interfaz ISingleton, entonces debe arrojar una excepción, o devolver nulo.

respuesta antigua:

public class Singleton 
{ 

    private static Singleton instance = null; 

    private Singleton(String arg1, String arg2) 
    { 
    } 

    public static Singleton getInstance(String arg1, String arg2) 
    { 
     if (instance != null) 
     { 
      throw new InvalidOperationException("Singleton already created - use getinstance()"); 
     } 
     instance = new Singleton(arg1, arg2); 
     return instance; 
    } 

    public static Singleton getInstance() 
    { 
     if (instance == null) 
      throw new InvalidOperationException("Singleton not created - use GetInstance(arg1, arg2)"); 
     return instance; 
    } 
} 

me gustaría ir con algo similar (lo que pueda necesitar para comprobar si la instancia se creó también), o, si su contenedor DI soporta tirar excepción de los tipos no registrados, lo haría ir con eso.

Atención: no hilo de código seguro :)

Answer 4

Singleton es feo pero desde whateva usuario no puede ser molestado en corregir su propio código ...

public class Singleton 
{ 
    private static Singleton _instance = null; 

    private static Object _mutex = new Object(); 

    private Singleton(object arg1, object arg2) 
    { 
     // whatever 
    } 

    public static Singleton GetInstance(object arg1, object arg2) 
    { 
     if (_instance == null) 
     { 
      lock (_mutex) // now I can claim some form of thread safety... 
      { 
       if (_instance == null) 
       { 
        _instance = new Singleton(arg1, arg2); 
       } 
      } 
     } 

     return _instance; 
    } 
} 

Skeet blogs sobre esto hace años creo, es bastante fiable. Sin excepciones, no está en el negocio de recordar qué objetos se supone que son simples y manejar las consecuencias cuando se equivoca.

Editar: los tipos no son relevantes, utilice lo que desee, object se acaba de utilizar aquí para mayor comodidad.

Answer 5

La solución singleton de doble bloqueo provista por annakata no funcionará siempre en todas las plataformas. hay un error en este enfoque que está bien documentado. No use este enfoque o terminará con problemas.

La única forma de resolver este problema es utilizar la palabra clave volátil, p.

private static volatile Singleton m_instance = null; 

Este es el único enfoque seguro de subprocesos.

Answer 6

Si está usando .NET 4 (o superior), puede utilizar el tipo System.Lazy. Cuidará el problema de la seguridad del hilo y lo hará perezoso para que no cree una instancia innecesariamente. De esta manera, el código es corto y limpio.

public sealed class Singleton 
{ 
    private static readonly Lazy<Singleton> lazy = 
     new Lazy<Singleton>(() => new Singleton(),LazyThreadSafetyMode.ExecutionAndPublication); 

    private Singleton() { } 

    public static Singleton Instance { get { return lazy.Value; } } 
}