Discussion :

[Troopers]

Bonjour,

J'ai une classe de base avec une propriété statique afin de renvoyer une instance unique.

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
 
public class MyBase
{
       protected statique MyBase oCurrentInstance;
 
       public static MyBase Current
       {
               get
               {
                       if(object.ReferenceEquals(oCurrentInstance, null))
                       {
                                   oCurrentInstance = new MyBase();
                                   oCurrentInstance.Load();
                       }
                       return oCurrentInstance;
               }
       }
}

Je voudrai créer des classes qui héritent de cette classe, est-il possible de modifier la propriété Current pour que l'instance soit du type de la classe héritée sans avoir à surcharger la propriété dans toutes les classes héritantes?
En fait, je cherche un équivalent à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

oCurrentInstance = this.GetType().CreateInstance();

mais en static cela n'est pas possible

[chrisdot]

Hello,

J'ai peut-être pas tout compris sur ce que tu essaies de faire, mais tu ne peux pas surcharger ta propriété Current (car statique). En tout cas ça s'appelle un singleton ce que tu viens d'écrire.
Je n'ai pas compris si tu dois avoir une seule instance quelle que soit le sous type, ou au max une de chaque type.??
Je pense que si tu vas voir du côté du pattern fabrique abstraite tu devrais trouver ton bonheur (en cobinant singleton + fabrique abstraite). Je suppose qu'il y a bien un paramètre qui va te faire instancier une classe plutôt qu'une autre.

Christophe

[Troopers]

Tel que ma classe de base est écrite (cf mail précédent), je suis obligé de faire dans chaque classe héritante :

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
public class InheritedClass:MyBase
{
	public static new InheritedClass Current
	{
		get
		{	
			if(object.ReferenceEquals(cCurrentInstance, null))
			{
				cCurrentInstance = new InheritedClass();
				cCurrentInstance.Load();
			}
			return (InheritedClass)cCurrentInstance;
		}
	}
}

et l'appel est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

MyBase oBase = InheritedClass.Current

J'aimerai ne pas écrire le code de InheritedClass, mais que la classe de base récupère le type appelant (cf le code de l'appel) et crée une instance de ce type. C'est pourquoi je pensais à this.GetType().CreateInstance()

Une factory ne va pas m'aider car je ne souhaite pas appeler une méthode je veux rester avec ma propriété Current qui est déjà une factory en soit... sauf que cette factory ne connais pas le type de l'objet à créer d'où mon problème!

[chrisdot]

Tu ne peux pas utiliser "this", puisque c'est une méthode statique, et en plus elle n'est pas encore instanciée.
Mais à quel niveau sais-tu quelle classe doit être instanciée?
Et sinon, par rapport à mon autre question:

Je n'ai pas compris si tu dois avoir une seule instance quelle que soit le sous type, ou au max une de chaque type.?

Sinon, en continuant sur ton idée, on peut faire un truc du style (mais je vois un intérêt limité, autant écrire une méthode "Current" par classe):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
public static MyBase GetCurrent(type o)
{
//on retourne une instance du type donné
}

je suppose qu'il y a même moyen de mettre un generic la dessus.

A+

[Troopers]

Mais à quel niveau sais-tu quelle classe doit être instanciée?

C'est l'appel qui détermine le type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

MyBase oBase = InheritedClass.Current

oBase est de type InheritedClass donc dans Current je cherche à savoir sur quel classe l'appel a eu lieu

Je n'ai pas compris si tu dois avoir une seule instance quelle que soit le sous type, ou au max une de chaque type.?

au max une de chaque type

Je suppose qu'il y a bien un paramètre qui va te faire instancier une classe plutôt qu'une autre

Oui, le type sur lequel a été fait d'appel

Sinon, en continuant sur ton idée, on peut faire un truc du style (mais je vois un intérêt limité, autant écrire une méthode "Current" par classe):

Oui j'ai bien pensé faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public static MyBase GetCurrent<T>() where T : MyBase, new()
{
	if(object.ReferenceEquals(cCurrentInstance, null))
	{
		cCurrentInstance = new T();
		cCurrentInstance.Load();
	}
	return (T)cCurrentInstance;
 
}

