Sintaxe mais curta para transmitir de uma Lista <X> para uma Lista <Y>?

Eu sei que é possível converter uma lista de itens de um tipo para outro (considerando que seu objeto tem um método de operador explícito estático público para fazer a conversão), um de cada vez, da seguinte maneira:

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

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

Mas não é possível transmitir a lista inteira de uma só vez? Por exemplo,

ListOfY = (List<Y>)ListOfX;

Se Xrealmente pode ser transmitido para Yvocê, você deve poder usar

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

Algumas coisas para estar ciente (H / T para comentaristas!)

• Você deve incluir using System.Linq;para obter esse método de extensão
• Isso lança cada item da lista - não a lista em si. Um novo List<Y>será criado pela chamada para ToList().
• Este método não suporta operadores de conversão personalizados. (consulte http://stackoverflow.com/questions/14523530/why-does-the-linq-cast-helper-not-work-with-the-implicit-cast-operator )
• Este método não funciona para um objeto que possui um método explícito de operador (estrutura 4.0)

A conversão direta var ListOfY = (List<Y>)ListOfXnão é possível porque exigiria co-contravariância do List<T>tipo e isso simplesmente não pode ser garantido em todos os casos. Leia para ver as soluções para esse problema de fundição.

Embora pareça normal ser capaz de escrever código como este:

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

porque podemos garantir que todo mamífero será um animal, isso é obviamente um erro:

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

já que nem todo animal é um mamífero.

No entanto, usando C # 3 e acima, você pode usar

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

isso facilita um pouco o elenco. Isso é sintaticamente equivalente ao seu código de adição um por um, pois usa uma conversão explícita para converter cada um Mammalda lista em uma Animale falhará se a conversão não for bem-sucedida.

Se você quiser ter mais controle sobre o processo de conversão / conversão, use o ConvertAllmétodo da List<T>classe, que pode usar uma expressão fornecida para converter os itens. Ele tem o benefício adicional de retornar a List, em vez de IEnumerable, portanto não .ToList()é necessário.

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

Para adicionar ao ponto de Sweko:

A razão pela qual o elenco

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

isso não é possível porque List<T>é invariável no Tipo T e, portanto, não importa se Xderiva de Y) - isso ocorre porque List<T>é definido como:

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

(Observe que nesta declaração, digite Taqui não possui modificadores de variação adicionais)

No entanto, se coleções mutáveis ​​não forem necessárias em seu design, é possível fazer upcast em muitas das coleções imutáveis , por exemplo, desde que Giraffederivadas de Animal:

IEnumerable<Animal> animals = giraffes;

Isso ocorre porque IEnumerable<T>suporta covariância em T- isso faz sentido, pois IEnumerableimplica que a coleção não pode ser alterada, pois não possui suporte para métodos para adicionar ou remover elementos da coleção. Observe a outpalavra - chave na declaração de IEnumerable<T>:

public interface IEnumerable<out T> : IEnumerable

( Aqui está mais uma explicação do motivo pelo qual coleções mutáveis ​​como Listnão podem suportar covariance, enquanto iteradores e coleções imutáveis ​​podem.)

Fundição com .Cast<T>()

Como outros já mencionaram, .Cast<T>()pode ser aplicado a uma coleção para projetar uma nova coleção de elementos convertidos para T, no entanto, isso será acionado InvalidCastExceptionse a conversão em um ou mais elementos não for possível (o que seria o mesmo comportamento que o explícito no foreachloop do OP ).

Filtragem e conversão com OfType<T>()

Se a lista de entrada contiver elementos de tipos diferentes e incompatíveis, o potencial InvalidCastExceptionpoderá ser evitado usando em .OfType<T>()vez de .Cast<T>(). ( .OfType<>()verifica se um elemento pode ser convertido no tipo de destino, antes de tentar a conversão, e filtra tipos incompatíveis.)

para cada

Observe também que, se o OP tivesse escrito isso: (observe o explícitoY y no foreach)

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

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

que o elenco também será tentado. No entanto, se nenhuma conversão for possível, InvalidCastExceptionhaverá um resultado.

Exemplos

Por exemplo, dada a hierarquia de classes simples (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) { }
}

Ao trabalhar com uma coleção de tipos mistos:

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

Enquanto que:

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

filtra apenas os elefantes - ou seja, as zebras são eliminadas.

Operadores implícitos de elenco

Sem dinâmica, os operadores de conversão definidos pelo usuário são usados ​​apenas em tempo de compilação *; portanto, mesmo que um operador de conversão entre o Zebra e o Elephant seja disponibilizado, o comportamento do tempo de execução acima das abordagens à conversão não mudaria.

Se adicionarmos um operador de conversão para converter uma Zebra em um elefante:

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

Em vez disso, dado o operador de conversão acima, o compilador poderá alterar o tipo da matriz abaixo de Animal[]para Elephant[], pois as Zebras agora podem ser convertidas em uma coleção homogênea de elefantes:

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

Usando operadores de conversão implícitos em tempo de execução

* Conforme mencionado por Eric, no entanto, o operador de conversão pode ser acessado em tempo de execução, recorrendo a 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

Você pode usar List<Y>.ConvertAll<T>([Converter from Y to T]);

Esta não é a resposta a esta pergunta, mas pode ser útil para alguns: como disse @SWeko, graças a covariância e contravariance, List<X>não pode ser convertido em List<Y>, mas List<X>pode ser lançado IEnumerable<Y>, e mesmo com conversão implícita.

Exemplo:

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

mas

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

A grande vantagem é que ele não cria uma nova lista na memória.

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