Auto Mapper in MVC:
When
we code for a realistic actual environment, we encounter many
challenges to refractor our code for a better understanding and to
easily identify the bugs. We mainly focus on re usability and try to
move as much code as possible to a common method so that development
time and maintenance costs are reduced.
In
this article, I will try to cover a new concept in MVC: AutoMapper is used to reduce the complexity we find when binding the
model and communicating with entities.
The
Real Problem:
We
often interact with our database entities and bind our models with
it. What we end up with is somewhat like this:
//Return
UserDTO Class
public UserDto GetUserById(string id)
{
//Create
new Object for DTO class
var
userDto = new UserDto();
//Create
New Object For Entity(DB class)
using(var
context = new EntityDBContext())
{
//Get
the single row from DB using LINQ query
//It
always use using statement for best practice to dispose object
automatically
var
user = context.Users.Where(ID => ID.user_id ==
id).FirstOrDefaul();
if
(user != null)
{
//Fill DB object to UserDTO Class
userDto.UserId
= user.user_id;
userDto.Name
= user.user_name;
userDto.Address
= user.user_address;
userDto.PhoneNo
= user.user_phoneNo;
userDto.City
= user.user_city;
}
}
return
userDto;
}
We
see here that there are five properties in each class. And what we
are doing here is binding the db context class to our model and then
passing it to the view. Now, this looks quite simple in this case.
The real problem arises when we have 25-30 fields in a record from
the database and we need to repeat this same binding code all over in
the project. It's awkward and painful. Copying and pasting even if
it's only five properties.
More
complexity arises when we have a separate ViewModel for each view
(which is typically used in current MVC across the companies). Now
you have double the amount of work, first you need to bind your model
and then again you need to bind it to the ViewModel. Think of how
tedious that job would be.
To
overcome this tedious situation AutoMapper is introduced. It not only
reduces the effort but it also limits the execution time that has
been taken by such a large number of lines to execute.
What is AutoMapper:
AutoMapper
is an object-object mapper. Object-object mapping works by
transforming an input object of one type into an output object of a
different type. What makes AutoMapper interesting is that it provides
some interesting conventions to take the dirty work out of figuring
out how to map type A to type B. As long as type B follows
AutoMapper's established conventions, almost zero configuration is
needed to map two types." Therefore, it provides the solution
for our mapping issue.
Tools
-> Library Packet Manager -> Packet manager Console
Then
in the console window opened at the bottom of Visual Studio, type:
PM>
Install-Package AutoMapper
Press
Enter, this will install AutoMapper and the next time you open an MVC
application in Visual Studio, it will automatically add a DLL
reference to the project.
Use of Automapper:
Now
we will see where AutoMapper fits in our problem. Well, AutoMapper
provides a CreateMap<T1,T2> method that provides mapping
between two classes. So, the entire code can be replaced by the
following single line:
There
are two steps to use this Automapper
Step 1 :
//UserDTO-DTO
Object Class//User-Model
Class to bind the View//Fill
UserDTO to User model
Mapper.CreateMap<User,
UserDto>();
Step 2 :
Mapper.Map<User,UserDto >(user);
Where
User is a DBContext class type and UserDto is our DTO class to map.
Finally:to
map all the data we need to use the Map<T1,T2>() method of the
AutoMapper class. So the final code will look like this:
public
UserDto GetUserById(string id)
{
var
userDto = new UserDto();
using(var
context = new EntityDBContext())
{
var
user = context.Users.Where(ID => ID.user_id ==
id).FirstOrDefault();
//Create
Map for DTO and Model Object
Mapper.CreateMap<User,UserDto
>();
//Fill
the DTO object to Model Object and reduce the lot of code.
userDto
= Mapper.Map<User,UserDto >(user);
}
return
userDto;
}
So,
we avoided the boring work of mapping properties in the code. Our
CRUD operation is also simplified and organized. Just map the classes
and then do Post actions. To get all the details, one change we need
to make to the preceding code is that we need to add all the userDto
objects to a List of userDtos.
ForMember()
and MapFrom() in AutoMapper
Two
important functions in AutoMapper play an important role in object
mapping. Suppose our model/viewmodel class has a property FullName,
and from the DTO we want to add the First Name and Last Name of the
user to make it a full name and bind it to the model. For these kinds
of scenarios ForMember() andMapFrom() come
in handy. See below code:
Mapper.CreateMap<LearningMVC.User, LearningMVC.Models.User>().ForMember(emp => emp.Fullname,
map => map.MapFrom(p => p.FirstName + " " + p.LastName));
Here we are saying that ForMember FullName in our model class maps properties from FirstName and LastName of User DTO.
The code itself is self-explanatory. This kind of mapping is also called Custom Mapping.
