Syntaxe plus courte pour la conversion d'une liste <X> en une liste <Y>?

Je sais qu'il est possible de caster une liste d'éléments d'un type à un autre (étant donné que votre objet a une méthode d'opérateur explicite statique publique pour faire le casting) un à la fois comme suit:

List<Y> ListOfY = new List<Y>();

foreach(X x in ListOfX)
    ListOfY.Add((Y)x);

Mais n'est-il pas possible de lancer la liste entière en une seule fois? Par exemple,

ListOfY = (List<Y>)ListOfX;

Si vous Xpouvez vraiment vous lancer, Yvous devriez pouvoir utiliser

List<Y> listOfY = listOfX.Cast<Y>().ToList();

Quelques choses à savoir (H / T aux commentateurs!)

• Vous devez inclure using System.Linq;pour obtenir cette méthode d'extension
• Cela jette chaque élément dans la liste - pas la liste elle-même. Un nouveau List<Y>sera créé par l'appel à ToList().
• Cette méthode ne prend pas en charge les opérateurs de conversion personnalisés. (voir http://stackoverflow.com/questions/14523530/why-does-the-linq-cast-helper-not-work-with-the-implicit-cast-operator )
• Cette méthode ne fonctionne pas pour un objet qui a une méthode d'opérateur explicite (framework 4.0)

La conversion directe var ListOfY = (List<Y>)ListOfXn'est pas possible car elle nécessiterait une co / contravariance du List<T>type, et cela ne peut tout simplement pas être garanti dans tous les cas. Veuillez lire la suite pour voir les solutions à ce problème de casting.

Bien qu'il semble normal de pouvoir écrire du code comme ceci:

List<Animal> animals = (List<Animal>) mammalList;

parce que nous pouvons garantir que chaque mammifère sera un animal, c'est évidemment une erreur:

List<Mammal> mammals = (List<Mammal>) animalList;

car tous les animaux ne sont pas des mammifères.

Cependant, en utilisant C # 3 et supérieur, vous pouvez utiliser

IEnumerable<Animal> animals = mammalList.Cast<Animal>();

cela facilite un peu le casting. Ceci est syntaxiquement équivalent à votre code d'ajout un par un, car il utilise une conversion explicite pour convertir chaque élément Mammalde la liste en un Animal, et échouera si la conversion n'est pas réussie.

Si vous aimez plus de contrôle sur le processus de transtypage / conversion, vous pouvez utiliser la ConvertAllméthode de la List<T>classe, qui peut utiliser une expression fournie pour convertir les éléments. Il a l'avantage supplémentaire de renvoyer un List, au lieu de IEnumerable, donc aucun .ToList()n'est nécessaire.

List<object> o = new List<object>();
o.Add("one");
o.Add("two");
o.Add(3);

IEnumerable<string> s1 = o.Cast<string>(); //fails on the 3rd item
List<string> s2 = o.ConvertAll(x => x.ToString()); //succeeds

Pour ajouter au point de Sweko:

La raison pour laquelle le casting

var listOfX = new List<X>();
ListOf<Y> ys = (List<Y>)listOfX; // Compile error: Cannot implicitly cast X to Y

n'est pas possible parce que le List<T>est invariant dans le Type T et donc peu importe qu'il Xdérive de Y) - c'est parce que List<T>est défini comme:

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T> ... // Other interfaces

