Casting List <> de la clase derivada a List <> de la clase base

Question

Tengo dos clases: una clase base (Animal) y una clase derivada de it (Cat). La clase Base contiene un método virtual Play que toma List como parameter.Something de entrada como esta

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace ConsoleApplication9 
{ 
    class Animal 
    { 
     public virtual void Play(List<Animal> animal) { } 
    } 
    class Cat : Animal 
    { 
     public override void Play(List<Animal> animal) 
     { 
     } 
    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      Cat cat = new Cat(); 
      cat.Play(new List<Cat>()); 
     } 
    } 
} 

cuando compilo el programa anterior, me sale el siguiente error

 
    Error 2 Argument 1: cannot convert from 'System.Collections.Generic.List' to 'System.Collections.Generic.List' 

¿hay alguna forma de lograr esto?

Answer 1

La razón por la que no puede hacer esto es porque una lista es de escritura. Supongamos que es legal, y vea qué va mal:

List<Cat> cats = new List<Cat>(); 
List<Animal> animals = cats; // Trouble brewing... 
animals.Add(new Dog()); // hey, we just added a dog to a list of cats... 
cats[0].Speak(); // Woof! 

Bueno, perrito, mis gatos, eso es maldad.

La función que desea se denomina "covarianza genérica" ​​y se admite en C# 4 para las interfaces que se sabe que son seguras. IEnumerable<T> no tiene forma de escribir en la secuencia, por lo que es seguro.

class Animal  
{  
    public virtual void Play(IEnumerable<Animal> animals) { }  
}  
class Cat : Animal  
{  
    public override void Play(IEnumerable<Animal> animals) { }  
}  
class Program  
{  
    static void Main()  
    {  
     Cat cat = new Cat();  
     cat.Play(new List<Cat>());  
    }  
} 

que trabajará en C# 4 List<Cat> porque se puede convertir en IEnumerable<Cat>, que es convertible a IEnumerable<Animal>. No hay forma de que Play pueda usar IEnumerable<Animal> para agregar un perro a algo que en realidad sea una lista de gatos.

Answer 2

Está buscando la covarianza de la colección genérica. Obviamente, sin embargo, esa característica no es compatible con la versión de C# que estás usando.

Puede solucionar el problema utilizando el método de extensión Cast<T>(). Tenga en cuenta, sin embargo, que esto creará una copia de su lista original en lugar de pasar el original como un tipo diferente:

cat.Play((new List<Cat>()).Cast<Animal>().ToList()); 

Answer 3

usar la conversión método de extensión()

manera:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Cat cat = new Cat(); 
     cat.Play(new List<Cat>().Cast<Animal>()); 
    } 
} 

La razón de esto es b/c .net 3.5 no admite la covarianza, pero 4.0 lo hace :)

Answer 4

Podría hacer algunas cosas. Un ejemplo es arrojado los elementos de la lista para Animal

Utilizando su código:

cat.Play(new List<Cat>().Cast<Animal>().ToList()); 

Otra es hacer Animal genérica, por lo cat.Play(new List<Cat>()); funcionaría.

class Animal<T> 
{ 
    public virtual void Play(List<T> animals) { } 
} 
class Cat : Animal<Cat> 
{ 
    public override void Play(List<Cat> cats) 
    { 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Cat cat = new Cat(); 
     cat.Play(new List<Cat>()); 
    } 
} 

Otro método es no hacer Animal genérico, pero el método y Play restringir que a T : Animal

class Animal 
{ 
    public virtual void Play<T>(List<T> animals) where T : Animal { } 
} 
class Cat : Animal 
{ 
    public override void Play<T>(List<T> animals) 
    { 
    } 
} 

Por último, si usted está en C# 4 y sólo es necesario enumerar la lista y no lo modifique, consulte la respuesta de Eric Lippert en IEnumerable<Animal>.

Answer 5

Todo el mundo menciona el método de lanzamiento ya. Si no puede actualizar a 4.0 una forma de ocultar el elenco es

class Cat : Animal 
{ 
    public override void Play(List<Animal> animal) 
    { 
     Play((List<Cat>)animal); 
    } 
    public virtual void Play(List<Cat> animal) 
    { 
    } 
} 

Este es el mismo truco IEnumable y IEnumarable<T> de juegos para GetEnumerator