时间戳

首页 > 解决方案 > Autofac 注入通用接口的 IEnumerable

c# - Autofac 注入通用接口的 IEnumerable

问题描述

所以，我认识到 StackOverflow 上充斥着这个问题，但经常没有人解释他们为什么要这样做。我希望通过这样做，一个更好的答案会浮到顶部。

这家伙做了一些接近我想要的事情：Resolving IEnumerable of generic interfaces from Autofac 容器但不完全。

我承认IGenericInterface<ObjectA>不等于IGenericInterface<ObjectB>.

话虽这么说，我很想将每一个注入IService<T>到一个构造函数中，以便我可以构建一个查找。老实说，我想构建一个非常类似于DbContext.Set<T>

我的问题中有几个关键人物。

public interface IService<TMessage> where TMessage: IContractDTO
{
    IQueryable<TMessage> BuildProjection();
}

目前我一次注射这些

public class SomeController : BaseODataController<SomeEntityDTO>
{
    public SomeController(IControllerServiceContext context, IService<SomeEntityDTO> service)
      : base(context, service)
    {

    }

    //DO STUFF
}

IControllerServiceContext是一个复合接口，包含DbContext,AppSettings和其他一些我想要在每个控制器中使用的常见好东西。

在大多数情况下，这已经足够了。但是偶尔为了支持EntityAIService<SomeEntityB>的逻辑，我可能需要对 B 进行快速查找。我宁愿使用BuildProjections()例如，以这种方式使用 8 或 9 参数的构造函数

所以我开始思考如果我能够添加一个IServiceLookup，IControllerServiceContext那么我将拥有我需要的一切。

我开始了这条路：

public class ServiceLookup<TContract>: IServiceLookup where TContract: BaseClass, IContractDTO
{

    public ServiceLookup(IEnumerable<IService<TContract>> services)
    {
        //Build _Services
    }

    private readonly IDictionary<Type, object> _services;

    public IService<TMessage> Service<TMessage>() where TMessage : class, IContractDTO
    {
        return (IService<TMessage>)(GetService(typeof(TMessage)));
    }

    private object GetService(Type type)
    {
        _services.TryGetValue(type, out var service);

        return service;
    }
}

由于明显的原因，这不能用当前的构造函数来完成。

但是有没有办法得到我想要的字典，或者IIndex我IEnumerable可以建立那个字典，<type, object>其中对象是我的各种IService<T>？

服务查找是基于读取DbContext代码和简化逻辑而构建的DbContext.Set，这也是由IDictionary<Type, object>.

如果通过某种解析器参数我可以获得所有IService<T>s，提取T类型并将它们添加到该列表中，我就可以参加比赛了。

编辑：我认识到我可以将构建每个服务所需的参数注入ServiceLookup并手动构建我的列表，这甚至可能是更好的答案......但如果我能做到这一点，它会更加强大，而且我从根本上很好奇这是否可能

Edit2：我希望在实现中能够做的事情如下所示：

public SomeController(IControllerServiceContext context, IServiceLookup lookup)
      : base(context, service)
{
    public SomeMethod() {
       var x = lookup.Service<EntityOneDTO>().BuildProjections().FirstOrDefault();
       var y = lookup.Service<EntityTwoDTO>().BuildProjections().FirstOrDefault();

    //Do Logic that requires both EntityOne and EntityTwo  
    }
}

标签： c#dependency-injectionautofac

解决方案

假设您有以下类型：

public class MessageA { }
public class MessageB { }

public interface IService<TMessage> { }
public class ServiceA : IService<MessageA> { }
public class ServiceB : IService<MessageB> { }

你有一个控制器，你想得到一个IService<MessageA>基于你想要的任何东西。

第一个解决方案是注入IService您可能需要的所有内容：

public class Controller
{
    public Controller(IService<MessageA> serviceA, IService<MessageB> serviceB)
    {
        this._serviceA = serviceA;
        this._serviceB = serviceB; 
    }

    private readonly IService<MessageA> _serviceA;
    private readonly IService<MessageB> _serviceB;

    public void Do()
    {
        IService<MessageA> serviceA = this._serviceA;
    }
}

如果您的消息类型很少，但如果您的消息类型过多，则无效。

因为IService<T>是通用的，Do没有简单的方法可以混合这两个世界。第一个解决方案是引入非通用接口

public interface IService { }
public interface IService<TMessage> : IService { }

并像这样注册这些类型：

builder.RegisterType<ServiceA>().As<IService<MessageA>>().As<IService>();
builder.RegisterType<ServiceB>().As<IService<MessageB>>().As<IService>();

然后你可以拥有一个IEnumerable<IService>. 类似的东西：

public interface IServiceLookup
{
    IService<TMessage> Get<TMessage>();
}
public class ServiceLookup : IServiceLookup
{
    public ServiceLookup(IEnumerable<IService> services)
    {
        this._services = services
            .ToDictionary(s => s.GetType()
                .GetInterfaces()
                .First(i => i.IsGenericType 
                            && i.GetGenericTypeDefinition() == typeof(IService<>))
                .GetGenericArguments()[0], 
                          s => s);
    }
    private readonly Dictionary<Type, IService> _services;

    public IService<TMessage> Get<TMessage>()
    {
        // you should check for type missing, etc. 
        return (IService<TMessage>)this._services[typeof(TMessage)];
    }
}

然后注入IServiceLookup你的控制器。

此解决方案的缺点是它会创建所有 IService 的实例，以避免您可以注入IEnumerable<Func<IService>>

另一种解决方案是IComponentContext注入ServiceLookup. ComponentContext是一种Autofac类型，您可以从中解析服务。

public class ServiceLookup : IServiceLookup
{
    public ServiceLookup(IComponentContext context)
    {
        this._context = context;
    }
    private readonly IComponentContext _context;

    public IService<TMessage> Get<TMessage>()
    {
        return this._context.Resolve<IService<TMessage>>();
    }
}

推荐阅读