(Notez que dans cette déclaration, le type Tici n'a pas de modificateurs de variance supplémentaires)

Cependant, si des collections modifiables ne sont pas requises dans votre conception, une conversion ascendante sur un grand nombre des collections immuables est possible , par exemple à condition qu'elles Giraffedérivent de Animal:

IEnumerable<Animal> animals = giraffes;

En effet, IEnumerable<T>prend en charge la covariance dans T- cela a du sens étant donné qu'il IEnumerableimplique que la collection ne peut pas être modifiée, car elle ne prend pas en charge les méthodes pour ajouter ou supprimer des éléments de la collection. Notez le outmot - clé dans la déclaration de IEnumerable<T>:

public interface IEnumerable<out T> : IEnumerable

( Voici une explication supplémentaire de la raison pour laquelle les collections mutables comme Listne peuvent pas prendre en charge covariance, alors que les itérateurs et les collections immuables le peuvent.)

Casting avec .Cast<T>()

Comme d'autres l'ont mentionné, .Cast<T>()peut être appliqué à une collection pour projeter une nouvelle collection d'éléments castés en T, mais cela provoquera un jet InvalidCastExceptionsi la cast sur un ou plusieurs éléments n'est pas possible (ce qui serait le même comportement que de faire l'explicite dans la foreachboucle de l'OP ).

Filtrage et diffusion avec OfType<T>()

Si la liste d'entrée contient des éléments de types différents et incompatibles, le potentiel InvalidCastExceptionpeut être évité en utilisant à la .OfType<T>()place de .Cast<T>(). ( .OfType<>()vérifie si un élément peut être converti en type cible, avant de tenter la conversion, et filtre les types incompatibles.)

pour chaque

Notez également que si l'OP l'a écrit à la place: (notez l' expliciteY y dans le foreach)

List<Y> ListOfY = new List<Y>();

foreach(Y y in ListOfX)
{
    ListOfY.Add(y);
}

que le casting sera également tenté. Cependant, si aucun lancer n'est possible, un InvalidCastExceptionrésultat sera obtenu.

Exemples

Par exemple, étant donné la hiérarchie de classe simple (C # 6):

public abstract class Animal
{
    public string Name { get;  }
    protected Animal(string name) { Name = name; }
}

public class Elephant :  Animal
{
    public Elephant(string name) : base(name){}
}

public class Zebra : Animal
{
    public Zebra(string name)  : base(name) { }
}

Lorsque vous travaillez avec une collection de types mixtes:

var mixedAnimals = new Animal[]
{
    new Zebra("Zed"),
    new Elephant("Ellie")
};

foreach(Animal animal in mixedAnimals)
{
     // Fails for Zed - `InvalidCastException - cannot cast from Zebra to Elephant`
     castedAnimals.Add((Elephant)animal);
}

var castedAnimals = mixedAnimals.Cast<Elephant>()
    // Also fails for Zed with `InvalidCastException
    .ToList();

Tandis que:

var castedAnimals = mixedAnimals.OfType<Elephant>()
    .ToList();
// Ellie

filtre uniquement les éléphants - c'est-à-dire que les zèbres sont éliminés.

Re: opérateurs de distribution implicites

Sans opérateurs de conversion dynamiques définis par l'utilisateur, ils ne sont utilisés qu'au moment de la compilation *, donc même si un opérateur de conversion entre Zebra et Elephant, par exemple, était disponible, le comportement d'exécution des approches de conversion ci-dessus ne changerait pas.

Si nous ajoutons un opérateur de conversion pour convertir un zèbre en éléphant:

public class Zebra : Animal
{
    public Zebra(string name) : base(name) { }
    public static implicit operator Elephant(Zebra z)
    {
        return new Elephant(z.Name);
    }
}

Au lieu de cela, étant donné l'opérateur de conversion ci-dessus, le compilateur pourra changer le type du tableau ci-dessous de Animal[]à Elephant[], étant donné que les zèbres peuvent maintenant être convertis en une collection homogène d'éléphants:

var compilerInferredAnimals = new []
{
    new Zebra("Zed"),
    new Elephant("Ellie")
};

Utilisation d'opérateurs de conversion implicite lors de l'exécution

* Comme mentionné par Eric, l'opérateur de conversion est cependant accessible au moment de l'exécution en recourant à dynamic:

var mixedAnimals = new Animal[] // i.e. Polymorphic collection
{
    new Zebra("Zed"),
    new Elephant("Ellie")
};

foreach (dynamic animal in mixedAnimals)
{
    castedAnimals.Add(animal);
}
// Returns Zed, Ellie

Vous pouvez utiliser List<Y>.ConvertAll<T>([Converter from Y to T]);

Ce n'est pas tout à fait la réponse à cette question, mais cela peut être utile pour certains: comme @SWeko l'a dit, grâce à la covariance et à la contravariance, List<X>ne peut pas être intégré List<Y>, mais List<X>peut être intégré à IEnumerable<Y>, et même avec une implicite.

Exemple:

List<Y> ListOfY = new List<Y>();
List<X> ListOfX = (List<X>)ListOfY; // Compile error

mais

List<Y> ListOfY = new List<Y>();
IEnumerable<X> EnumerableOfX = ListOfY;  // No issue

Le gros avantage est qu'il ne crée pas de nouvelle liste en mémoire.

dynamic data = List<x> val;  
List<y> val2 = ((IEnumerable)data).Cast<y>().ToList();