Discussion :

[khalifanizar]

Bonjour
Je me suis bloqué au niveaux d'une conversion d'une liste d'interface à son propre classe.

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
 
/*Interface IField*/
public interface IField
    {
        string FieldName { get; set; }
        string FieldType { get; set; } 
 
    }
 
/*Son implémentation*/
public class Field : IField
    {
             public Field(string fieldName, string fieldType)
             {
                this.FieldName = fieldName;
                this._fieldType = fieldType;
             }
 
             public string FieldName {   get ;   set;  }
             public string FieldType{   get ;   set;  }
  }

La 2ème interface qui parmi de ces attributs un de type IField.

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 interface IProtocol
    {
        string NameProtocol { get; set; }
        string Id { get; set; }
        List<IField> FieldList { get; set; }
    }
/*Son implémentation*/
 
public class Protocol : IProtocol
    {
 
      public Protocol(string nameProtocol, string id, List<IField> fieldList)
        {
            this.NameProtocol = nameProtocol;
            this.Id = id;
            this.FieldList = fieldList;
        }
 
         public string NameProtocol{   get ;   set;  }
         public string Id{   get ;   set;  }
         public List<IField> FieldList{   get ;   set;  }
  }

Ce que je veux c'est convertir la liste de IField en liste de Field pour avoir un constructeur où FieldList est de type List<Field> comme:

Code :

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

1
2
3
4
5
6
7
8
9
10

 public Protocol(string nameProtocol, string id, List<Field> fieldList)
        {
            this.NameProtocol = nameProtocol;
            this.Id = id;
            this.FieldList = fieldList;
        }

 public List<Field> FieldList{   get ;   set;  }

Le problème si j'utilise le 2eme constructeur j'aurais un problème d'implémentation car son Interface possède une liste de IField.
Celle la sa marche: IField Ifield = new Field();
Mais celle ci non: List<IField> fields = new List<Field>(); "Err convertion"
Avez vous de solution?

Merci
Cordialement

[meziantou]

Ca s'appelle la covariance.
En c# 4 il y a 2 mot clés pour les génériques in et out.

[tomlev]

Il n'y a aucune relation d'héritage entre List<Field> et List<IField>, l'affectation que tu cherches à faire n'est donc pas possible. Si c'était possible, ça permettrait de faire des choses comme ça :

Code :

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

1
2
3
4
5
6
class Field : IField { ... }
class Field2 : IField { ... }
 
List<Field> fields = new List<Field>();
List<IField> ifields = fields; // interdit, mais supposons que ce soit possible
ifields.Add(new Field2()); // oops, on ajoute un Field2 à une liste de Field... BOOM !

Une solution est d'utiliser ToList (mais ça crée une nouvelle liste) :

Code :

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

this.FieldList = fieldList.ToList<IField>();

Ca s'appelle la covariance.

Sauf qu'ici la covariance ne s'applique pas, car seules les interfaces et délégués peuvent être covariants (ou contravariants), et List<T> est une classe. Et de toutes façons, même l'interface IList<T> n'est pas covariante (ni contravariante) en T, car T apparait aussi bien en sortie qu'en entrée.

[khalifanizar]

Il n'y a aucune relation d'héritage entre List<Field> et List<IField>, l'affectation que tu cherches à faire n'est donc pas possible. Si c'était possible, ça permettrait de faire des choses comme ça :

Code :

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

1
2
3
4
5
6
class Field : IField { ... }
class Field2 : IField { ... }
 
List<Field> fields = new List<Field>();
List<IField> ifields = fields; // interdit, mais supposons que ce soit possible
ifields.Add(new Field2()); // oops, on ajoute un Field2 à une liste de Field... BOOM !

Une solution est d'utiliser ToList (mais ça crée une nouvelle liste) :

Code :

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

this.FieldList = fieldList.ToList<IField>();

Sauf qu'ici la covariance ne s'applique pas, car seules les interfaces et délégués peuvent être covariants (ou contravariants), et List<T> est une classe. Et de toutes façons, même l'interface IList<T> n'est pas covariante (ni contravariante) en T, car T apparait aussi bien en sortie qu'en entrée.

Merci pour votre réponse mais this.FieldList = fieldList.ToList<IField>(); vas convertir list<IField> en list<Field> mais j'aurais une erreur de convertion d'une list vers classe, sachant que Field implémente IField aussi j'ai pas compris la covariance, pouvez vous me donner un exemple bien préçi svp !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 public Protocol(string nameProtocol, string id, List<Field> fieldList, )
        {
        //lp = _fieldList.ConvertAll(new Converter<IField, Field>(IFieldToField));
                        
            this.NameProtocol = nameProtocol;
            this.LongName = longName;
            this.Id = id;
            this.FieldList = fieldList.ToList<Field>(); //Err convertion
            this.Encapsulation = encapsulation;

           

        }

[tomlev]

Merci pour votre réponse mais this.FieldList = fieldList.ToList<IField>(); vas convertir list<IField> en list<Field>

Non, ça va convertir List<Field> en List<IField>... dans ton code tu as écrit .ToList<Field>() au lieu de .ToList<IField>()

aussi j'ai pas compris la covariance, pouvez vous me donner un exemple bien préçi svp !

Par exemple, IEnumerable<T> est covariant en T, c'est à dire que si Y hérite de X, alors un IEnumerable<Y> peut être affecté à un IEnumerable<X>.

Exemple avec X = object et Y = string :

Code :

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

1
2
List<string> listOfStrings = new List<string>(); // List<T> implémente IEnumerable<T>
IEnumerable<object> objects = listOfStrings;

(une séquence de strings peut être considérée comme une séquence d'objects)

La contravariance, c'est le contraire. Par exemple, Action<T> est contravariant en T, c'est à dire que si Y hérite de X, alors un Action<X> peut être affecté à un Action<Y> :

Code :

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

1
2
3
Action<object> actionOnObject = o => Console.WriteLine(o.ToString());
Action<string> actionOnString = actionOnObject;
actionOnString("Hello");

(une action qui s'applique à n'importe quel object peut être appliquée à une string, puisqu'une string est un object)

Pour plus de détails, regarde cet article

[khalifanizar]

Non, ça va convertir List<Field> en List<IField>... dans ton code tu as écrit .ToList<Field>() au lieu de .ToList<IField>()

Par exemple, IEnumerable<T> est covariant en T, c'est à dire que si Y hérite de X, alors un IEnumerable<Y> peut être affecté à un IEnumerable<X>.

Exemple avec X = object et Y = string :

Code :

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

1
2
List<string> listOfStrings = new List<string>(); // List<T> implémente IEnumerable<T>
IEnumerable<object> objects = listOfStrings;

(une séquence de strings peut être considérée comme une séquence d'objects)

La contravariance, c'est le contraire. Par exemple, Action<T> est contravariant en T, c'est à dire que si Y hérite de X, alors un Action<X> peut être affecté à un Action<Y> :

Code :

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

1
2
3
Action<object> actionOnObject = o => Console.WriteLine(o.ToString());
Action<string> actionOnString = actionOnObject;
actionOnString("Hello");

(une action qui s'applique à n'importe quel object peut être appliquée à une string, puisqu'une string est un object)

Pour plus de détails, regarde cet article

Merci encore une fois je sais que j'ai mis .ToList<Field>() au lieu de .ToList<IField>() car je veux avoir dans la classe de protocol un attribut List<Field> et non pas List<IField> pour pouvoir sérialiser une liste de protocole y compris une liste de Field de type Field, j'espr que vous m'avez compris bien maintenant!