Converter lista <classe derivada> em lista <classe base>

Embora possamos herdar da classe / interface base, por que não podemos declarar o List<> uso da mesma classe / interface?

interface A
{ }

class B : A
{ }

class C : B
{ }

class Test
{
    static void Main(string[] args)
    {
        A a = new C(); // OK
        List<A> listOfA = new List<C>(); // compiler Error
    }
}

Existe uma maneira de contornar?

A maneira de fazer isso funcionar é iterar sobre a lista e converter os elementos. Isso pode ser feito usando o ConvertAll:

List<A> listOfA = new List<C>().ConvertAll(x => (A)x);

Você também pode usar o Linq:

List<A> listOfA = new List<C>().Cast<A>().ToList();

Antes de tudo, pare de usar nomes de classe impossíveis de entender como A, B, C. Use Animal, Mamífero, Girafa ou Comida, Fruta, Laranja ou algo onde os relacionamentos sejam claros.

Sua pergunta então é "por que não posso atribuir uma lista de girafas a uma variável do tipo de lista de animais, pois posso atribuir uma girafa a uma variável do tipo animal?"

A resposta é: suponha que você possa. O que poderia então dar errado?

Bem, você pode adicionar um tigre a uma lista de animais. Suponha que permitamos que você coloque uma lista de girafas em uma variável que contém uma lista de animais. Então você tenta adicionar um tigre a essa lista. O que acontece? Deseja que a lista de girafas contenha um tigre? Você quer um acidente? ou você deseja que o compilador o proteja da falha, tornando a atribuição ilegal em primeiro lugar?

Nós escolhemos o último.

Esse tipo de conversão é chamado de conversão "covariante". No C # 4, permitiremos que você faça conversões covariantes em interfaces e delegados quando se sabe que a conversão é sempre segura . Veja meus artigos de blog sobre covariância e contravariância para obter detalhes. (Haverá um novo sobre este tópico na segunda e na quinta-feira desta semana.)

Para citar a grande explicação de Eric

O que acontece? Deseja que a lista de girafas contenha um tigre? Você quer um acidente? ou você deseja que o compilador o proteja da falha, tornando a atribuição ilegal em primeiro lugar? Nós escolhemos o último.

Mas e se você quiser escolher uma falha de tempo de execução em vez de um erro de compilação? Você normalmente usaria o Cast <> ou o ConvertAll <>, mas terá 2 problemas: Ele criará uma cópia da lista. Se você adicionar ou remover algo da nova lista, isso não será refletido na lista original. Em segundo lugar, há uma grande penalidade de desempenho e memória, pois ela cria uma nova lista com os objetos existentes.

Eu tive o mesmo problema e, portanto, criei uma classe de wrapper que pode converter uma lista genérica sem criar uma lista totalmente nova.

Na pergunta original, você poderia usar:

class Test
{
    static void Main(string[] args)
    {
        A a = new C(); // OK
        IList<A> listOfA = new List<C>().CastList<C,A>(); // now ok!
    }
}

e aqui a classe wrapper (+ um método de extensão CastList para facilitar o uso)

public class CastedList<TTo, TFrom> : IList<TTo>
{
    public IList<TFrom> BaseList;

    public CastedList(IList<TFrom> baseList)
    {
        BaseList = baseList;
    }

    // IEnumerable
    IEnumerator IEnumerable.GetEnumerator() { return BaseList.GetEnumerator(); }

    // IEnumerable<>
    public IEnumerator<TTo> GetEnumerator() { return new CastedEnumerator<TTo, TFrom>(BaseList.GetEnumerator()); }

    // ICollection
    public int Count { get { return BaseList.Count; } }
    public bool IsReadOnly { get { return BaseList.IsReadOnly; } }
    public void Add(TTo item) { BaseList.Add((TFrom)(object)item); }
    public void Clear() { BaseList.Clear(); }
    public bool Contains(TTo item) { return BaseList.Contains((TFrom)(object)item); }
    public void CopyTo(TTo[] array, int arrayIndex) { BaseList.CopyTo((TFrom[])(object)array, arrayIndex); }
    public bool Remove(TTo item) { return BaseList.Remove((TFrom)(object)item); }

    // IList
    public TTo this[int index]
    {
        get { return (TTo)(object)BaseList[index]; }
        set { BaseList[index] = (TFrom)(object)value; }
    }

    public int IndexOf(TTo item) { return BaseList.IndexOf((TFrom)(object)item); }
    public void Insert(int index, TTo item) { BaseList.Insert(index, (TFrom)(object)item); }
    public void RemoveAt(int index) { BaseList.RemoveAt(index); }
}

public class CastedEnumerator<TTo, TFrom> : IEnumerator<TTo>
{
    public IEnumerator<TFrom> BaseEnumerator;

    public CastedEnumerator(IEnumerator<TFrom> baseEnumerator)
    {
        BaseEnumerator = baseEnumerator;
    }

    // IDisposable
    public void Dispose() { BaseEnumerator.Dispose(); }

    // IEnumerator
    object IEnumerator.Current { get { return BaseEnumerator.Current; } }
    public bool MoveNext() { return BaseEnumerator.MoveNext(); }
    public void Reset() { BaseEnumerator.Reset(); }

    // IEnumerator<>
    public TTo Current { get { return (TTo)(object)BaseEnumerator.Current; } }
}

public static class ListExtensions
{
    public static IList<TTo> CastList<TFrom, TTo>(this IList<TFrom> list)
    {
        return new CastedList<TTo, TFrom>(list);
    }
}

