Discussion :

[Benbout]

Bonsoir,
je souhaite ajouter de nouveaux composants à un objet en fonction de son patron de conception.

Diagramme simplifié (des prop et méthodes en moins ainsi que des classes dérivées d'ActorMod réduites à une seule pour que cela reste lisible) :



- une classe ActorManager qui gere des instances d'Actor.
- une classe Actor qui représente un objet Actor lui meme défini par un template représenté sous la forme d'une classe que j'appellerais ActorDefinition. (en fonction du template, certains champs / props sont modifiés dans la classe Actor, non visible dans ce diagramme simplifié)
- une classe ActorMod qui me sert de composant primaire et qui contient des méthodes dont certaines virtual. (exemple OnActorCreated(Actor actor) )
- des classes dérivées d'ActorMod instanciées selon certaines spécificité du template.



Concernant mes deux méthodes pour rechercher un composant précis de l'objet :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        public T GetComponent<T>()
        {
            return GetComponentInternal(typeof(T));
        }
 
        private dynamic GetComponentInternal(Type type)
        {
            foreach (var mod in ActorMods)
            {
                if (mod.GetType() == type) return mod;
            }
 
            return null;
        }

A vrai dire, cela ne me parait pas très propre, j'ai l'impression que le corps de ma fonction GetComponentInternal est mal défini et le mot clé dynamic me gene dans cette situation (peut etre lié au fait que c'est l'une des rares fois que je l'utilise depuis mes premiers pas sur c#) mais je n'ai pas trouvé d'autres solutions. Auriez vous mieux à proposer concernant les méthodes de récupération d'un composant de mon objet ?

[ericlm128]

ActorModCorpse dérive de ActorMod, c’est cela ?

Je ne suis pas un spécialiste mais j'essaie de comprendre ce que fait GetComponent<T>()
- Il te retourne le premier élément de ton tableau ActorMods[] qui correspond exactement au type demandé
- Sans prendre en compte l'héritage, car il n'est pas faux de dire qu'un objet de type ActorModCorpse est aussi de type ActorMod.

Je te proposer ceci, regrouper des deux méthodes en une seule via une expression linq :

Code c# :

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

1
2
3
4
        public T GetComponent<T>()
        {
            return ActorMods.OfType<T>().Where(a => a.GetType() == typeof(T)).FirstOrDefault<T>();
        }

Après on pourrait en laisser deux méthodes si tu as besoin de cette structure.

Je n'utilise plus le type dynamic qui as été créé pour simplifier l'écriture lors d'utilisation d'objets COM (j’avait des fuites mémoires qui ont disparu lorsque j'ai utiliser les types réelles).
Je ne l'ai jamais utiliser en dehors de ce cadre la d’ailleurs.

[François DORIN]

Bonjour,

Pour ma part, j'aurais simplement fait ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public T GetComponent<T>() where T: class
{
   return GetComponentInternal<T>() as T;
}
 
private ActorMod GetComponentInternal<T>() where T: class
{
   Type type = typeof(T);
   foreach (var mod in ActorMods)
   {
      if (mod.GetType() == type) return mod;
   }
   return null;
}

Eventuellement, je n'aurais même gardé qu'une seule méthode.

[ericlm128]

Oui pas bête on peu ajouter la contrainte sur le type de base

Code c# :

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

1
2
3
4
        public T GetComponent<T>() where T : ActorMod
        {
            return ActorMods.OfType<T>().Where(a => a.GetType() == typeof(T)).FirstOrDefault<T>();
        }

Le dernier <T> étant facultatif

Code c# :

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

1
2
3
4
        public T GetComponent<T>() where T : ActorMod
        {
            return ActorMods.OfType<T>().Where(a => a.GetType() == typeof(T)).FirstOrDefault();
        }

Et le test pouvant être effectuer dans FirstOrDefault

Code c# :

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

1
2
3
4
        public T GetComponent<T>() where T : ActorMod
        {
            return ActorMods.OfType<T>().FirstOrDefault(a => a.GetType() == typeof(T));
        }

[Benbout]

Eric, Francois, merci pour vos réponses. Concernant les conditions Eric, c'est tout à fait cela. Encore une fois, linq fait des miracles dans votre fonction, j'avais déja eu affaire avec la méthode .OfType<T> une fois, oubliant aujourdhui qu'elle existait. Je vais garder la derniere méthode que vous avez posté, la contrainte établie sur le type par Francois était exactement ce que je cherchais à faire aussi sans pouvoir y arriver. Et oui, une seule méthode suffit, j'en ai créé deux n'arrivant pas à solutionner mon probleme en une seule, je comptais factoriser tout cela après avoir trouvé la solution, vous m'avez maché le travail, je ne vais pas m'en plaindre .

Vos réponses confirment implicitement mes lacunes vis à vis de la bibliothèques linq, il est temps de m'y plonger plus ardemment.

[François DORIN]

A noter que le OfType est totalement superflue ici, dans la mesure où ensuite tu compares directement les types, simplifiant encore plus la requête Linq

Code :

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

1
2
3
4
public T GetComponent<T>() where T : ActorMod
{
   return ActorMods.FirstOrDefault(a => a.GetType() == typeof(T));
}

[ericlm128]

Merci mais sans cela j'ai une erreur

Erreur CS0266 Impossible de convertir implicitement le type 'Forum_deriver_et_T.ActorMod' en 'T'. Une conversion explicite existe (un cast est-il manquant*?) Forum deriver et T

Sinon avec le cast comme conseillé

Code C# :

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

1
2
3
4
        public T GetComponent<T>() where T : ActorMod
        {
            return (T) ActorMods.FirstOrDefault(a => a.GetType() == typeof(T));
        }

[François DORIN]

Très juste ! Il faut un cast supplémentaire dans ce cas. Au temps pour moi...