Introduction to Mapster in C#

For a long time, I relied exclusively on AutoMapper in my applications. Recently, however, I was introduced to Mapster, an alternative object mapping library for C#. Mapster offers a flexible and efficient way of mapping objects, and while I haven’t explored all its features yet, I focused on learning how to handle registrations effectively. Here’s what I discovered.

What is Mapster?

Mapster is a lightweight, fast, and flexible object mapping library for .NET. It allows you to map properties from one object to another with minimal configuration. Unlike AutoMapper, Mapster provides more granular control over mapping rules, making it highly customizable.

Setting up Mapster Configuration

To configure Mapster, you use the TypeAdapterConfig class. This class allows you to set up mapping rules and customize behavior according to your application’s needs.

One of the key properties is GlobalSettings, which returns a TypeAdapterConfig instance. This instance provides access to methods like Scan(), which can automatically register mappings by scanning assemblies that implement the IRegister interface. This approach helps organize mapping rules efficiently and eliminates the need for manual registration.

Example: Registering Mappings

We first create a class named MyRegistrations. Then we include the IRegister interface:

public class MyRegistrations : IRegister
{
    public void Register(TypeAdapterConfig config)
    {
        // Basic mapping configuration
        config.NewConfig<Source, Destination>();
    }
}

In this example we create a class named MyRegistrations that implements the IRegister interface. The Register method defines basic and custom mapping rules.

Now, let’s register these mappings using the Scan() method:

class Program
{
    static void Main(string[] args)
    {
        // Register mappings globally by scanning all assemblies
        TypeAdapterConfig.GlobalSettings.Scan();
    }
}

This line of code scans the current assembly for classes that implement IRegister and automatically registers their configurations.

Benefits of Using Mapster

After exploring Mapster, here are some key benefits I’ve identified:

• Simplicity: The setup is straightforward, reducing boilerplate code.
• Performance: Mapster is optimized for speed, making it faster than some other mapping libraries.
• Flexibility: The ability to define custom mapping rules and scan assemblies simplifies large projects.
• Lightweight: Minimal overhead compared to other mapping solutions.

Conclusion

Learning about Mapster has been an eye-opener. It’s refreshing to explore an alternative to AutoMapper that offers simplicity, performance, and flexibility. If you’re looking for an efficient object mapping library in C#, I highly recommend giving Mapster a try.

Have you tried Mapster in your projects? Share your experiences in the comments below!

References

• Scan Method