隱藏IEnumerable到另一個IEnumerable C＃

Question

來自JS/PHP/Node的背景，對C＃應用程序開發有些新鮮。在MVC應用上工作。

我需要從我的服務中返回一個對象IEnumerable<Car>到我的控制器。我的服務調用我的存儲庫返回IEnumberable<CarEntity>

我想不出如何將CarEntity列表轉換爲Car列表。

汽車看起來像

public int CarId { get; set; } 
    public string CarColor { get; set; } 
    public string CarMake { get; set; } 
    public string CarModel { get; set; } 

和CarEntity看起來像

public int Id { get; set; } 
    public string Color { get; set; } 
    public string Make { get; set; } 
    public string Model { get; set; } 
    public string SomeOtherProp { get; set;} 

這是一個例子，但是這通常是我需要的。我是否需要通過我的CarEntity列表進行某種循環，並將每個列表推送到Car列表中？我會認爲這樣做有一些更精明的方法。

Answer 1

是的。您需要爲汽車實體列表集合中的每個項目創建一個新的Car對象並分配屬性值。你可以做，在foreach循環

var carEntityList= new List<CarEntity>(); //assume this has items 
var carList = new List<Car>(); 
foreach(car carEntity in carEntityList) 
{ 
    var c= new Car(); 
    c.CarId =carEntity.Id; 
    // to do : Map other property values as well. 
    carList.Add(c);  
} 

或者使用便捷LINQ擴展方法如IEnumerable.Select

var carEntityList= new List<CarEntity>(); //assume this has items 
var carList = carEntityList.Select(s=>new Car { 
               CarId = s.Id, 
               CarColor = s.Color, 
               CarModel = s.Model, 
               CarMake = s.Make 
               } 
           ); 

Answer 2

長手的方法是使用上IEnumerable<T> LINQ的.Select擴展方法來project一個項目從一個集合到另一個集合：

IEnumberable<CarEntity> carEntities = repository.GetCars(); 

IEnumerable<Car> cars = 
    carEntities 
    .Select(c => 
     new Car 
     { 
      CarId = c.Id, 
      CarColor = c.Color, 
      //etc. 
     }); 

有像AutoMapper這樣的工具，但我沒有經驗。

Answer 3

假設results是IEnumerable<CarEntity>：

IEnumerable<Car> cars = results.Select(c=> new Car{Brand = c.Brand, Color = c.Color}); 

Answer 4

List<Car> cars = results.Select(r=> new Car(){CarId = r.Id, CarColor = r.Color .... etc}}).ToList(); 

results將是你的IEnumerable

Answer 5

它實際上是安靜的簡單 讓我們假設您的收藏如下

IEnumerable<Car>=cars; 
IEnumerable<CarEntity>=entities; 

foreach(CarEntity e in entities){ 
     Car c = new Car(e.Id,e.Color,e.Make,e.Model); 
     cars.Add(c); 
} 

Answer 6

只是輸入，如果你有實體的很多的，你需要（可能應該）將它們轉換成不同用途的其他邊界對象，我會把那：10那麼你的代碼應該在這樣所有實體運行在實體的擴展類中映射邏輯。

這是爲了不放置對實體的依賴 - 以及可能的其他數據庫或與持久層超出持久層邊界的其他特定依賴關係。 此外，它還爲您提供了一個很好的地方來檢查所有的映射規則 - 易於測試和更改，並且可以製作出很好的上下文特定模型，實現他們所需的上下文，就像這個Car類添加了「馬」到馬力屬性。

我創造出這個這個小例子：

public class CarRepository 
{ 
    private readonly SqlCarStore _carStore; 

    public CarRepository(SqlCarStore carStore) 
    { 
     _carStore = carStore; 
    } 

    public IEnumerable<Car> GetCars() 
    { 
     IEnumerable<CarEntity> dbCars = _carStore.GetCars(); 
     return dbCars.Select(c => c.ToCar()); 

    } 
} 
public static class CarEntityExtensions 
{ 
    //Maps from CarEntity to Car 
    public static Car ToCar(this CarEntity entityCar) 
    { 
     return new Car 
     { 
      Make = entityCar.Make, 
      Model = entityCar.Model, 
      Year = entityCar.Year, 
      HorsePower = entityCar.HorsePower.ToString(), 

     }; 
    } 
} 
public class CarEntity 
{ 
    public string Id { get; set; } 
    public string Make { get; set; } 
    public string Model { get; set; } 
    public string Year { get; set; } 
    public int HorsePower { get; set; } 
} 

public class Car 
{ 
    private string _horsePower; 
    public string Make { get; set; } 
    public string Model { get; set; } 
    public string Year { get; set; } 

    public string HorsePower 
    { 
     get { return _horsePower; } 
     set { _horsePower = $"{value} horses"; } 
    } 
} 

Answer 7

另一個LINQ的中心的解決方案，如果你做了很多的CarEntity到Car映射是創建一個隱式轉換和使用演員<>：

public static implicit operator Car(CarEntity aCE) { 
    return new Car() { CarId = aCE.Id, CarColor = aCE.Color, 
     CarMake = aCE.Make, CarModel = aCE.Model }; 
} 

然後你可以只是

List<Car> cars = carEntities.Cast<Car>();