AutoMapper

项目地址:AutoMapper

1.Flattening

配置器尝试匹配源类型中的属性和方法到目的类型，对于源类型中以"Get"为前缀的方法或属性，AutoMapper会按照驼峰命名格式分割这个属性或方法并映射到对应的目的类型中

 public class Order
    {
        private readonly IList<OrderLineItem> _orderLineItems = new List<OrderLineItem>();

        public Customer Customer { get; set; }

        public OrderLineItem[] GetOrderLineItems()
        {
            return _orderLineItems.ToArray();
        }

        public void AddOrderLineItem(Product product, int quantity)
        {
            _orderLineItems.Add(new OrderLineItem(product, quantity));
        }

        public decimal GetTotal()
        {
            return _orderLineItems.Sum(li => li.GetTotal());
        }
    }

    public class Product
    {
        public decimal Price { get; set; }
        public string Name { get; set; }
    }

    public class OrderLineItem
    {
        public OrderLineItem(Product product, int quantity)
        {
            Product = product;
            Quantity = quantity;
        }

        public Product Product { get; private set; }
        public int Quantity { get; private set;}

        public decimal GetTotal()
        {
            return Quantity*Product.Price;
        }
    }

    public class Customer
    {
        public string Name { get; set; }
    }

 public class OrderDto
    {
        public string CustomerName { get; set; }
        public decimal Total { get; set; }
    }

 var customer = new Customer
        {
            Name = "George Costanza"
        };
    var order = new Order
        {
            Customer = customer
        };
    var bosco = new Product
        {
            Name = "Bosco",
            Price = 4.99m
        };
    order.AddOrderLineItem(bosco, 15);

    // 配置AutoMapper

    Mapper.CreateMap<Order, OrderDto>();

    // 执行 mapping

    OrderDto dto = Mapper.Map<Order, OrderDto>(order);

    dto.CustomerName.ShouldEqual("George Costanza");
    dto.Total.ShouldEqual(74.85m);

2.Projection(映射)

 public class CalendarEvent
    {
        public DateTime Date { get; set; }
        public string Title { get; set; }
    }

 public class CalendarEventForm
    {
        public DateTime EventDate { get; set; }
        public int EventHour { get; set; }
        public int EventMinute { get; set; }
        public string Title { get; set; }
    }

 // Model
    var calendarEvent = new CalendarEvent
        {
            Date = new DateTime(2008, 12, 15, 20, 30, 0),
            Title = "Company Holiday Party"
        };

    // 配置AutoMapper
    Mapper.CreateMap<CalendarEvent, CalendarEventForm>()
        .ForMember(dest => dest.EventDate, opt => opt.MapFrom(src => src.Date.Date))
        .ForMember(dest => dest.EventHour, opt => opt.MapFrom(src => src.Date.Hour))
        .ForMember(dest => dest.EventMinute, opt => opt.MapFrom(src => src.Date.Minute));

    // 执行mapping
    CalendarEventForm form = Mapper.Map<CalendarEvent, CalendarEventForm>(calendarEvent);

    form.EventDate.ShouldEqual(new DateTime(2008, 12, 15));
    form.EventHour.ShouldEqual(20);
    form.EventMinute.ShouldEqual(30);
    form.Title.ShouldEqual("Company Holiday Party");

 3.Configuration validation

  public class Source
    {
        public int SomeValue { get; set; }
    }

    public class Destination
    {
        public int SomeValuefff { get; set; }
    }

   Mapper.CreateMap<Source, Destination>();

    Mapper.AssertConfigurationIsValid();

当目的类型中的属性与源类型中的不匹配是会抛出'AutoMapperConfigurationException'异常，通过以下方式解决：

a.重命名

b.配置映射(Projection)

 Mapper.CreateMap<Source, Destination>()
       .ForMember(a => a.SomeValuefff, b => b.MapFrom(c => c.SomeValue));

c.使用Ignore()选项

 Mapper.CreateMap<Source, Destination>()
       .ForMember(dest => dest.SomeValuefff, opt => opt.Ignore());

4.Lists and arrays

public class Source
    {
        public int Value { get; set; }
    }

    public class Destination
    {
        public int Value { get; set; }
    }

Mapper.CreateMap<Source, Destination>();

    var sources = new[]
        {
            new Source { Value = 5 },
            new Source { Value = 6 },
            new Source { Value = 7 }
        };

    IEnumerable<Destination> ienumerableDest = Mapper.Map<Source[], IEnumerable<Destination>>(sources);
    ICollection<Destination> icollectionDest = Mapper.Map<Source[], ICollection<Destination>>(sources);
    IList<Destination> ilistDest = Mapper.Map<Source[], IList<Destination>>(sources);
    List<Destination> listDest = Mapper.Map<Source[], List<Destination>>(sources);
    Destination[] arrayDest = Mapper.Map<Source[], Destination[]>(sources);