Mais je voudrais garder la propriété Current pour ne pas modifier tous les appels existant.

Question: une proprité générique ça existe???

[Troopers]

@cinemania :

Merci cela correspond bien à ce que je veux faire mais as tu une solution pour faire ça en tant que propriété de la classe de base?

[chrisdot]

Peut être que ce lien pourra t'aider?

[cinemania]

Quelque soit le langage, on ne peut pas redéfinir une méthode static, on peut au mieux la cacher pour la "remplacer"/"occulter".

Si j'ai bien compris ton problème tu souhaite que chacune des classes qui héritent ne soit instanciables qu'une seule et unique fois via le design pattern du Singleton.

En fait la problématique, c'est qu'il sera possible d'instancier toutes les classes de ton arbre au moins une fois et tu risque d'avoir des problèmes ne termes d'instances...

Si seule une et seule et unique classe héritière doit pouvoir être instanciée en fonction de celle qui te choisi pour une exécution de ton appli donnée, je te suggère de mettre le champ dans la classe ancêtre et un code de propriété spécifique appelant une méthode ancêtre (tjs en static) qui vérifie que l'instance n'est pas déja définie

utiliser une méthode static dans la classe de base utilisant les generics te permettrait d'instancier dynamiquement la bonne sans réécrire systèmatiquement le code, surtout si cette méthode de construction est de type protected.

Il faut savoir parfois sortir des sentiers battus et faire abstraction des design pattern.

tu peux même utiliser un dictionary static caché dans l'ancêtre avec un Type comme clé, et une instance de ce même Type comme valeur.
(donc object) et tu fait un cast au niveau de ton accesseur get sur le singleton de ton héritière...

voici un code qui pourrait remplir tes besoins

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
 
public abstract class SingletonBase
{
    protected static Dictionary<Type, object> s_Singletons;
    protected static T CreateSingleton<T>() where T: SingletonBase, new()
    {
        lock (typeof(SingletonBase))
        {
            if (s_Singletons == null) s_Singleton = new Dictionary<Type, object>();
            T single = null;
            if (!s_Singletons.TryGetValue(typeof(T), out single))
                s_Singletons.Add(typeof(T), single = new T());
            return single;
        }
    }
}
public class MyBase : SingletonBase
{
    public static MyBase Singleton { get { return CreateSingleton<MyBase>(); } }
 
//...
    private MyBase() 
    {
    }
}
public class MyInherits : MyBase
{
    public static new MyInherits Singleton { get { return CreateSingleton<MyInherits>(); } }
 
//...
 
    private MyInherits : base()
    {
    }
}

j'ai juste un petit doute sur le code de SingletonBase...
effectivement j'ai imposé que les classes décrites par T devaient être instanciable, mais j'ignore si cette portabilité ne va pas poser problème

si les "domaines" de visibilité devaient poser problème tu peux remplacer le code de la méthode généric par ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
    protected static T CreateSingleton<T>() where T: SingletonBase
    {
        lock (typeof(SingletonBase))
        {
            if (s_Singletons == null) s_Singleton = new Dictionary<Type, object>();
            T single = null;
            if (!s_Singletons.TryGetValue(typeof(T), out single))
                s_Singletons.Add(typeof(T), (T)Activator.CreateInstance(typeof(T), true));
            return single;
        }
    }

Personellement je déteste utiliser ce type de code et préfere utiliser une singleton factory qui est seule à pouvoir instancier les classes que je dois possèder sous forme d'instances unique,

d'ailleurs ce code n'est qu'une abstraction de la singleton factory remise directement dans la classe qui utilise le singleton, mais je trouve que cette écriture n'est pas heureuse, car tu mélange alors les concepts.
il est préférable à mon sens de recourrir à une factory externe qui instanciera le type en ayant recours à la reflection.
Certes je sais la reflection c'est long, blablabla, mais là on parle de singletons... donc la perte de temps inhérente au mécanisme de reflection est ici un sacrifice que l'on peut aisément consentir.