Design pattern: Singleton en C#

 Définition des design patterns

Un patron de conception (design pattern en anglais) est un concept de génie logiciel destiné à résoudre les problèmes récurrents suivant le paradigme objet. En français on utilise aussi le terme motif de conception qui est une traduction alternative de design pattern, perçue comme incorrecte par certains.

Les patrons de conception décrivent des solutions standard pour répondre à des problèmes d'architecture et de conception des logiciels. À la différence d'un algorithme qui s'attache à décrire d'une manière formelle comment résoudre un problème particulier, les patrons de conception décrivent des procédés de conception généraux. On peut considérer un patron de conception comme une formalisation de bonnes pratiques, ce qui signifie qu'on privilégie les solutions éprouvées.

Il ne s'agit pas de fragments de code, puisque les patrons de conception sont le plus souvent indépendants du langage de programmation, mais d'une méthode de conception, c’est-à-dire d'une manière standardisée de résoudre un problème qui s'est déjà posé par le passé. Le concept de patron de conception a donc une grande influence sur l'architecture logicielle d'un système.

On peut donc considérer les patrons de conception comme un outil de capitalisation de l'expérience appliqué à la conception logicielle.

Source wikipedia.

Les design patterns peuvent être découpés en trois grandes catégories :

• Les modèles de création : Ces modèles sont très courants pour déléguer à d'autres classes la construction des objets.
• Les modèles de structure : Ces modèles tendent à concevoir des agglomérations de classes avec des macro-composants.
• Les modèles de comportement : Ces modèles tentent de répartir les responsabilités entre chaque classe (l'usage est plutôt dynamique).

Nous allons voir maintenant un des ces patterns, qui appartient a la famille des modèles de création avec une implémentation en c#.

Design pattern: Singleton

Rôle

Le but de ce pattern est d'assurer qu'il n'y a qu'une seul instance d'une class tout en permettant l'accès à cette instance depuis n'importe quel point de notre application, de plus l'objet n'est instancier qu'au moment de sa première utilisation et c'est à la class elle même d'assurer toutes ces contraintes.

Implémentation

On peut appliquer ce pattern à n'importe quel class existante en :

1. Modifiant la portée de son/ses constructeurs car il faut interdire la création d'objets de l'extérieur de la class.
2. Exposant une propriété permettant d'obtenir l'unique objet instancié.

public class Singleton
{
    private static Singleton _instance;
    private static readonly object synchro = new object();
 
    // constructeur privé
    private Singleton()
    {
        /*          * initialisation de l'objet          */
    }
 
    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (synchro)
                {
                    if (_instance == null)
                    {
                        _instance = new Singleton();
                    }
                }
            }
            return _instance;
        }
    }       
}

Vous remarquerai que notre Singleton est "thread safe", ce qui veut dire qu'il n'y aura qu'une seul instance même entre plusieurs threads.

Utilisation

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Singleton.Instance.GetHashCode());
        Console.WriteLine(Singleton.Instance.GetHashCode());
 
        Console.WriteLine(new object().GetHashCode());
        Console.WriteLine(new object().GetHashCode());
 
        Console.ReadLine();
    }
}

Ce programme affichera le même HashCode deux fois (ce qui montre que c'est le même objet dans les deux premières lignes) ensuite il affichera deux hash code différent (car on crée deux objets différents).

Une autre implementation thread-safe et qui en plus générique(c'est-à-dire qu'elle implemente le pattern singleton pour tous nos classes)

using System;
 
namespace IntelliX.Helper
{
    public class Singleton<T> where T : class, new()
    {
        private Singleton()
        { }
 
        private 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; }
        }
    }
}
 

Merci pour la société Intellix qui a bien voulu partager avec nous ce code qu'elle utilise chaque jour en production.