Singleton avec paramètres

Question

J'ai besoin d'une classe singleton pour être instanciée avec certains arguments. La façon dont je le fais maintenant:

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... 
    } 
} 

L'instance est créé « fin », ce qui signifie que je n'ai pas tous les arguments nécessaires au démarrage de l'application.

En général je n'aime pas forcer une commande d'appels de méthode, mais je ne vois pas d'autre moyen ici. L'IoC ne le résoudrait pas non plus, puisque je peux l'enregistrer dans le conteneur, je peux aussi appeler Create() ...

Considérez-vous cela comme un bon scénario? Avez-vous une autre idée?

modifier: Je sais que ce que j'ai écrit comme un exemple, il est pas thread-safe, thread-safe ne fait pas partie de la question

Answer 1

A Singleton avec des paramètres me sent le poisson.

Tenir compte de la réponse whateva et le code suivant:

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

De toute évidence, x == œuvres y et y avec les paramètres de création de x, tandis que les paramètres de création de y sont tout simplement ignorés. Les résultats sont probablement ... déroutants au moins.

Si vous avez vraiment, vraiment tombé comme vous devez le faire, le faire comme ceci:

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);    
    } 
} 

Dans un environnement multithreading, ajouter la synchronisation pour éviter les conditions de course.

Answer 2

Je ne peux pas vraiment voir un singleton dans votre code. Utilisez une méthode getInstance statique et paramétrée qui renvoie le singleton et le crée s'il n'a pas été utilisé auparavant.

Answer 3

Meilleure réponse:

1. Créer une interface: ISingleton (contenant toutes les actions que vous voulez faire pour)

2. Et votre type: Singleton : ISingleton

3. En supposant que vous avez accès à un UnityContainer:

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

1. Lorsque vous êtes prêt à créer votre utilisation de type (en supposant que vous utilisez l'unité pour DI):

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

1. Si vous voulez saisir le singleton il suffit d'utiliser:

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

Remarque: Si le conteneur n'a pas de type enregistré pour l'interface ISingleton, il doit soit renvoyer une exception, soit renvoyer une valeur nulle.

Old Réponse:

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; 
    } 
} 

je partirais avec quelque chose de similaire (vous pourriez avoir besoin de vérifier si instance a été créée aussi), ou, si votre conteneur DI prend en charge lancer exception sur les types non enregistrés, je aller avec ça.

ATTN: fil non Code sécurité :)

Answer 4

Singleton est laid, mais depuis whateva utilisateur ne peut pas être pris la peine de corriger son propre code ...

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 blogué il y a environ cette année, je pense, il est assez fiable. Aucune exception n'est nécessaire, vous n'avez pas à vous rappeler quels objets sont censés être des singletons et à gérer les retombées lorsque vous vous trompez. Editer: les types ne sont pas pertinents, utilisez ce que vous voulez, object est juste utilisé ici pour plus de commodité.

Answer 5

La solution de double singlet à verrouillage fournie par annakata ne fonctionnera pas à chaque fois sur toutes les plates-formes. il y a une faille dans cette approche qui est bien documentée. N'utilisez pas cette approche ou vous vous retrouverez avec des problèmes.

La seule façon de résoudre ce problème consiste à utiliser le mot-clé volatile par ex.

private static volatile Singleton m_instance = null; 

Ceci est la seule approche thread-safe.

Answer 6

Si vous utilisez .NET 4 (ou supérieur), vous pouvez utiliser le type System.Lazy. Il va prendre soin de vous le problème de sécurité des threads et le faire paresseux de sorte que vous ne créerez pas d'instance inutilement. De cette façon, le code est court et propre.

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; } } 
}