Discussion :

[m3z91]

Bonjour

Voici un problème à la fois simple et compliqué (pour moi)

Je travail en Dot Net 2.0.

Je défini

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
36
 
public class maclass :ImonInterface
{
 
}
 
 
et 
 
public class maclassDeuxLeretour
{
      private List<ImonInterface> _maliste= null;
 
      .... 
 
      public void MaMethode(ref IList<ImonInterface> maliste)
     {
           _malist = malist;
     }
 
    ....
 
 
}
 
 
et enfin quelque part dans le code .... loin très loin ....
 
maclassDeuxLeRetour _maclassDeuxLeRetour = new maclassDeuxLeRetour();
List<maclass> _maclass = new List<maclass>();
 
... 
_maclass.Add(new maClass());
...
 
 _maclassDeuxLeRetour .MaMethode (ref (IList<ImonInterface>)_maliste)

et là à la compile, c'est le drame

=>

Argument '1'*: impossible de convertir de 'ref System.Collections.Generic.IList<Espace.maClass>' en 'ref System.Collections.Generic.IList<Espace.ImonInterface>'

Mais pourquoi donc ?

Y a-t-il une manière de contourner le problème, voir une autre approche (si possible en évitant le code unsafe).

Je passe une List<ImonInterface> car l'object de la liste n'est pas forcement de type maClass mais il implémente toujours l'interface ImonInterface.

Merci de votre aide

[ostenhard]

Bonjour,

Essaye plutôt :

Code :

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

1
2
3
4
5
6
7
8
maclassDeuxLeRetour _maclassDeuxLeRetour = new maclassDeuxLeRetour();
List<ImonInterface> _maliste= new List<ImonInterface>();
 
... 
_maliste.Add(new maClass());
...
 
 _maclassDeuxLeRetour .MaMethode (_maliste)

[m3z91]

Bonjour,

Essaye plutôt :

Code :

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

1
2
3
4
5
6
7
8
maclassDeuxLeRetour _maclassDeuxLeRetour = new maclassDeuxLeRetour();
List<ImonInterface> _maliste= new List<ImonInterface>();
 
... 
_maliste.Add(new maClass());
...
 
 _maclassDeuxLeRetour .MaMethode (_maliste)

Merci de ta réponse mais ca ne colle pas car le type de la liste est imposé.

[ostenhard]

Merci de ta réponse mais ca ne colle pas car le type de la liste est imposé.

Tu veux dire par là que ta liste doit être de type List<maCLasse> obligatoirement ?

Edit :
Le cast en List<IInterface> ne fonctionne pas cela est normal, il faut faire comme ceci (désolé j'ai qu'un visual 2005 sous la main en 3.5 et VS2008, il existe une autre façon en utilisant la méthode Cast<T>) :

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
    interface itest
    {
    }
 
    class test : itest
    {
    }
 
    class methode
    {
        public void appelMethode(List<itest> liste)
        {
        }
    }
 
    class appel
    {
        void appeler()
        {
            List<test> liste = new List<test>();
            liste.Add(new test());
 
            List<itest> iliste = new List<itest>();
            liste.ForEach(delegate (test item) { iliste.Add(item);});
            (new methode()).appelMethode(iliste);
        }
    }

[m3z91]

Tu veux dire par là que ta liste doit être de type List<maCLasse> obligatoirement ?

Absolument, la classe est mappée par nHibernate je n'ai pas le choix à ce niveau.

Le cast en List<IInterface> ne fonctionne pas cela est normal

Ah ok, merci je n'en était pas sûr (que cela soit normal). Je suppose que la disposition mémoire de l'objet implémentant l'interface n'est pas prédictible. Le cast dans ce cas devient donc impossible.

, il faut faire comme ceci (désolé j'ai qu'un visual 2005 sous la main en 3.5 et VS2008, il existe une autre façon en utilisant la méthode Cast<T>) :

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
    interface itest
    {
    }
 
    class test : itest
    {
    }
 
    class methode
    {
        public void appelMethode(List<itest> liste)
        {
        }
    }
 
    class appel
    {
        void appeler()
        {
            List<test> liste = new List<test>();
            liste.Add(new test());
 
            List<itest> iliste = new List<itest>();
            liste.ForEach(delegate (test item) { iliste.Add(item);});
            (new methode()).appelMethode(iliste);
        }
    }

[/I]

Whaou, oki je vois. Effectivement cela pourrait marché sauf qu'en fait je dois avoir un passage par référence plutôt que par valeur. Ce doit donc être un cast et non pas une copie .

Merci en tout cas de ton aide