Comment faire une liste générique égale une autre liste générique

Question

Ceci est mon mis en place,

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

Quelle serait la meilleure façon de le faire?

Answer 1

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

Answer 2

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

Je crois en C# 4, si vous utilisez quelque chose de la mise en œuvre IEnumerable<out T>, vous pouvez simplement faire la façon dont vous l'avez écrit, et il serait résolu à l'aide Covariance.

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

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

Answer 3

Les méthodes LINQ à coulés à partir d'une séquence à l'autre ne sera pas égal . C'est-à-dire que le test suivant échouerait si vous utilisiez Cast()/ToList().

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

En outre, l'utilisation de ces méthodes signifie que si vous avez essayé d'ajouter un élément à une collection, ils ne seraient pas pris en compte dans l'autre. Et chaque fois que vous appelez periodCalcList, cela crée une collection entièrement nouvelle qui peut être désastreuse en fonction du nombre d'éléments, de la fréquence, etc.

Une meilleure solution, à mon avis, est de ne pas utiliser List<T> pour tenir le CostPeriodDto et utiliser à la place une collection dérivée de Collection<T> et implémenter explicitement IEnumerable<IPeriodCalculation>. En option, vous pouvez implémenter IList<IPeriodCalculation> si vous le souhaitez.

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