Héritage d'instance statique

Bonjour,

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

Code:

---

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:

---

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

---

mais en static cela n'est pas possible

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

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

Code:

---

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:

---

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!

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:

Citation:

---

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:

---

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+

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:

---

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:

---

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.

Citation:

---

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

---

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

Code:

---

MyBase oBase = InheritedClass.Current

---

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

Citation:

---

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

Citation:

---

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

Citation:

---

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:

---

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???

@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?

la problématique c'est que techniquement parlant, les classe qui hérite de ta classe mère, n'héritent pas du membre du static car son contexte est static donc en dehors de tout "héritage".

certes tu l'appel par InheritClass.Current mais techniquement parlant il n'y a pas notion d'héritage.
d'ailleurs le problème c'est que même en traçant la pile d'appel je ne suis pas sure qu'on arrive à obtenir le type sur lequel tu as réellement inféré l'appel.
de plus Current renverrais tjs un MyBase (certes instancié comme un InheritClass) mais tu devrais tjs faire le cast toi même.
il existe peut être une solution du coté de l'émission de code et des délégués anonymes mais là je ne suis pas un spécialiste.

il y a peut etre une lueur d'espoir avec C# 4 et le fait que le type object puisse être utilisé de façon polymorphe indépendemment de son type sans cast, mais le procédé est lent car derrière se cache la reflection.

Là le truc c'est surtout que je ne vois pas depuis la classe MyBase comment récupérer le type sur lequel le membre static a été réellement appelé...

Peut être que ce lien pourra t'aider?

@chrisdot
Merci pour lien.

L'article est intéressant même si franchement je n'ai pas tou compris:roll:

Mais cela m'apporte une solution :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public class MyBase<T> where T:new() { private static T cCurrentInstance;   public static T Current { get { if(object.ReferenceEquals(cCurrentInstance, null)) { cCurrentInstance = new T(); } return (T)cCurrentInstance; } }   protected MyBase() { } }

---

Merci à vous deux