How to get started with AutoMapper and ASP.NET Core 2
If you were to ask a group of ASP.NET developers to name their most installed and used packages, I’d be surprised if the majority didn’t have AutoMapper on their list.
At the time of writing, AutoMapper on NuGet.org has been downloaded 17,291,772 times and sits at the number 6 spot in the top 100 most downloaded community packages over the last 6 weeks. But what is AutoMapper?
What is AutoMapper?
I’m sure you’ve been in this scenario countless times: you’ve got an ASP.NET web application, and you want to keep the separation between your domain models and your view models. So you write code that allows you to map your domain model into your view model. Then, as you add more views and domain models, you end up writing more mappers. Then you write mappers to map your domain transfer objects from your database layer into your domain objects…you get the point.
This code is mundane and repetitive. And this is where AutoMapper comes in. It’s a convention-based object-to-object mapper that requires little configuration.
AutoMapper is a convention-based object-to-object mapper that requires little configuration.
Here’s how you can get started with AutoMapper.
Getting started with AutoMapper
Step 1: Installing AutoMapper
For this example you’ll need to create an ASP.NET Core 2 web application (I’m using Visual Studio 2017 in Windows).
There are a couple of ways you can install AutoMapper, you can either right-click the web project and select Manage NuGet Packages and then search for and install the
Or you can use the Package Manager Console with the following command:
By installing the
AutoMapper.Extensions.Microsoft.DependencyInjection package, it will automatically install the AutoMapper package for you as well.
Step 2: Configuring AutoMapper
You can now go ahead and configure AutoMapper in your
Startup.cs class under the
Let’s create a
User Model in the
Along with our
User Model we also want to create a new
ViewModel that will eventually be used to display our
Now we’ve got our
User Model and our
User ViewModel, how do we tell AutoMapper to map from our
User Mode to our
User ViewModel? Well, we use a Profile.
Profiles in AutoMapper are a good way of organizing your mapping collections. To create a
Profile, we create a new class and inherit from
Profile. We can then add our mapping configuration inside our new classes constructor.
Go head and create a
UserProfile class to map our
User Model to our
We now have a
UserProfile class that creates the mapping between our
User Model and
User ViewModel. But how does AutoMapper know about our
Well, if you remember, towards the start of this example we added this line of code to our
ConfigureServices method in
When our application starts up and adds AutoMapper, AutoMapper will scan our assembly and look for classes that inherit from
Profile, then load their mapping configurations.
Step 3: AutoMapper in action
Let’s create a new
UserController in the
To use our configured mappings, we need to inject the
IMapper interface into the constructor of our
Profiles, by calling AddAutoMapper in our
ConfigureServices method, it’s taken care of registering
IMapper for us.
Index Action method, let’s create a
We can now use the
IMapper interface that we injected into our constructor and call the
We give the
Map method the type we want to map to and the object we would like to map from:
In the code above, I’ve also passed our newly mapped
User ViewModel into the view.
Finally — we can now create a view for our controller using our
Time for the big reveal — run the application and navigate to /user (in my case I went to http://localhost:64877/user):
There you have it — you should be able to see the properties that we used when creating our
User have been mapped to our
User ViewModel and are now being shown.
With Automapper you can map one object to another throughout your application with just a little configuration.
We’ve just scratched the surface of what AutoMapper has to offer in terms of mapping objects from one to another, but I hope you can see how easy it is to get up and running with it.
I encourage you to continue exploring AutoMappers feature set and usages in the documentation link below.