向Autofac注册通用接口和类

Question

My current Autofac config is working to resolve my ApiControllers in a WebApi.

Where I'm struggling is, I'm attempting to create a 'BaseApiController' with generic constructor parameters, but getting exception:

No constructors on type 'Service`1[WorldRegion]' can be found with the constructor finder 'Autofac.Core.Activators.Reflection.DefaultConstructorFinder'.

Here is the code structure:

public interface IEntityKey { }
public class WorldRegion : IEntityKey { }
public interface IRepository<T> where T : IEntityKey { }
public interface IService<T> where T : IEntityKey { }
public abstract class Service<T> : IService<T> where T : IEntityKey { }
public interface IWorldRegionService : IService<WorldRegion> { }
public class WorldRegionService : Service<WorldRegion>, IWorldRegionService
{
    private readonly IRepository<WorldRegion> _repository;
}

WORKING API Controller:

public class WorldRegionsController : BaseApiController
{
    private readonly IWorldRegionService _worldRegionService;
    private readonly ICultureService _cultureService;

    public WorldRegionsController(IWorldRegionService worldRegionService, ICultureService cultureService)
    {
        _worldRegionService = worldRegionService;
        _cultureService = cultureService;
    }
}

WORKING Autofac config:

public static void Register(HttpConfiguration config, IAppBuilder app)
{
    var builder = new ContainerBuilder();
    builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

    RegisterTypes(builder);

    var container = builder.Build();
    config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

    app.UseAutofacMiddleware(container);
    app.UseAutofacWebApi(config);
}

public static void RegisterTypes(ContainerBuilder builder)
{
    // Context
    builder.RegisterType<DataContext>().As<IDataContext>().InstancePerRequest();
    // UOW
    builder.RegisterType<UnitOfWork>().As<IUnitOfWork>().InstancePerRequest();
    // Repositories
    builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)).InstancePerRequest();
    // Services
    builder.RegisterType<CultureService>().As<ICultureService>().InstancePerRequest();
    builder.RegisterType<WorldRegionService>().As<IWorldRegionService>().InstancePerRequest();
}

Here is the generic ATTEMPT:

// BaseApiController
public abstract class BaseApiController<T> : ApiController where T : IEntityKey

{
    protected readonly IService<T> _service;
    protected readonly ICultureService _cultureService;
    public BaseApiController(IService<T> service, ICultureService cultureService)
    {
        _service = service;
        _cultureService = cultureService;
    }
}

// ApiController
public class WorldRegionsController : BaseApiController<WorldRegion>
{
    public WorldRegionsController(
        IService<WorldRegion> service, ICultureService cultureService)
            : base(service, cultureService) {}
}

// Added to Autofac config
builder.RegisterGeneric(typeof(Service<>)).As(typeof(IService<>)).InstancePerRequest();
// Removed
builder.RegisterType<WorldRegionService>().As<IWorldRegionService>().InstancePerRequest();

With this change, I'm getting the exception message noted above (in yellow). I think I'm missing something in the Autofac config, just not sure what. Maybe include/register/add 'WorldRegion' somehow.

How should I register my types ?

Answer 1

Your controller expect a IService<WorldRegion> . Autofac find the following registration for this service :

builder.RegisterGeneric(typeof(Service<>)).As(typeof(IService<>)).InstancePerRequest();

So it tries to create a Service<WorldRegion> which is not possible because Service<T> is an abstract class.

Don't forget that a IWorldRegionService is a IService<WorldRegion> but a IService<WorldRegion> is not a IWorldRegionService .

You don't want to register a generic service but want to register all children as a IService<T> , you can do this by using the RegisterAssemblyTypes method with the AsClosedTypedOf

builder.RegisterAssemblyTypes(this.GetAssemblies())
       .AsClosedTypesOf(typeof(IService<>));

Read Autofac documentation - Assembly scanning for more information and how to properly implement the GetAssemblies method in IIS.

Answer 2

At first, I tried removing the abstract from Service<T> , that didn't work, same error. Then I read the Autofac docs and searched around, and I found something similar to Cyril's answer that works:

builder.RegisterAssemblyTypes(typeof(Service<>).Assembly)
       .Where(t => t.Name.EndsWith("Service")).AsImplementedInterfaces();

I tried Cyril's implementation of builder.RegisterAssemblyTypes() but this.GetAssemblies() wasn't available. I had to use the full path and this also works:

builder.RegisterAssemblyTypes(AppDomain.CurrentDomain.GetAssemblies())
       .AsClosedTypesOf(typeof(IService<>));

To note, using either builder.RegisterTypes() , the Service<T> can still be abstract. And just to test, I changed WorldRegionService to abstract, and that DID NOT work.

// THIS DOES NOT WORK..!!!! Must remove 'abstract' from this class.
public abstract class WorldRegionService {}

So both above builder.RegisterTypes() work.