Convierta List <DerivedClass> a List <BaseClass>

Si bien podemos heredar de la clase / interfaz base, ¿por qué no podemos declarar un List<> uso de la misma clase / interfaz?

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
    }
}

¿Hay alguna forma de evitarlo?

La forma de hacer que esto funcione es iterar sobre la lista y emitir los elementos. Esto se puede hacer usando ConvertAll:

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

También puedes usar Linq:

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

En primer lugar, deje de usar nombres de clase imposibles de entender como A, B, C. Use Animal, Mamífero, Jirafa, o Comida, Fruta, Naranja o algo donde las relaciones sean claras.

Su pregunta es "¿por qué no puedo asignar una lista de jirafas a una variable de tipo lista de animales, ya que puedo asignar una jirafa a una variable de tipo animal?"

La respuesta es: suponga que podría. ¿Qué podría salir mal entonces?

Bueno, puedes agregar un tigre a una lista de animales. Supongamos que le permitimos poner una lista de jirafas en una variable que contiene una lista de animales. Luego intenta agregar un tigre a esa lista. ¿Lo que pasa? ¿Quieres que la lista de jirafas contenga un tigre? ¿Quieres un choque? ¿o quieres que el compilador te proteja del accidente al hacer que la asignación sea ilegal en primer lugar?

Elegimos este último.

Este tipo de conversión se denomina conversión "covariante". En C # 4, le permitiremos realizar conversiones covariantes en interfaces y delegados cuando se sabe que la conversión es siempre segura . Vea los artículos de mi blog sobre covarianza y contravarianza para más detalles. (Habrá uno nuevo sobre este tema tanto el lunes como el jueves de esta semana).

Para citar la gran explicación de Eric

¿Lo que pasa? ¿Quieres que la lista de jirafas contenga un tigre? ¿Quieres un choque? ¿o quieres que el compilador te proteja del accidente al hacer que la asignación sea ilegal en primer lugar? Elegimos este último.

Pero, ¿qué sucede si desea elegir un bloqueo en tiempo de ejecución en lugar de un error de compilación? Normalmente usaría Cast <> o ConvertAll <> pero luego tendrá 2 problemas: creará una copia de la lista. Si agrega o elimina algo en la nueva lista, esto no se reflejará en la lista original. Y en segundo lugar, hay una gran penalización de rendimiento y memoria ya que crea una nueva lista con los objetos existentes.

Tuve el mismo problema y, por lo tanto, creé una clase de contenedor que puede emitir una lista genérica sin crear una lista completamente nueva.

En la pregunta original, podría usar:

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

y aquí la clase wrapper (+ un método de extensión CastList para un uso fácil)

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

Si lo usa IEnumerable, funcionará (al menos en C # 4.0, no he probado versiones anteriores). Esto es solo un reparto, por supuesto, seguirá siendo una lista.

En vez de -

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

En el código original de la pregunta, use -

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

En cuanto a por qué no funciona, podría ser útil comprender la covarianza y la contravarianza .

Solo para mostrar por qué esto no debería funcionar, aquí hay un cambio en el código que proporcionó:

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

     C FirstItem = DerivedList.First();
}

¿Debería funcionar esto? El primer elemento de la lista es del tipo "B", pero el tipo del elemento DerivedList es C.

Ahora, suponga que realmente solo queremos hacer una función genérica que opere en una lista de algún tipo que implemente A, pero no nos importa de qué tipo sea:

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

}

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

Solo puedes enviar a listas de solo lectura. Por ejemplo:

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

Y no puede hacerlo para listas que admiten elementos de guardado. La razón por la cual es:

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

¿Ahora que? Recuerde que listObject y listString son la misma lista en realidad, por lo que listString ahora tiene un elemento objeto: no debería ser posible y no lo es.

Personalmente me gusta crear librerías con extensiones a las clases.

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

Porque C # no permite ese tipo de herenciaconversión en este momento .

Esta es una extensión de la brillante respuesta de BigJim .

En mi caso, tuve una NodeBaseclase con un Childrendiccionario y necesitaba una forma genérica de hacer búsquedas O (1) de los niños. Intentaba devolver un campo de diccionario privado en el captador de Children, así que obviamente quería evitar las costosas copias / iteraciones. Por lo tanto, utilicé el código de Bigjim para convertirlo Dictionary<whatever specific type>en un 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>();
    }
    ...
}

Esto funcionó bien. Sin embargo, eventualmente encontré limitaciones no relacionadas y terminé creando un FindChild()método abstracto en la clase base que haría las búsquedas en su lugar. Al final resultó que esto eliminó la necesidad del diccionario fundido en primer lugar. (Pude reemplazarlo con un simple IEnumerablepara mis propósitos).

Entonces, la pregunta que puede hacer (especialmente si el rendimiento es un problema que le prohíbe usar .Cast<>o .ConvertAll<>) es:

"¿Realmente necesito lanzar la colección completa, o puedo usar un método abstracto para mantener el conocimiento especial necesario para realizar la tarea y así evitar el acceso directo a la colección?"

A veces la solución más simple es la mejor.

También puede usar el System.Runtime.CompilerServices.Unsafepaquete NuGet para crear una referencia al mismo List:

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

Dado el ejemplo anterior, puede acceder a las Hammerinstancias existentes en la lista utilizando la toolsvariable. Agregar Toolinstancias a la lista genera una ArrayTypeMismatchExceptionexcepción porque hace toolsreferencia a la misma variable que hammers.

He leído todo este hilo, y solo quiero señalar lo que me parece una inconsistencia.

El compilador le impide realizar la tarea con Listas:

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

Pero el compilador está perfectamente bien con las matrices:

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

El argumento sobre si se sabe que la asignación es segura se desmorona aquí. La asignación que hice con la matriz no es segura . Para probar eso, si sigo con esto:

myAnimalsArray[1] = new Giraffe();

Recibo una excepción de tiempo de ejecución "ArrayTypeMismatchException". ¿Cómo se explica esto? Si el compilador realmente quiere evitar que haga algo estúpido, debería haberme impedido hacer la asignación de la matriz.