AutoMapper map to derived class based on condition

3 min read 07-10-2024

AutoMapper map to derived class based on condition

In the world of C# development, one often encounters scenarios where you need to convert an object of one class type into another. This is especially common when dealing with inheritance and polymorphism, where you might want to map to a derived class based on specific conditions. AutoMapper, a popular library for object mapping in .NET, offers a way to facilitate this process. In this article, we'll explore how to use AutoMapper to map to derived classes conditionally, making your code cleaner and more maintainable.

Understanding the Problem

When working with object-oriented programming, it's common to have a base class and multiple derived classes. AutoMapper can simplify the mapping process between these types. The challenge arises when you need to decide which derived class to instantiate based on certain conditions.

Scenario Illustration

Let's consider the following scenario. We have a base class Animal and two derived classes: Dog and Cat. Depending on a string input ("dog" or "cat"), we want to map to the corresponding derived class.

Here’s the original code you might encounter:

public class Animal
{
    public string Name { get; set; }
}

public class Dog : Animal
{
    public string BarkSound { get; set; }
}

public class Cat : Animal
{
    public string MeowSound { get; set; }
}

Using AutoMapper for Conditional Mapping

To perform conditional mapping, we can set up AutoMapper profiles that define how each type should be mapped. We will use a custom value resolver to determine which derived class to create based on the input string.

Step-by-Step Implementation

Install AutoMapper: Ensure you have AutoMapper installed in your .NET project. You can add it via NuGet:
```
Install-Package AutoMapper
```
Define Your Profiles: Create a mapping profile for the Animal classes.

public class AnimalProfile : Profile
{
    public AnimalProfile()
    {
        CreateMap<AnimalInput, Animal>()
            .ConvertUsing<AnimalConverter>();
    }
}

Create a Custom Value Resolver: Define a custom converter that uses the condition to return the appropriate derived class.

public class AnimalConverter : ITypeConverter<AnimalInput, Animal>
{
    public Animal Convert(AnimalInput source, Animal destination, ResolutionContext context)
    {
        if (source.Type == "dog")
        {
            return new Dog
            {
                Name = source.Name,
                BarkSound = "Woof!"
            };
        }
        else if (source.Type == "cat")
        {
            return new Cat
            {
                Name = source.Name,
                MeowSound = "Meow!"
            };
        }
        throw new ArgumentException("Invalid animal type");
    }
}

Create the Input Class: Define an input class that represents the data coming in.

public class AnimalInput
{
    public string Name { get; set; }
    public string Type { get; set; }
}

Performing the Mapping: Use AutoMapper to map the input to the derived class.

var config = new MapperConfiguration(cfg => cfg.AddProfile<AnimalProfile>());
var mapper = config.CreateMapper();

var input = new AnimalInput { Name = "Buddy", Type = "dog" };
Animal animal = mapper.Map<Animal>(input);

Insights and Analysis

Using AutoMapper with a custom converter allows you to keep your code clean while still implementing complex logic for determining the type of object to create. This pattern is particularly useful in scenarios involving APIs, where the input format may dictate the response type, facilitating flexible designs.

By leveraging conditional logic in your mapping profiles, you ensure that your application can easily accommodate changes, such as adding new derived classes or altering the mapping logic without disrupting the overall architecture.

Conclusion

Mapping to derived classes based on conditions can be a common requirement in software development. With AutoMapper, the task becomes straightforward. By defining a custom converter, you can ensure that your application remains flexible and maintainable.

For more information and advanced AutoMapper features, consider checking the official AutoMapper documentation for further guidance and examples.

Additional Resources

This article provides you with a robust starting point for implementing conditional mapping with AutoMapper, allowing you to enhance your application architecture efficiently. Happy coding!