Syntaxe plus courte pour le moulage à partir d'une Liste<X> une Liste<Y>?

Si X peut vraiment être jeté à Y vous devriez être en mesure d'utiliser

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

Certaines choses pour être au courant de (H/T pour les commentateurs!)

• Vous devez inclure using System.Linq; d'obtenir cette extension de la méthode
• Ce qui jette de chaque élément dans la liste - non pas la liste elle-même. Une nouvelle List<Y> sera créé par l'appel à ToList().
• Cette méthode ne prend pas en charge personnalisée opérateurs de conversion. ( 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 explicite de l'opérateur méthode (framework 4.0)

À ajouter à Sweko point:

La raison pour laquelle la fonte

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

n'est pas possible que parce que le List<T> est invariant dans le Type T et donc il n'a pas d'importance si X dé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

(À noter que dans la présente déclaration, type T ici n'a pas de variance supplémentaire modificateurs)

Toutefois, si mutable collections ne sont pas nécessaires dans votre conception, une sortie sur un grand nombre de immuable collections, est possible, par exemple, à condition que Giraffe dérive de Animal:

IEnumerable<Animal> animals = giraffes;

C'est parce que IEnumerable<T> prend en charge la covariance dans T - ce qui est logique étant donné que IEnumerable implique que la collection ne peut pas être modifié, car il n'a pas de support pour les méthodes pour Ajouter ou Supprimer des éléments de la collection. Remarque le out mot-clé dans la déclaration de IEnumerable<T>:

public interface IEnumerable<out T> : IEnumerable

(Voici plus d'explications pour la raison pour laquelle mutable collections comme List ne peut pas soutenir covariance, alors que immuables itérateurs et des collections.)

Casting avec .Cast<T>()

Comme d'autres l'ont mentionné, .Cast<T>() peut être appliquée à une collection pour projet une nouvelle collection d'éléments coulé à T, cependant cela permettra de jeter un InvalidCastException si la fonte sur un ou plusieurs éléments n'est pas possible (ce qui serait le même comportement que le fait de faire le cast explicite dans le cas des OP foreach boucle).

De filtrage et de Casting avec OfType<T>()

Si l'entrée de la liste contient des éléments différents, incompatibles types, le potentiel InvalidCastException peut être évité en utilisant .OfType<T>() au lieu de .Cast<T>(). (.OfType<>() vérifie si un élément peut être convertie dans le type de cible, avant de tenter la conversion, et de filtrer les types incompatibles.)

foreach

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

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

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

que le casting sera tentée. Toutefois, si aucune conversion n'est possible, un InvalidCastException sera le résultat.

Exemples

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

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 l'on travaille avec une collection de différents types:

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();

Considérant ce qui suit:

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

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

Re: opérateurs de transtypage Implicite

Sans dynamique, défini par l'utilisateur opérateurs de conversion sont également utilisés lors de la au moment de la compilation*, de sorte que même si un opérateur de conversion entre le Zèbre et l'Éléphant a été mis à disposition, le moment de l'exécution du comportement des approches de conversion ne change pas.

Si l'on ajoute un opérateur de conversion pour convertir un Zèbre, un É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, compte tenu de la ci-dessus opérateur de conversion, le compilateur sera en mesure de changer le type du tableau ci-dessous à partir de Animal[] à Elephant[], étant donné que les Zèbres peuvent être convertis en un tout homogène collection d'Éléphants:

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

Aide de la Conversion Implicite des Opérateurs au moment de l'exécution

*Comme mentionné par Eric, l'opérateur de conversion peut cependant être consulté au moment de l'exécution par le recours à 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

Ce n'est pas tout à fait la réponse à cette question, mais il peut être utile pour certains: comme @SWeko dit, grâce à la covariance et la contravariance, List<X> ne peut pas être jeté dans List<Y>, mais List<X> peut être jeté dans IEnumerable<Y>, et même avec un cast 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 de ne pas créer une nouvelle liste dans la mémoire.