Bonjour à tous,

j'ai un petit soucis d'architecture logicielle. Voilà je développe une appli winform en C# qui a une petite fenêtre dans laquelle l'utilisateur peut régler l'appli en manipulant des données globales ( évidemment).

Ces paramètres sont enregistrés dans la base de données sql server qui alimente l'application. Pour çà j'ai une petite table param.

J'ai dois donc pouvoir lire et enregistrer depuis et dans cette table, les modifications de parametres de l'appli. Pour faire çà j'ai effectué des recherches ("variables globales") sur le forum et je suis tombé sur des discussions interessante traitant des classes static et des singleton.

Je pense avoir saisis le fonctionnement de l'une et l'autre méthode. Avec le singleton j'ai l'assurance qu'il n'existera qu'une seule instance de mon objet. Ce dernier étant visible de l'application entière.

Pour en venir au but, j'ai deux soucis.
Le premier est que je ne suis pas certain de l'avoir implémenter comme il faut. Ci dessous mon code commenté avec ce que j'ai compris. Si quelqu'un veut me reprendre en cas d'erreur ...

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 // sealed permet d'interdire l'heritage si je me trompe pas
public sealed class SingletonMesParam
{
        private string p_param1;
        private string p_param2;
        private string p_param3;

        public string param1
        {
            get{return p_param1;}
            set{p_param1 = value;}
        }
        public string param2{//etc ...}
        public string param3{//etc ...}
        
      //constructeur privé - du coup pas possible d'avoir d'autre instance
      private SingletonMesParam()
      {
            // 
            // TODO : ajoutez ici la logique du constructeur
            //
            this.LireDepuisBDD(); 
      }

        // cette ligne je comprend pas a quoi elle sert, je l'ai repiqué sur un exemple
        private static SingletonParamLiv _SingletonParamLiv;
        
         // Ce bloc me permet d'obtenir une instance ( est elle unique ?)
        // si l'objet n'est pas instancié, on appelle le constructeur qui appelle 
         public static SingletonParamLiv GetInstance()
        {
            if (_SingletonParamLiv == null) 
            { 
                 //je comprend toujours pas. C'est quoi ce _SingletonParamLiv.
                _SingletonParamLiv = new SingletonParamLiv(); 
            }
            return _SingletonParamLiv; 
        }

        public void LireDepuisBDD(string sChaineCon)
        {
              // ici code d'accès au données et on valorise
             // les propriétés de l'objet
        }

}
Le deuxieme est que j'ai essayé de comparer l'utilisation des classes static avec l'implémentation ci dessus et je ne comprend pas la différence. Est ce que quelqu'un pourrait m'aider à y voir plus clair.


Merci d'avance.


mots clés : singleton design pattern variables globales parametre