Cast de liste générique

Version imprimable

Bonjour,
Voilà, j'expose le problème :
soit deux objets :
- un objet A contenant une EntityCollection<T>
- un objet B du même type T
- une fonction dans laquelle je dois ajouter l'objet B dans la EntityCollection<T> de l'objet A
- la fonction prend en paramètres les deux objets ci-dessus et le nom de la propriété de l'objet A à laquelle ajouter l'objet B
- je connais le nom de la propriété de type EntityCollection<T> à laquelle je dois ajouter l'objet de type T
- je sais que le premier objet contient une EntityCollection<T>

Dans ma fonction, par réflexion, j'arrive à retrouver la propriété de type EntityCollection<T> grâce à son nom.
Maintenant que j'ai cette propriété, j'aimerais pouvoir y ajouter l'objet B.
Mais pour cela, il me faut caster la propriété pour obtenir la fonction Add() et caster l'objet B pour pouvoir le passer à la fonction Add()

Ca ressemblerait à ceci :
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 36 37 38 39 40 41 42 43 44 45 public class Obj1 : EntityObject { public string Name; } public class Obj2 : EntityObject { public string Name; } public class ObjetA1 { public EntityCollection<Obj1> LstO1 { get; set; } public ObjetA1() { LstO1 = new EntityCollection<Obj1>(); } } public class ObjetA2 { public EntityCollection<Obj2> LstO2 { get; set; } public ObjetA2() { LstO2 = new EntityCollection<Obj2>(); } } private void AddToList(object objA, object objB, string propName) { PropertyInfo pi = objA.GetType().GetProperty(propName); ((EntityCollection<Obj1>)pi.GetValue(objA, null)).Add((Obj1)objB); } private void button4_Click(object sender, EventArgs e) { ObjetA1 obj = new ObjetA1(); Obj1 obj1 = new Obj1(); obj1.Name = "OBJ1"; AddToList(obj, obj1, "LstO1"); }
Dans AddToList il faut que je puisse remplacer Obj1 par le type réel (génériquement) de l'objet objB.
Et là je bute sur ces cast...
Ca devrait être possible mais il y quelque chose que je fais de travers...
Quelqu'un aurait-il une idée de la bonne méthode à employer ??

Essaies quelque chose comme ça, tu tireras avantage de la généricité

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
36
37
public class Obj1 : EntityObject
  {
    public string Name;
  }
 
  public class Obj2 : EntityObject
  {
    public string Name;
  }
 
  public class ObjetA<T> where T:EntityObject
  {
    public EntityCollection<T> LstO { get; set; }
 
    public ObjetA1()
    {
      LstO = new EntityCollection<T>();
    }
 
    public void AddObj(T obj){
        this.ListO.add(obj);
    }
 
  }
 
 
 
    private void button4_Click(object sender, EventArgs e)
    {
      ObjetA<Obj1> objA1 = new ObjetA<Obj1>();
      Obj1 obj1 = new Obj1();
      objA1.add(obj1);
 
      ObjetA<Obj2> objA2 = new ObjetA<Obj2>();
      Obj2 obj2 = new Obj2();
      objA2.add(obj2);
    }

27/01/2011, 14h00
ppphil

le problème est que ObjA1 et ObjA2 sont déjà déclarés et que je ne peux pas y toucher....

c'est vrai que t'es alors un peu limité,

tu peux faire sinon

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
 
private void AddToList<T>(EntityCollection<T> List,T obj) where T:EntityObject{
    List.add(obj);
}
 
 private void button4_Click(object sender, EventArgs e)
    {
      ObjetA1 obj = new ObjetA1();
      Obj1 obj1 = new Obj1();
      AddToList<Obj1>(obj.LstO1 , obj1);
    }

C'est plus propre que la reflection

C'est bon, j'ai trouvé...
Une EntityCollection<TEntity> demande un type bien précis. Par contre, elle implémente un ICollection<T> qui ne demande pas de précision quant au type.

Code:

EntityCollection<TEntity> : RelatedEnd, ICollection<TEntity>, IEnumerable<TEntity>, IEnumerable, IListSource where TEntity : class, System.Data.Objects.DataClasses.IEntityWithRelationships

Alors la solution est la suivante :
Code:

1 2 3 4 5 6 private void AddToEntityCollection<T>(object objA, T objB, string propName) { PropertyInfo pi = objA.GetType().GetProperty(propName); ((ICollection<T>)pi.GetValue(objA, null)).Add(objB); }
Merci polkduran

