¿Cómo hacer una lista genérica igual otra lista genérica

Question

Ésta es mi creación,

class CostPeriodDto : IPeriodCalculation 
{ 
    public decimal? a { get; set; } 
    public decimal? b { get; set; } 
    public decimal? c { get; set; } 
    public decimal? d { get; set; } 
} 

interface IPeriodCalculation 
{ 
    decimal? a { get; set; } 
    decimal? b { get; set; } 
} 

class myDto 
{ 
    public List<CostPeriodDto> costPeriodList{ get; set; } 

    public List<IPeriodCalculation> periodCalcList 
    { 
     get 
     { 
      return this.costPeriodList; // compile error 
     } 
    } 
} 

¿Cuál sería la mejor manera de hacer esto?

Answer 1

Pruebe return this.costPeriodList.Cast<IPeriodCalculation>().ToList().

Answer 2

Uso Cast<IPeriodCalculation>():

public class CostPeriodDto : IPeriodCalculation 
{ 
    public decimal? a { get; set; } 
    public decimal? b { get; set; } 
    public decimal? c { get; set; } 
    public decimal? d { get; set; } 
} 

public interface IPeriodCalculation 
{ 
    decimal? a { get; set; } 
    decimal? b { get; set; } 
} 

public class myDto 
{ 
    public List<CostPeriodDto> costPeriodList { get; set; } 

    public List<IPeriodCalculation> periodCalcList 
    { 
     get 
     { 
      return this.costPeriodList.Cast<IPeriodCalculation>().ToList();   
     } 
    } 
} 

Creo en C# 4, si estuviera usando algo implementar IEnumerable<out T>, simplemente podría hacerlo de la manera que lo escribió, y sería resuelto mediante Covariance.

class myDto 
{ 
    public IEnumerable<CostPeriodDto> costPeriodList{ get; set; } 

    public IEnumerable<IPeriodCalculation> periodCalcList 
    { 
     get 
     { 
      return this.costPeriodList; // wont give a compilation error  
     } 
    } 
} 

Answer 3

Los métodos LINQ para emitir a partir de una secuencia a otra no será igual. Es decir que la siguiente prueba fallaría si usó Cast()/ToList().

Assert.AreSame(myDto.costPeriodList, myDto.periodCalcList); 

Por otra parte, el uso de estos métodos significa que si se trató de agregar un elemento a una colección, no serían reflejadas en el otro. Y cada vez que llamó a periodCalcList, crearía una colección completamente nueva que podría ser desastrosa según la cantidad de elementos, la frecuencia con la que se llama, etc.

Una mejor solución, en mi opinión, es no usar List<T> para sosteniendo el CostPeriodDto y en su lugar usar una colección derivada de Collection<T> e implementar explícitamente IEnumerable<IPeriodCalculation>. Opcionalmente podría implementar IList<IPeriodCalculation> si lo necesitara.

class CostPeriodDtoCollection : 
    Collection<CostPeriodDto>, 
    IEnumerable<IPeriodCalculation> 
{ 

    IEnumerable<IPeriodCalculation>.GetEnumerator() { 
     foreach (IPeriodCalculation item in this) { 
      yield return item; 
     } 
    } 

} 

class MyDto { 
    public CostPeriodDtoCollection CostPeriods { get; set; } 
    public IEnumerable<IPeriodCalculation> PeriodCalcList { 
     get { return CostPeriods; } 
    } 
}