Simplify Object Mapping with Mapperly and Source Generators in .NET

Object mapping is a common task in software development, often involving repetitive code to transfer data between different layers of an application. With the advent of source generators in .NET, this process can be greatly simplified. In this post, we’ll explore how to use Mapperly—a powerful NuGet package—to streamline object mapping in your .NET applications.

Introduction to Mapperly

Mapperly is a NuGet package that leverages .NET source generators to automate object mapping. By using Mapperly, you can avoid writing boilerplate mapping code and focus on the core logic of your application.

Installation

To get started with Mapperly, you first need to install the NuGet package. You can do this using the .NET CLI:

dotnet add package Riok.Mapperly

This package provides the necessary tools to generate mapping code at compile time, which helps in reducing runtime overhead and improving performance.

Example: Mapping a Complex Object

Let’s dive into a practical example to see Mapperly in action. Suppose you have the following models:

Models

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

public class UserDto
{
    public string Username { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
}

public class UserProfileRequest
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public string Email { get; set; }
    public Address Address { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Defining the Mapper

Create a Mapper class with a partial method to handle the mapping:

using Riok.Mapperly.Abstractions;

[Mapper]
public partial class Mapper
{
    public partial UserDto ToUserProfileResponse(UserProfileRequest request);
}

Mapping Logic

In the Mapper class, you define how properties from UserProfileRequest should be mapped to UserDto. Mapperly handles the generation of the mapping code:

public class Program
{
    public static void Main()
    {
        var request = new UserProfileRequest
        {
            FirstName = "Jane",
            LastName = "Doe",
            Username = "jane.doe@1234",
            Password = "123456789",
            Email = "jane12@test.com",
            Address = new Address
            {
                Street = "123 Main St",
                City = "Springfield",
                State = "IL"
            },
            DateOfBirth = new DateTime(1990, 5, 15)
        };

        var mapper = new Mapper();
        var response = mapper.ToUserProfileResponse(request);

        Console.WriteLine($"Username: {response.Username}");
        Console.WriteLine($"Email: {response.Email}");
        Console.WriteLine($"Password: {response.Password}");
    }
}

Username: jane.doe@1234
Email: jane12@test.com
Address: 123 Main St, Springfield, IL

Explanation

In the code above, we create a UserProfileRequest object and use the Mapper class to convert it to a UserDto. The Mapper class is decorated with the [Mapper] attribute, which instructs Mapperly to generate the necessary code to map the UserProfileRequest to UserDto. This eliminates the need for manual mapping code, making your codebase cleaner and more maintainable.

Conclusion

Mapperly simplifies the process of object mapping by leveraging source generators to handle repetitive tasks. By installing the Riok.Mapperly package and using the [Mapper] attribute, you can automatically generate mapping code, reducing boilerplate and improving code readability.

For more details on Mapperly and to get started, check out the official documentation.