Ouais, ben ça ne joue pas... Faux espoir....
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 private void AddToEntityCollection<T>(object objA, T objB, string propName) { PropertyInfo pi = objA.GetType().GetProperty(propName); ((ICollection<T>)pi.GetValue(objA, null)).Add(objB); } private void button5_Click(object sender, EventArgs e) { EntityObject obj1; EntityObject obj2; string listName; //Obtention de obj1 et obj2 et listName par désérialisation AddObjectToEntityCollection(obj, obj1, listName); }
En fait, je ne connais que le type parent des deux objets soit EntityObject.
Je les obtient par désérialisation.
et la ligne

Code:

((ICollection<T>)pi.GetValue(objA, null)).Add(objB);

geule au p'tits pois comme quoi

Citation:

Impossible d'effectuer un cast d'un objet de type 'System.Data.Objects.DataClasses.EntityCollection`1[WindowsFormsApplication10.Obj1]' en type 'System.Collections.Generic.ICollection`1[System.Data.Objects.DataClasses.EntityObject]'.

28/01/2011, 15h24
Nathanael Marchand

Euh c'est dangereux ce que tu fais la!
Il n'y a aucune relation d'héritage entre Obj1 et Obj2, le cast est plutot hasardeux!

Oui, excuse-moi, je me suis un peu mélangé les pinceaux.
Revoici la définition des class

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
 
  public class Obj1 : EntityObject
  {
    public string Name;
  }
 
  public class Obj2 : EntityObject
  {
    public string Name;
  }
 
  public class ObjetA1 : EntityObject
  {
    public EntityCollection<Obj1> LstO1 { get; set; }
 
    public ObjetA1()
    {
      LstO1 = new EntityCollection<Obj1>();
    }
  }
 
  public class ObjetA2 : EntityObject
  {
    public EntityCollection<Obj2> LstO2 { get; set; }
 
    public ObjetA2()
    {
      LstO2 = new EntityCollection<Obj2>();
    }
  }

et les fonctions

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
     private void AddToEntityCollection<T>(object objA, T objB, string propName)
    {
      PropertyInfo pi = objA.GetType().GetProperty(propName);
      ((ICollection<T>)pi.GetValue(objA, null)).Add(objB);
    }
 
    private void button5_Click(object sender, EventArgs e)
    {
      EntityObject obj1;
      EntityObject obj2;
      string listName;
 
      //Obtention de obj1 et obj2 et listName par désérialisation
 
      AddObjectToEntityCollection(obj1, obj2, listName);
 
    }

Et ce que je ne comprends pas c'est ceci :

Code:

1
2
3
4
5
6
7
8
9
10
 
     private void AddToEntityCollection<T>(EntityObject objA, T objB, string propName)
    {
      MessageBox.Show(typeof(T).ToString());
      //Affiche System.Data.Objects.DataClasses.EntityObject
      MessageBox.Show(objB.GetType().ToString());
      //Affiche MonApplication.Obj1
      PropertyInfo pi = objA.GetType().GetProperty(propName);
      ((ICollection<T>)pi.GetValue(objA, null)).Add(objB);
    }

28/01/2011, 16h38
Guulh
Tu appelles AddObjectToEntityCollection sans spécifier explicitement le type <T>, ce qui est normal puisque tu ne le connais pas statiquement. Je suppose que ton désérializer va instancier un objet héritant de EntityObject, que tu vas coller dans obj2 après.

Donc dans le contexte de ta méthode générique, T = EntityObject. La propriété que tu récupères par réflexion est un EntityCollection<Obj2>, qui n'implémente pas ICollection<EntityObject>, ICollection n'étant pas (à ma connaissance) ni covariant ni contravariant. Ca explique pourquoi ton cast lève une exception.
Donc je ne pense pas que tu puisses avoir une référence typée vers la collection à laquelle tu veux rajouter un item. Puisque tu bosses déjà par réflexion, le plus simple est à mon avis d'appeler la méthode "Add" par réflexion. En pseudo-code (j'ai la flemme de vérifier) :
Code:

1 2 3 4 PropertyInfo pi = objA.GetType().GetProperty(propName); object laCollection = pi.GetValue(objA, null)); MethodInfo addMethod = laCollection.GetType().GetMethod("Add"); addMethod.Invoke(objB);
Pour être bien précis : les génériques n'ont pas un comportement dynamique. C'est à dire:
Code:

1 2 3 4 5 class Mere { } class Fille : Mere { } public void F<T>() { } Mere m = new Fille(); F(m); // équivaut à F<Mere>(m), pas à F<Fille>
28/01/2011, 16h41
Nathanael Marchand

Désolé d'être désagréable mais je comprends rien à ta bidouille :aie:
Quel est le besoin derrière ?

(En reflechissant un peu je crois que c'est un problème de co ou contra-variance, meme si Obj1 est un EntityObject il n'est pas possible de dire que ICollection<Obj1> est une ICollection<EntityObject> sur le framework 3.5, ca existe à partir du 4)

Edit: Han grillé par guulh :(

Edit2: Voici les covariances et contravariances implémentées en .Net

Citation:

IEnumerable<T> (covariant)
IEnumerator<T> (covariant)
IQueryable<T> (covariant)
IGrouping<TKey, TElement> (covariant)
IComparer<T> (contravariant)
IEqualityComparer<T> (contravariant)
IComparable<T> (contravariant)
Action<T> et ses frères et soeurs (contravariants)
Func<TResult> et Func<T, TResult> (TResult est covariant; T,T1,T2 sont contravariants)
Predicate<T> (contravariant)
Comparison<T> (contravariant)
Converter<TInput, TOutput> (TInput est contravariant; TOutput est covariant.)

Source
28/01/2011, 17h07
Guulh

Citation:

Envoyé par PitMaverick78

Voici les covariances et contravariances implémentées en .Net

Merci :) il me semblait bien à vu de nez qu'il y a des choses qu'on peut faire à une collection de filles mais pas à une collection de mères et réciproquement (toute grivoiserie mise à part :aie:), ce qui explique l'absence de covariance et contravariance.