Quel est le bon modèle de template générique threadsafe singleton en C# ?

Question

J'ai le modèle singleton C# suivant, y a-t-il un moyen de l'améliorer ?

    public class Singleton<T> where T : class, new()
    {

        private static object _syncobj = new object();
        private static volatile T _instance = null;
        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_syncobj)
                    {
                        if (_instance == null)
                        {
                            _instance = new T();
                        }
                    }
                }
                return _instance;
            }
        }

        public Singleton()
        { }

    }

Exemple d'utilisation préférée :

class Foo : Singleton<Foo> 
{
} 

Related :

Une implémentation évidente du singleton pour .NET ?

Answer 1

Selon Jon Skeet dans Implémentation du modèle Singleton en C# le code que vous avez posté est en fait considéré comme un mauvais code, car il semble cassé lorsqu'il est vérifié par rapport à la norme ECMA CLI.

Attention également : chaque fois que vous instanciez votre objet avec un nouveau type de T, il devient une autre instance ; cela ne se reflète pas dans votre singleton original.

Answer 2

Ce code ne compilera pas, vous avez besoin de la contrainte "class" sur T.

De plus, ce code nécessite un constructeur public sur la classe cible, ce qui n'est pas bon pour un singleton, car vous ne pouvez pas contrôler au moment de la compilation que vous obtenez une instance (unique) uniquement via la propriété (ou le champ) Instance. Si vous n'avez pas d'autres membres statiques que la propriété Instance, vous pouvez vous contenter de ce code :

class Foo
{
  public static readonly Instance = new Foo();
  private Foo() {}
  static Foo() {}
}

Il est thread safe (garanti par le CLR) et lazy (l'instance est créée au premier accès au type). Pour en savoir plus sur BeforeFieldInit et sur la raison pour laquelle nous avons besoin d'un constructeur statique ici, voir https://csharpindepth.com/articles/BeforeFieldInit .

Si vous souhaitez avoir d'autres membres statiques publics sur le type, mais créer un objet uniquement lors de l'accès à l'instance, vous pouvez créer un type imbriqué, comme dans le cas suivant https://csharpindepth.com/articles/Singleton

Answer 3

Avec l'aimable autorisation de Judith Bishop, http://patterns.cs.up.ac.za/

Cette mise en œuvre du modèle singleton assure une initialisation paresseuse.

//  Singleton PatternJudith Bishop Nov 2007
//  Generic version

public class Singleton<T> where T : class, new()
{
    Singleton() { }

    class SingletonCreator
    {
        static SingletonCreator() { }
        // Private object instantiated with private constructor
        internal static readonly T instance = new T();
    }

    public static T UniqueInstance
    {
        get { return SingletonCreator.instance; }
    }
}

Answer 4

C'est ce que je constate en utilisant .NET 4

public class Singleton<T> where T : class, new()
    {
        Singleton (){}

        private static readonly Lazy<T> instance = new Lazy<T>(()=> new T());

        public static T Instance { get { return instance.Value; } } 
    }

Answer 5

Plus de détails sur cette réponse sur un autre fil : Comment implémenter un singleton en C# ?

Cependant, le fil n'utilise pas Générique .