Discussion :

[Pfeffer]

Bonjour,

J'ai une classe A et plusieurs classe B,C,D, etc. qui hérite de A.

J'aimerais faire ceci sous forme dynamique sachant que dans listBody j'ai un ensemble d'objet A:

Code :

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

1
2
3
 
(from tmp in listBody
 select ((B)tmp).Value).Distinct().ToList();

En fait faire le cast (B)tmp dynamiquement en fonction du type d'objet dans la liste (ex: (C)tmp ou (D)tmp, etc. )
Est ce possible ?

[Invité]

Je n'ai pas trop bien compris ta question mais si tu es sûr que, dans listBody, tout tes éléments sont du type U alors il suffit de faire listBody.Cast(Of U)().Select(p => p.Value).Distinct().ToList().

[Pfeffer]

En fait je veux dynamiser ce cast et faire une méthode générique.
Dans ma liste passée en paramètre j'ai du B mais je peux lui passer aussi du C, D, E.
J'espère qu'avec l'exemple ci-dessous ce sera plus clair...

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
 
 
public class A{
}
 
public class C : A{
int Value;
}
 
public class D : A{
int Value;
}
 
public class E : A{
int Value;
}
 
public void castMehod(List<A> listA)
{
           (from tmp in listBody
            select ((B)tmp).Value).Distinct().ToList(); // ICI: comment faire pour faire mon cast dynamiquement en fonction de ce qui a dans List<A> ?
 
}

[Invité]

Pourquoi ne pas tout simplement mettre la propriété Value dans la classe de base A ? C'est soit déplacer la propriété dans A ou soit ton exemple est pourri

[Pragmateek]

Comme indiqué par Holty le plus simple serait de définir la propriété Value au niveau de A si elle est partagée par toutes les sous-classes.

Si ton use-case n'est pas aussi trivial alors voici plusieurs solutions, classées par ordre de :
- complexité de ton cas d'utilisation : du plus simple au plus complexe
- facilité d'implémentation : de la plus directe à la plus alambiquée
- qualité du design : du plus OO-compliant au moins
- performance : de la plus performante à la moins
(oui tous ces critères sont parfaitement alignés )

1) La plus simple et propre, si tu a accès aux types, est de définir une interface IValue avec une propriété Value :

Code :

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

1
2
3
4
interface IValue
{
    int Value { get; set; }
}

Et de la faire implémenter par tes classes :

Code :

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

1
2
3
4
class B : IValue
{
    public int Value { get; set; }
}

Et la méthode aurait cette signature :

Code :

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

public void castMehod(List<IValue> list)

2) Si tu ne peux pas intervenir de cette façon alors tu peux définir une méthode par type (B, C ou D) et rediriger vers chacune selon le type du 1er élément.

Et si tu ne veux pas exposer ces méthodes pour ne pas trop polluer ton code tu peux utiliser un mapping, une de mes techniques favorites

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
static readonly IDictionary<Type, Func<A, int>> mapping = new Dictionary<Type, Func<A, int>>
{
    { typeof(B), a => ((B)a).Value },
    { typeof(C), a => ((C)a).Value },
    { typeof(D), a => ((D)a).Value }
};
 
static IList<int> GetValues(IList<A> listOfA)
{
    return listOfA.Select(mapping[listOfA.First().GetType()]).ToList();
}
 
static void TestListOfA()
{
    IList<A> bs = new[]{ new B { Value = 1 }, new B { Value = 2 }, new B { Value = 3 } };
    IList<A> cs = new[]{ new C { Value = 4 }, new C { Value = 5 }, new C { Value = 6 } };
    IList<A> ds = new[]{ new D { Value = 7 }, new D { Value = 8 }, new D { Value = 9 } };
 
    IList<int> bValues = GetValues(bs);
    IList<int> cValues = GetValues(cs);
    IList<int> dValues = GetValues(ds);
 
    foreach (int bValue in bValues) Console.Write(bValue + " ");
    Console.WriteLine();
    foreach (int cValue in cValues) Console.Write(cValue + " ");
    Console.WriteLine();
    foreach (int dValue in dValues) Console.Write(dValue + " ");
    Console.WriteLine();
}

3) Enfin si tu ne connais pas tous les types à l'avance, ou bien qu'il y en a des 10aines alors tu peux aussi utiliser de la réflexion et faire du duck-typing mais en terme de performances ça ne va plus être la même chose.
Mais si tu n'as pas de contrainte de ce côté c'est envisageable, tout en sachant que ça risque d'obfusquer ton code.

Voilà tu as l'embarras du choix.

[Pfeffer]

Merci pour vos interventions.
Pour info :

- [Pragmateek]: j'ai utilisé ta méthode de mapping qui me convient pas mal. Mais je vais encore essayer avec l'interface, je n'y avais pas forcément pensé.
Le hic c'est que cette implémentation va être lourde au niveau développement de mon côté.

- [h2s84]: je ne peux pas mettre ma valeur dans la classe mère vu qu'elle n'est pas commune à toutes les classes filles.