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 [Link] 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 [Link]
{
public class AutoMapperConfig
{
public static void RegisterMappings()
{
[Link](x =>
{
[Link]<DomainToViewModelMappingProfile>();
[Link]<ViewModelToDomainMappingProfile>();
});
}
}
}
Classe DomainToViewModelMappingProfile
using AutoMapper;
using [Link];
using [Link];
namespace [Link]
{
public class DomainToViewModelMappingProfile : Profile
{
public override string ProfileName
{
get { return "DomainToViewModelMappings"; }
}
protected override void Configure()
{
[Link]<Cliente, ClienteViewModel>();
}
}
Classe ViewModelToDomainMappingProfile
using AutoMapper;
using [Link];
using [Link];
namespace [Link]
{
public class ViewModelToDomainMappingProfile : Profile
{
public override string ProfileName
{
get { return "ViewModelToDomainMappings"; }
}
protected override void Configure()
{
[Link]<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 [Link]
Application_Start
[Link]();
Agora ser feito a converso do model Cliente para o
ClienteViewModel
[Link]<Origem, Destino>();
// Transformando a Model Cliente em ClienteViewModel
var clienteView = [Link]<Cliente, ClienteViewModel>(cliente);
// Atribuindo valor aos dados adicionais da entidade Cliente
[Link] = [Link](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 [Link]), basta adicionar uma linha a mais em cada
momento que houver o mapeamento, conhecido como mapeamento por
demanda.
// Criando o Mapeamento por demanda.
[Link]<Cliente, ClienteViewModel>();
// Transformando a Model Cliente em ClienteViewModel
var clienteView = [Link]<Cliente, ClienteViewModel>(cliente);
// Atribuindo valor aos dados adicionais da entidade Cliente
[Link] = [Link](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.
[Link]<Book, BadBookViewModel>()
.ForMember(dest => [Link],
opts => [Link](src => [Link]));
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 [Link] para [Link]
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.
[Link]<Book, BookViewModel>()
.ForMember(dest => [Link],
opts => [Link](src => [Link]));
Extras
1) Mapeando uma lista:
var destinationList = [Link]<List<Destino>>(origem);
2) Ignorar o mapeamento de uma propriedade:
[Link]<PersonDTO, Person>()
.ForMember(dest => [Link],
opts => [Link]());
Utilizar Ignore para impedir o mapeamento do atributo x, no
exemplo acima o atributo o Pets.