Introduction au Pattern singleton en c# : 

Les design pattern (ou patron de conception) sont des blocs pré-designés servants à régler des problèmes spécifiques et récurrent en programmation (voir sur wikipedia).

Dans le cas du singleton son objectif est assez simple. Proposez un objet qui sera instancé qu'une fois et qui offrira ses services à l'ensemble de votre code sans prendre le risque d'avoir une multitude d'instances ouvertes.

La force du singleton est de régler ces risques là rapidement, en quelques lignes.... et de permettre d'exposer sa méthode à tout son code sans être inquiet surtout dans un context client server. 

Le concept de base du singleton

Le concept est simple : on expose une methode unique qui vérifie si une instance de l'objet existe déja ou non... Si elle n'existe pas elle est initialisée. La méthode réellement utilisée est une private, mais on utilise des getsetters pour accèder aux méthodes.

Quand utilisez un singleton ? 

Typiquement quand on développe du web ou des applications client-server le singleton est idéal pour implémenter des accès à des backends externes des services ou autres fournisseurs externes. On a ainsi une seule instance qui gère cela.

Le snippet de base d'un singleton multitreadable

Après avoir essayé plusieurs implémentations je vous propose une adaptée à mon objectif .net web et SAP supportant SharePoint 2010 et mes connecteurs. 

using System;

public sealed class Singleton

{

    private static volatile Singleton instance;

    private static object syncRoot = new Object();

    private Singleton() { }

    public static Singleton Instance    {

        get
        {
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }
}

Code exemple d'un singleton c# multitreadable

Je vous propose pour pouvoir jouer le code suivant complet. 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


    class Program
    {
        static void Main(string[] args)
        {
            mySingleton s1 = mySingleton.Instance;
            mySingleton s2 = mySingleton.Instance;
            if (s1 == s2)
            {
                Console.WriteLine("Même instance");
            }

            Console.WriteLine(s1.myCounter);
            Console.WriteLine(s2.myCounter);
            Console.WriteLine("fin");
        }
    }


    public sealed class mySingleton
    {
        private static volatile mySingleton instance;
        private static object syncRoot = new Object();
        private int counter; 
   
        private mySingleton() 
        {
            Console.WriteLine("Hello world");
            counter = 0; 
        }


        private string getCounter()
        {
            counter++;
            return ("compteur=" + counter + ".");
        }


        public static mySingleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (syncRoot)
                    {
                        if (instance == null)
                            instance = new mySingleton();
                    }
                }
                return instance;
            }
        }



        public string myCounter
        {
            get {
                return getCounter();
            }
        }
    }

Vous pouvez aussi modifier la méthode getCounter en la passant en public. Il s'agit d'un code pour jouer et apprendre.

Conclusion

Etant un vieux programmeur C j'avoue avoir eu du mal quand à l'utilité des patterns. L'idée même que les développeurs deviennent des ouvriers à la chaine n'appliquant que des morceaux de code génériques utilisant des framework génériques laisse peu de place à la création et l'optimisation. Toutefois certaines approches sont utiles, alors pourquoi s'en priver.

Jerome Fortias