Fundir/Convertir IEnumerable <T> en IEnumerable <U>?

Question

Lo siguiente cumple, pero en tiempo de ejecución arroja una excepción. Lo que intento hacer es lanzar una clase PersonWithAge a una clase de Persona. ¿Cómo hago esto y cuál es el trabajo?

class Person 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
} 

class PersonWithAge 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public int Age { get; set; } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     IEnumerable<PersonWithAge> pwa = new List<PersonWithAge> 
     { 
      new PersonWithAge {Id = 1, Name = "name1", Age = 23}, 
      new PersonWithAge {Id = 2, Name = "name2", Age = 32} 
     }; 

     IEnumerable<Person> p = pwa.Cast<Person>(); 

     foreach (var i in p) 
     { 
      Console.WriteLine(i.Name); 
     } 
    } 
} 

EDIT: Por cierto PersonWithAge siempre contendrá las mismas propiedades que la persona además de un par más.

EDIT 2 Lo siento muchachos, pero debería haber dejado esto un poco más claro, decir que tengo dos vistas db en una base de datos que contiene las mismas columnas pero la vista 2 contiene 1 campo adicional. Mis entidades de vista de modelo son generadas por una herramienta que imita las vistas de la base de datos. Tengo una vista parcial de MVC que hereda de una de las entidades de clase pero tengo más de una forma de capturar datos ...

No estoy seguro si esto ayuda, pero significa que no puedo hacer que personWithAge herede de persona.

Answer 1

no se puede convertir, ya que son diferentes tipos. Tiene dos opciones:

1) Cambie la clase para que PersonWithAge herede de la persona.

class PersonWithAge : Person 
{ 
     public int Age { get; set; } 
} 

2) crear nuevos objetos:

IEnumerable<Person> p = pwa.Select(p => new Person { Id = p.Id, Name = p.Name }); 

Answer 2

Uso Select en lugar de Cast con el fin de indicar cómo realizar la conversión de un tipo a otro:

IEnumerable<Person> p = pwa.Select(x => new Person { Id = x.Id, Name = x.Name }); 

También como PersonWithAge siempre contendrá las mismas propiedades que Person además de un par más sería mejor tenerlo heredar de Person.

Answer 3

es posible que desee modificar el código para ser algo como:

class Person 
{ 
     public int Id { get; set; } 
     public string Name { get; set; } 
} 

class PersonWithAge : Person 
{ 
     public int Age { get; set; } 
} 

Answer 4

gane PersonWithAge heredan de persona.

De esta manera:

class PersonWithAge : Person 
{ 
     public int Age { get; set; } 
} 

Answer 5

No se puede emitir dos tipos sin relación entre sí. Podría hacer posible convertir PersonWithAge en Person permitiendo que PersonWithAge herede de Person. Desde PersonWithAge es obviamente un caso especial de una persona, esto tiene mucho sentido:

class Person 
{ 
     public int Id { get; set; } 
     public string Name { get; set; } 
} 

class PersonWithAge : Person 
{ 
     // Id and Name are inherited from Person 

     public int Age { get; set; } 
} 

Ahora bien, si usted tiene una IEnumerable<PersonWithAge> nombrado personsWithAge, entonces personsWithAge.Cast<Person>() va a funcionar.

En VS 2010 Incluso será capaz de saltar el fundido por completo y hacer (IEnumerable<Person>)personsWithAge, ya IEnumerable<T> es covariante en .NET 4.

Answer 6

Puede mantener el IEnumerable<PersonWithAge> y no convertirlo en IEnumerable<Person>. Simplemente agregue una conversión implícita para convertir un objeto de PersonWithAge a Person cuando lo necesite.

class Person 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public static implicit operator Person(PersonWithAge p) 
    { 
     return new Person() { Id = p.Id, Name = p.Name }; 
    } 
} 

---

List<PersonWithAge> pwa = new List<PersonWithAge> 
Person p = pwa[0];