1) Définition du design pattern Singleton

Le singleton est un design pattern (pour les plus francophone un « patron de conception ») qui consiste à restreindre l'instanciation d'une classe à un seul objet (ou à quelques objets).

Dans la pratique, le singleton peut être utilisé dans le cas d’une classe de connexion à une base de données. Le singleton permet de s’assurer qu’une seule instance de la classe connexion est utilisée.

Par contre, attention à ne pas confondre classe statique et Singleton : les deux sont différents et ne s’appliquent pas dans les mêmes cas. Singleton permet d’utiliser un vrai objet, être hérité (classe « normale »)… etc, la classe statique non (ce qui peut être gênant, dans le cas cité plus haut, dans initialisation de la classe).

Ce design pattern est très pratique, à manipuler selon ses besoins, mais attention à l’utilisation de ce pattern en cas de multithreading : il faut éviter que deux threads accèdent en même temps à la création de l’instance de l’objet. Aussi, certains pensent que c’est un antipattern, du fait qu’on le retrouve « dans tout et n’importe quoi ».

Nous allons donc voir son implémentation avec .NET.

 
2) Exemples d’implémentation C# (thread-safe)

a. Exemple simple

public sealed class MyClass
{
    private static MyClass _instance = null;
    private static readonly object _lock = new object();

    private MyClass()
    {
       
    }

    public static MyClass Instance
    {
        get
        {
            lock(_lock)
            {
                if (_instance==null)
                {
                    _instance = new MyClass();
                }
                return _instance;
            }
        }
    }
}

Le bout de code ci-dessus suffirait à la plupart des cas. Mais dans un contexte multithread, il se peut que nous rencontrerions un problème : les deux threads pourraient arriver au même moment dans la section critique. Dans ce cas, l’instance sera crée deux fois et risque de poser problème.

Pour remédier à ce problème, il existe le Double Checked Locking (verrouillage à double test).

b. Double Checked Locking

Comme dit précédemment, le Double Checked Locking va permettre de rendre notre code plus sécurisé dans un contexte multithread. On va vérifier par deux fois si l’instance n’a pas été crée, pour éviter que deux threads le fasse au « même moment » (comme ça peut arriver dans l’exemple a).

public sealed class MyClass
{
    static MyClass _instance = null;
    static readonly object _lock = new object();
                
    private MyClass()
    {     
    }

    public static MyClass Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new MyClass();
                    }
                }
            }
            return _instance;
        }
    }
}

public sealed class MyClass
{
    private static readonly MyClass _instance = new MyClass();
    
    private MyClass()
    {
    }
        
    public static MyClass Instance
    {
        get
        {
            return _instance;
        }
    }
 }