Automapper Tutorial

Criado por Alisson Pereira

O AutoMapper uma biblioteca pequena e simples construda

para resolver um problema aparentemente complexo, que
livrar-se de um cdigo que mapeou um objeto para outro. Este
tipo de problema muito comum e relativamente trabalhoso de
resolver, a ferramenta AutoMapper atua nesse cenrio de forma
simples e elegante.
Mapeamento de um Model para uma Entidade:
Entidade Cliente:

ViewModel Cliente:

Na classe ClienteViewModel possumos a mesma estrutura de

clientes, mais o dado adicional de nmero da sorte e os
DataAnnotations para validao de formulrio.
Aps a separao das responsabilidades temos uma Model e
uma View Model, ambas representando a entidade cliente, agora
necessrio mapear um objeto ao outro para que a
ClienteController receba a Model cliente e responda para View
uma ClienteViewModel (e vice-versa), esse trabalho executado
pelo AutoMapper.
Configurando o AutoMapper no projeto ASP.Net MVC
Primeiramente necessrio configurar as referncias das
bibliotecas do AutoMapper e isto pode ser feito facilmente com o
NuGet

(install-package AutoMapper)

No projeto MVC crie uma pasta vazia chamada Mappers, dentro

desta pasta ser necessrio criar uma classe que servir de
configurao dos profiles de mapeamento (Model > View Model)
e (View Model > Model), esses profiles de mapeamento foram
separados em dois arquivos, confira como abaixo como criar
cada um deles.

Classe AutoMapperConfig
using AutoMapper;
namespace MvcMapping.Mappers
{
public class AutoMapperConfig
{
public static void RegisterMappings()
{
Mapper.Initialize(x =>
{
x.AddProfile<DomainToViewModelMappingProfile>();
x.AddProfile<ViewModelToDomainMappingProfile>();
});
}
}
}

Classe DomainToViewModelMappingProfile
using AutoMapper;
using MvcMapping.Models;

using MvcMapping.ViewModels;
namespace MvcMapping.Mappers
{
public class DomainToViewModelMappingProfile : Profile
{
public override string ProfileName
{
get { return "DomainToViewModelMappings"; }
}
protected override void Configure()
{
Mapper.CreateMap<Cliente, ClienteViewModel>();
}
}

Classe ViewModelToDomainMappingProfile
using AutoMapper;
using MvcMapping.Models;
using MvcMapping.ViewModels;
namespace MvcMapping.Mappers
{
public class ViewModelToDomainMappingProfile : Profile
{
public override string ProfileName
{
get { return "ViewModelToDomainMappings"; }
}
protected override void Configure()
{
Mapper.CreateMap<ClienteViewModel, Cliente>();
}
}

Esta a estrutura necessria para configurar o AutoMapper de

forma a utilizar o mnimo possvel de cdigo de mapeamento em
outras classes da aplicao.

AutoMapperConfig > Inicializa os profiles de mapeamento

(Model > View Model) e (ViewModel > Model).

DomainToViewModelMappingProfile

>

Profile

de

mapeamento (Model > View Model)

ViewModelToDomainMappingProfile >
mapeamento (View Model > Model)

Profile

de

Confira como o projeto ficou estruturado

Neste
momento
resta
apenas
configurar
que
a
classe AutoMapperConfig seja inicializada junto com a aplicao
para registrar os profiles de mapeamento, essa configurao
feita no arquivo Global.asax
Application_Start
AutoMapperConfig.RegisterMappings();

Agora ser feito a converso do model Cliente para o

ClienteViewModel

AutoMapper.Mapper.CreateMap<Origem, Destino>();

// Transformando a Model Cliente em ClienteViewModel

var clienteView = Mapper.Map<Cliente, ClienteViewModel>(cliente);
// Atribuindo valor aos dados adicionais da entidade Cliente
clienteView.NumeroDaSorte = rdnGen.Next(1, 100);

Note que foi necessrio apenas uma linha para transformar a

Model Cliente em ClienteViewModel. De forma muito elegante foi
criado um objeto do tipo ClienteViewModel j populado com os
dados existentes no objeto Cliente.
Para mapear mais Models / View Models basta editar os
arquivos DomainToViewModelMappingProfile
e ViewModelToDomainMappingProfile com os mapeamentos necessrios.
Existe uma forma que dispensa toda essa configurao (inclusive
inicializao no Global.asax), basta adicionar uma linha a mais em cada
momento que houver o mapeamento, conhecido como mapeamento por
demanda.

// Criando o Mapeamento por demanda.

Mapper.CreateMap<Cliente, ClienteViewModel>();
// Transformando a Model Cliente em ClienteViewModel
var clienteView = Mapper.Map<Cliente, ClienteViewModel>(cliente);
// Atribuindo valor aos dados adicionais da entidade Cliente
clienteView.NumeroDaSorte = rdnGen.Next(1, 100);

Apesar de ser mais simples eu pessoalmente no recomendo

utilizar o mapeamento desta forma, pois alm de somar uma
linha a mais em todo momento de executar o mapeamento, o
comando de criao de mapeamento no fica centralizado,
difcil ter viso dos mapeamentos j existentes e dificulta
tambm a manuteno.

Para situaes onde necessrio que acontea o mapeamento

de um atributo x para um atributo y necessrio especificar no
mapeamento do AutoMapper (de quem para quem ser
mapeado).
Exemplo 1:

public class Book

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

No exemplo acima ser mapeado o atributo Title da classe Book

para o atributo BookTitle da classe BadBookViewModel, para

realizar esse tipo de mapeamento necessrio seguir o

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

Onde especificado que no mapeamento de book para

badBookViewModel ir mapear o atributo title para bookTitle.
Exemplo 2:
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; }
}

Mapeando Book.Author.Name para BookViewModel.Author

ou seja mapeando um atributo (Name) da entidade

chamada Author que por si um atributo da class Book
para o atributo string da class BookViewModel.

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

Extras
1) Mapeando uma lista:
var destinationList = AutoMapper.Mapper.Map<List<Destino>>(origem);

2) Ignorar o mapeamento de uma propriedade:

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

Utilizar Ignore para impedir o mapeamento do atributo x, no

exemplo acima o atributo o Pets.