将一个对象映射到另一个对象的最佳实践

Question

我的问题是，我可以以最易维护的方式将一个对象映射到另一个对象的最佳方式是什么。我无法改变我们得到的Dto对象被设置为更规范化的方式，所以我需要创建一种方法将其映射到我们的对象实现。

下面是示例代码来说明我需要发生：

class Program 
{ 
    static void Main(string[] args) 
    { 
     var dto = new Dto(); 

     dto.Items = new object[] { 1.00m, true, "Three" }; 
     dto.ItemsNames = new[] { "One", "Two", "Three" };    

     var model = GetModel(dto); 

     Console.WriteLine("One: {0}", model.One); 
     Console.WriteLine("Two: {0}", model.Two); 
     Console.WriteLine("Three: {0}", model.Three); 
     Console.ReadLine(); 
    } 

    private static Model GetModel(Dto dto) 
    { 
     var result = new Model(); 

     result.One = Convert.ToDecimal(dto.Items[Array.IndexOf(dto.ItemsNames, "One")]); 
     result.Two = Convert.ToBoolean(dto.Items[Array.IndexOf(dto.ItemsNames, "Two")]); 
     result.Three = dto.Items[Array.IndexOf(dto.ItemsNames, "Three")].ToString(); 

     return result; 
    } 
} 

class Dto 
{ 
    public object[] Items { get; set; } 
    public string[] ItemsNames { get; set; } 
} 

class Model 
{ 
    public decimal One { get; set; } 
    public bool Two { get; set; } 
    public string Three { get; set; } 
} 

，我认为这将是巨大的，如果我有某种映射类的，将采取在模型对象的PropertyInfo，I型想要转换为，以及我想要提取的“itemname”。有没有人有任何建议，使这个更清洁？

谢谢！

Answer 1

这是使用有点反射的可能通用的实现（伪代码，不具有VS现在）：

public class DtoMapper<DtoType> 
{ 
    Dictionary<string,PropertyInfo> properties; 

    public DtoMapper() 
    { 
     // Cache property infos 
     var t = typeof(DtoType); 
     properties = t.GetProperties().ToDictionary(p => p.Name, p => p); 
    } 

    public DtoType Map(Dto dto) 
    { 
     var instance = Activator.CreateInstance(typeOf(DtoType)); 

     foreach(var p in properties) 
     { 
      p.SetProperty(
       instance, 
       Convert.Type(
        p.PropertyType, 
        dto.Items[Array.IndexOf(dto.ItemsNames, p.Name)]); 

      return instance; 
     } 
    } 

用法：

var mapper = new DtoMapper<Model>(); 
var modelInstance = mapper.Map(dto); 

这将是缓慢的，当你创建映射器实例，但稍后更快。

Answer 2

我会选择AutoMapper，这是一个开放源代码和免费的映射库，允许根据约定将一种类型映射到另一种类型（即具有相同名称和相同/衍生/可转换类型的映射公共属性，以及其他许多其他类型smart ones）。使用非常简单，将让你实现这样的事情：

Model model = Mapper.Map<Model>(dto); 

不知道您的具体要求，但AutoMapper还支持custom value resolvers，这将有助于你写一个单一，通用实现您的特定映射的。

Answer 3

/// <summary> 
/// map properties 
/// </summary> 
/// <param name="sourceObj"></param> 
/// <param name="targetObj"></param> 
private void MapProp(object sourceObj, object targetObj) 
{ 
    Type T1 = sourceObj.GetType(); 
    Type T2 = targetObj.GetType(); 

    PropertyInfo[] sourceProprties = T1.GetProperties(BindingFlags.Instance | BindingFlags.Public); 
    PropertyInfo[] targetProprties = T2.GetProperties(BindingFlags.Instance | BindingFlags.Public); 

    foreach (var sourceProp in sourceProprties) 
    { 
     object osourceVal = sourceProp.GetValue(sourceObj, null); 
     int entIndex = Array.IndexOf(targetProprties, sourceProp); 
     if (entIndex >= 0) 
     { 
      var targetProp = targetProprties[entIndex]; 
      targetProp.SetValue(targetObj, osourceVal); 
     } 
    } 
}