使用AutoMapper

一、AutoMapper初探：

[参考Using AutoMapper: Getting Started]

1.新建空的ASP.NET MVC项目。

2.在Models文件夹添加类：

    public class Book
    {
        public string Title { get; set; }
    }

    public class BookViewModel
    {
        public string Title { get; set; }
    }

3.安装AtuoMapper：

Install-Package AutoMapper

4.在App_Start文件夹添加配置类：

    public static class AutoMapperConfig
    {
        public static void RegisterMappings()
        {
            AutoMapper.Mapper.CreateMap<Book, BookViewModel>();
        }
    }

5.在Global.asax中注册：

AutoMapperConfig.RegisterMappings();

6.新建HomeController：

        public string Index()
        {
            var book = new Book{Title="水浒传" };
            var bookModel = AutoMapper.Mapper.Map<Book>(book);
            return bookModel.Title;
        }

7.运行程序：

　　

二、创建映射：

[参考Using AutoMapper: Creating Mappings]

1.CreateMap方法：

　　AutoMapper所有映射都是使用CreateMap方法定义的：

AutoMapper.Mapper.CreateMap<SourceClass, DestinationClass>();

　　需要注意的是，上面定义的映射是单向映射。例如，我们定义了如下映射：

AutoMapper.Mapper.CreateMap<Book, BookViewModel>();

　　我们可以将一个Book实例映射到一个BookViewModel实例：

var bookViewModel = AutoMapper.Mapper.Map<BookViewModel>(book);

　　但是我们不能将一个BookViewModel实例映射到一个Book实例：

var book = AutoMapper.Mapper.Map<Book>(bookViewModel);

　　如果要实现双向映射，需要再次调用CreateMap方法定义：

AutoMapper.Mapper.CreateMap<Book, BookViewModel>();
AutoMapper.Mapper.CreateMap<BookViewModel, Book>();

　　如果我们不需要为反向映射定义任何自定义映射逻辑，我们可以使用ReverseMap实现双向映射：

AutoMapper.Mapper.CreateMap<Book, BookViewModel>().ReverseMap();

2.映射规则：

　　AutoMapper有一些映射约定，其中一个约定就是同名映射。例如：

public class Book
{
    public string Title { get; set; }
}

public class NiceBookViewModel
{
    public string Title { get; set; }
}

public class BadBookViewModel
{
    public string BookTitle { get; set; }
}

　　如果我们将一个Book实例映射到一个NiceBookViewModel实例，Title属性的值会是我们所期望的值。然而如果我们将一个Book实例映射到一个BadBookViewModel实例，Title属性的值会为null。因为名字不同，AutoMapper无从知晓BookTitle需要从Title获取值。这种情况下就需要我们手动添加配置代码：

AutoMapper.Mapper.CreateMap<Book, BadBookViewModel>()
    .ForMember(dest => dest.BookTitle,
               opts => opts.MapFrom(src => src.Title));

　　另一个约定涉及到嵌入对象。例如：

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

public class Book
{
    public string Title { get; set; }
    public Author Author { get; set; }
}

public class BookViewModel
{
    public string Title { get; set; }
    public string Author { get; set; }
}

　　尽管Book和BookViewModel都有Author属性，但是它们的类型不匹配，因此AutoMapper不能将Book.Author映射到BookViewModel.Author。对于嵌入对象，AutoMapper的约定是目标类属性的命名为骆驼拼写法的“对象名+对象属性名”。示例如下：

public class BookViewModel
{
    public string Title { get; set; }
    public string AuthorName { get; set; }
}

　　如果不采用约定，我们依然可以使用配置代码：

AutoMapper.Mapper.CreateMap<Book, BookViewModel>()
    .ForMember(dest => dest.Author,
               opts => opts.MapFrom(src => src.Author.Name));

3.投影：

　　在之前的示例中，如果我们把Author类修改为：

public class Author
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

　　我们需要将这两个属性映射到一个属性，代码如下：

AutoMapper.Mapper.CreateMap<Book, BookViewModel>()
    .ForMember(dest => dest.Author,
               opts => opts.MapFrom(
                   src => string.Format("{0} {1}",
                       src.Author.FirstName,
                       src.Author.LastName)));

4.更复杂的投影：

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }
}

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Address Address { get; set; }
}

