Fixed Issue: Unable to resolve service for type 'AutoMapper.IMapper' while attempting to activate

I am building an API for my app and I'm encountering issues when attempting to use Automapper. Specifically, I'm having trouble resolving a mapper object, and I'm receiving this error message" "Unable to resolve service for type 'AutoMapper.IMapper'" in our ASP.NET Core application. This error typically occurs when the dependency injection container is unable to find a service registration for the IMapper interface provided by AutoMapper.

InvalidOperationException: Unable to resolve service for type 'AutoMapper.IMapper' while attempting to activate 'PetsLover.Controllers.TravlerController'.

Here is my complete code

namespace PetsLover.Models
{
    [Table("Species")]
    public class Species
    {
        public int Id { get; set; }
        [Required]
        [StringLength(255)]
        public string Name { get; set; }

        public Harbor Harbor { get; set; }
        public int HarborId { get; set; }
    }
}

namespace PetsLover.Models
{
    public class Harbor
    {
        public int Id { get; set; }
        [Required]
        [StringLength(255)]
        public string Name { get; set; }
        public ICollection<Species> Species { get; set; }

        public Harbor()
        {
            Species = new Collection<Species>();
        }
    }
}

namespace PetsLover.Controllers.Resources
{
    public class HarborResource
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public ICollection<SpeciesResource> Species { get; set; }

        public HarborResource()
        {
            Species = new Collection<SpeciesResource>();
        }
    }
}

namespace PetsLover.Controllers.Resources
{
    public class SpeciesResource
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

namespace PetsLover.Controllers
{
    public class HarborsController : Controller
    {
        private readonly FishDbContext _context;
        private readonly IMapper _mapper;
        public HarborsController(FishDbContext context, IMapper mapper)
        {
            _mapper = mapper;
            _context = context;
        }


        [HttpGet("/api/harbors")]
        public async Task<IEnumerable<HarborResource>> GetHarbors()
        {
            var harbors = await _context.Harbors.Include(s => s.Species).ToListAsync();

            return _mapper.Map<List<Harbor>, List<HarborResource>>(harbors);
        }

    }
}

To solve this issue, we need to ensure that AutoMapper is properly configured and registered with the dependency injection container in our application's startup configuration.

Here's an example of how we can register AutoMapper in the ConfigureServices method of our application's Startup class:


public void ConfigureServices(IServiceCollection services)
{
    // Add AutoMapper configuration here
    services.AddAutoMapper(typeof(Startup));
    
    // Other service registrations
}

In above example, we use the AddAutoMapper method provided by AutoMapper.Extensions.Microsoft.DependencyInjection package to register AutoMapper with the dependency injection container. We specify typeof(Startup) to scan the application's assemblies for AutoMapper profiles and register them accordingly.

Once AutoMapper is properly registered, the dependency injection container will be able to resolve services for the IMapper interface, and the error should be resolved.

If are using .Net core version >=6 then to register AutoMapper in an ASP.NET Core application targeting .NET 6, you do it in the ConfigureServices method within the Program.cs file.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using AutoMapper;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// Register AutoMapper
builder.Services.AddAutoMapper(typeof(Program));

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
    
app.Run();

Let me tell you that Automapper library used in .NET applications to simplify the mapping of objects from one type to another. It automates the process of manually mapping properties between different classes by convention-based mapping.

To use Automapper in ASP.NET Core, follow these steps:

Install Automapper NuGet package:
```
dotnet add package AutoMapper
```
Create classes that inherit from Profile provided by AutoMapper. In these profiles, define mappings between source and destination types.
Configure AutoMapper: Register mapping profiles in the application's startup configuration.
Inject IMapper into services or controllers and use it to perform object mapping.

How to use AutoMapper in ASP.NET Core:

using AutoMapper;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Hosting;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Register AutoMapper
        services.AddAutoMapper(typeof(Startup));

        // Other service registrations
        services.AddControllersWithViews();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Configure other middleware

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<ProductEntity, ProductViewModel>()
            .ForMember(dest => dest.DisplayPrice, opt => opt.MapFrom(src => src.Price.ToString("C")));
        // Additional mappings can be added here if needed
    }
}

public class ProductEntity
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
   
}

public class ProductViewModel
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public string DisplayPrice { get; set; } // Formatted price for display
   
}

public class ProductController : Controller
{
    private readonly IMapper _mapper;

    public ProductController(IMapper mapper)
    {
        _mapper = mapper;
    }

    public IActionResult ProductDetail()
    {
        ProductEntity product = GetProductFromDatabase(); // Retrieve product data from the database
        ProductViewModel productViewModel = _mapper.Map<ProductViewModel>(product);

        // Use mapped product view model object
        return View(productViewModel);
    }

    private ProductEntity GetProductFromDatabase()
    {
        // this method would retrieve product data from the database
        return new ProductEntity
        {
            ProductId = 1,
            Name = "Product",
            Price = 99.99m
            
        };
    }
}

In the MappingProfile class we defines the mapping configuration between ProductEntity and ProductViewModel.ProductEntity and ProductViewModel represent the data entity and view model for products, respectively.

In the ProdcuController class we are going to show you how to use AutoMapper in an ASP.NET Core controller to map ProductEntity to ProductViewModel. The ProductDetail action retrieves product data, maps it to the view model, and returns a view with the mapped data for display.

In this mapping configuration, we're specifying that the DisplayPrice property in ProductViewModel should be populated by formatting the Price property from ProductEntity as a currency string.Other properties can be mapped similarly, or AutoMapper can handle mappings automatically for properties with matching names and types, when ProductEntity objects are mapped to ProductViewModel, AutoMapper will automatically format the Price property into a user-friendly display format specified in the mapping configuration, this allows us to keep the data access and UI concerns separate and maintain clean, readable code.

We encountered the error message "This error occurs may be you haven't registered a mapper which should be resolved on the IMapper interface on the service collection." in our ASP.NET Core application. This error suggests that AutoMapper has not been properly configured and registered with the dependency injection container, leading to the inability to resolve services for the IMapper interface.

To resolve this issue, we can follow the suggested solution by adding the mapping profile to a new mapper configuration and then creating a mapper from that configuration. Finally, we bind the mapper to the service collection.

Here's an example of how we can implement this solution:


// Create a new mapper configuration and add the mapping profile
var config = new AutoMapper.MapperConfiguration(cfg =>
{
    cfg.AddProfile(new OrderDataMappingProfile());
});

// Create a mapper from the configuration
var mapper = config.CreateMapper();

// Bind the mapper to the service collection
_serviceCollection.AddSingleton(mapper);

By following this approach, we ensure that AutoMapper is properly configured and registered with the dependency injection container. This allows the dependency injection container to resolve services for the IMapper interface, resolving the error and enabling AutoMapper to be used throughout the application for mapping objects.

Fixed Issue: Unable to resolve service for type 'AutoMapper.IMapper' while attempting to activate

Read Similar Articles