Create simple generic automapper in dotnet core 6

AutoMapper uses reflection to generate mapping code dynamically, which improves performance by avoiding the overhead of manual mapping code. This makes it an ideal choice for mapping large and complex object hierarchies. AutoMapper supports LINQ and enables developers to map LINQ queries to other objects or data types. This makes it easy to query data from a database and map it to domain objects or DTOs. AutoMapper provides various customization options that enable developers to configure the mapping process as per their requirements. It supports custom value resolvers, type converters, and other advanced features that allow developers to handle complex mapping scenarios.

AutoMapper simplifies the mapping process between two objects by eliminating the need to write manual mapping code. It enables developers to write mapping configuration between two object types and allows them to map the source object to the destination object automatically. With the use of AutoMapper, developers don't have to write repetitive code for mapping between objects. It saves a lot of time and allows them to focus on other important aspects of their application. With the use of AutoMapper, mapping code is centralized, which improves the maintainability of the codebase. Developers can easily locate and modify mapping configurations, reducing the likelihood of errors caused by scattered mapping logic.

Alternatively you can improve this code also as shared by @Sachin

public static class GenericAutoMapper
{
    private static readonly IMapper _mapper;

    static GenericAutoMapper()
    {
        var configuration = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap();
        });

        _mapper = configuration.CreateMapper();
    }

    public static TDestination Map(object source)
    {
        return _mapper.Map(source);
    }
}

I have modified as 

• Removed unnecessary new MapperConfiguration() call.
• Added readonly modifier to _mapper field.
• Removed generic type parameter from Map() method, since the types are already defined at the class level.

The error you are getting suggests that there is an issue with the mapping configuration. Specifically, the mapping configuration may not be correctly set up to map the source object of type object to the destination type QuestionEntity.

To resolve this error, you need to ensure that the mapping configuration is correctly set up to map the source and destination types. Instead of using object as the source and destination types in the mapping configuration, you should specify the actual types that you want to map. For example, if you want to map from a DTO object to a QuestionEntity object, you should create a mapping configuration that specifies these types:

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap();
});

_mapper = config.CreateMapper();

you can use the mapping service to map from the DTO to the QuestionEntity object:

var data = _mapperService.Map(inputfromDto);

This should correctly map the source object to the destination type and eliminate the error that you are seeing.

It should be something like this

public static class GenericAutoMapper
{
    private static Mapper _mapper=new Mapper(new MapperConfiguration(cfg =>
            {
                cfg.CreateMap(typeof(Source), typeof(Destination));
            }));

    

    public static TDestination Map(object source)
    {
        return _mapper.Map(source);
    }
}