public class PersonDTO
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }
}

　　如果我们要把PersonDTO映射到Person，代码如下：

AutoMapper.Mapper.CreateMap<PersonDTO, Person>()
    .ForMember(dest => dest.Address,
               opts => opts.MapFrom(
                   src => new Address
                   {
                       Street = src.Street,
                       City = src.City,
                       State = src.State,
                       ZipCode = src.ZipCode
                   }));

5.嵌套映射：

　　上面的示例中，如果PersonDTO修改为：

public class AddressDTO
{
    public string Street { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }
}

public class PersonDTO
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public AddressDTO Address { get; set; }
} 

　　映射应该修改为：

AutoMapper.Mapper.CreateMap<PersonDTO, Person>();
AutoMapper.Mapper.CreateMap<AddressDTO, Address>();

三、映射到实例：

[参考Using AutoMapper: Mapping Instances]

1.映射到新的实例：

　　之前的示例均产生一个新的实例，例如：

var destinationObject = AutoMapper.Mapper.Map<DestinatationClass>(sourceObject);

2.映射到已经存在的实例：

AutoMapper.Mapper.Map(sourceObject, destinationObject);

3.映射到集合：

var destinationList = AutoMapper.Mapper.Map<List<DestinationClass>>(sourceList);

　　我们可以映射到所有的集合类型和接口：List<T>、ICollection<T>、IEnumerable<T>等。

　　但是如果我们尝试映射到现有的实例：

AutoMapper.Mapper.Map(sourceList, destinationList);

　　我们会发现destinationList已经被损坏。因为AutoMapper实际上是映射到集合而不是分别映射到集合中的对象。当我们考虑对象的层级结构时，这种情况就变得十分讨厌。例如：

public class Pet
{
    public string Name { get; set; }
    public string Breed { get; set; }
}

public class Person
{
    public List<Pet> Pets { get; set; }
}

public class PetDTO
{
    public string Name { get; set; }
    public string Breed { get; set; }
}

public class PersonDTO
{
    public List<PetDTO> Pets { get; set; }
}

　　如果我们创建一个只更新Name属性的表单，我们提交的对象图会是这样：

{
    Pets: [
        { Name : "Sparky", Breed : null },
        { Name : "Felix", Breed : null },
        { Name : "Cujo", Breed : null }
    ]
}

　　由于Breed属性没有被传递，它在每个PetDTO中的值为null。现在如果我们使用PersonDTO更新Person：

AutoMapper.Mapper.Map(person, personDTO);

　　这样Person中每个Pet的Breed属性均变为null。这种问题解决起来有点麻烦，首先我们需要使用Ignore方法：

AutoMapper.Mapper.CreateMap<PersonDTO, Person>()
    .ForMember(dest => dest.Pets,
               opts => opts.Ignore());

　　上面的代码告诉AutoMapper不映射Pets集合，这就意味着我们现在必须手动处理：

AutoMapper.Mapper.Map(person, personDTO);
for (int i = 0; i < person.Pets.Count(); i++)
{
    AutoMapper.Mapper.Map(person.Pets[i], personDTO.Pets[i]);
}

　　上面的代码是基于假设两个list是相同的即我们没有对它们重新排序，并且不允许在表单添加或者删除项。为了解决重新排序后不一致的问题，我们需要依赖某些标识属性。例如：

var pet = person.Pets[i];
var updatedPet = personDTO.Pets.Single(m => m.Id == pet.Id);
AutoMapper.Mapper.Map(pet, updatedPet);

　　添加或者删除项会更复杂一些：

var updatedPets = new List<Pet>();
foreach (var pet in personDTO.Pets)
{
    var existingPet = person.Pets.SingleOrDefault(m => m.Id == pet.Id);
    // No existing pet with this id, so add a new one
    if (existingPet == null)
    {
        updatedPets.Add(AutoMapper.Mapper.Map<Pet>(pet));
    }
    // Existing pet found, so map to existing instance
    else
    {
        AutoMapper.Mapper.Map(existingPet, pet);
        updatedPets.Add(existingPet);
    }
}
// Set pets to updated list (any removed items drop out naturally)
person.Pets = updatedPets;

　　这可能是使用AutoMapper最大的难点，但是只要我们在执行更新操作的时候记得手动映射list项就行了。