Se você usar IEnumerable, ele funcionará (pelo menos no C # 4.0, eu não tentei versões anteriores). Este é apenas um elenco, é claro, ainda será uma lista.

Ao invés de -

List<A> listOfA = new List<C>(); // compiler Error

No código original da pergunta, use -

IEnumerable<A> listOfA = new List<C>(); // compiler error - no more! :)

Na medida em que não funciona, pode ser útil entender covariância e contravariância .

Apenas para mostrar por que isso não deve funcionar, aqui está uma alteração no código que você forneceu:

void DoesThisWork()
{
     List<C> DerivedList = new List<C>();
     List<A> BaseList = DerivedList;
     BaseList.Add(new B());

     C FirstItem = DerivedList.First();
}

Isso deve funcionar? O primeiro item da lista é do tipo "B", mas o tipo do item DerivedList é C.

Agora, suponha que realmente queremos apenas criar uma função genérica que opere em uma lista de algum tipo que implemente A, mas não nos importamos com o tipo:

void ThisWorks<T>(List<T> GenericList) where T:A
{

}

void Test()
{
     ThisWorks(new List<B>());
     ThisWorks(new List<C>());
}

Você só pode transmitir para listas somente leitura. Por exemplo:

IEnumerable<A> enumOfA = new List<C>();//This works
IReadOnlyCollection<A> ro_colOfA = new List<C>();//This works
IReadOnlyList<A> ro_listOfA = new List<C>();//This works

E você não pode fazer isso para listas que suportam salvar elementos. O motivo é:

List<string> listString=new List<string>();
List<object> listObject=(List<object>)listString;//Assume that this is possible
listObject.Add(new object());

E agora? Lembre-se de que listObject e listString são a mesma lista, portanto, listString agora tem um elemento de objeto - não deve ser possível e não é.

Pessoalmente, gosto de criar bibliotecas com extensões para as classes

public static List<TTo> Cast<TFrom, TTo>(List<TFrom> fromlist)
  where TFrom : class 
  where TTo : class
{
  return fromlist.ConvertAll(x => x as TTo);
}

Como o C # não permite esse tipo de herançaconversão no momento .

Esta é uma extensão da brilhante resposta de BigJim .

No meu caso, eu tive uma NodeBaseaula com um Childrendicionário e precisava de uma maneira generosa de fazer pesquisas O (1) das crianças. Eu estava tentando retornar um campo de dicionário privado no getter de Children, então obviamente eu queria evitar cópias / iterações caras. Portanto, usei o código de Bigjim para converter o Dictionary<whatever specific type>em um genérico Dictionary<NodeBase>:

// Abstract parent class
public abstract class NodeBase
{
    public abstract IDictionary<string, NodeBase> Children { get; }
    ...
}

// Implementing child class
public class RealNode : NodeBase
{
    private Dictionary<string, RealNode> containedNodes;

    public override IDictionary<string, NodeBase> Children
    {
        // Using a modification of Bigjim's code to cast the Dictionary:
        return new IDictionary<string, NodeBase>().CastDictionary<string, RealNode, NodeBase>();
    }
    ...
}

Isso funcionou bem. No entanto, acabei encontrando limitações não relacionadas e acabei criando um FindChild()método abstrato na classe base que faria as pesquisas. Como se viu, isso eliminou a necessidade do dicionário fundido em primeiro lugar. (Consegui substituí-lo por um simples IEnumerablepara meus propósitos.)

Portanto, a pergunta que você pode fazer (especialmente se o desempenho é um problema que o impede de usar .Cast<>ou .ConvertAll<>) é:

"Preciso realmente converter a coleção inteira ou posso usar um método abstrato para manter o conhecimento especial necessário para executar a tarefa e, assim, evitar o acesso direto à coleção?"

Às vezes, a solução mais simples é a melhor.

Você também pode usar o System.Runtime.CompilerServices.Unsafepacote NuGet para criar uma referência ao mesmo List:

using System.Runtime.CompilerServices;
...
class Tool { }
class Hammer : Tool { }
...
var hammers = new List<Hammer>();
...
var tools = Unsafe.As<List<Tool>>(hammers);

Dada a amostra acima, você pode acessar as Hammerinstâncias existentes na lista usando a toolsvariável Adicionar Toolinstâncias à lista gera uma ArrayTypeMismatchExceptionexceção porque faz toolsreferência à mesma variável que hammers.

Eu li todo esse tópico e só quero apontar o que me parece uma inconsistência.

O compilador impede que você faça a atribuição com Listas:

List<Tiger> myTigersList = new List<Tiger>() { new Tiger(), new Tiger(), new Tiger() };
List<Animal> myAnimalsList = myTigersList;    // Compiler error

Mas o compilador está perfeitamente bem com matrizes:

Tiger[] myTigersArray = new Tiger[3] { new Tiger(), new Tiger(), new Tiger() };
Animal[] myAnimalsArray = myTigersArray;    // No problem

O argumento sobre se a tarefa é conhecida como segura se desfaz aqui. A tarefa que fiz com a matriz não é segura . Para provar isso, se eu seguir com isso:

myAnimalsArray[1] = new Giraffe();

Recebo uma exceção de tempo de execução "ArrayTypeMismatchException". Como se explica isso? Se o compilador realmente quer me impedir de fazer algo estúpido, deveria ter me impedido de fazer a atribuição da matriz.