从 Autofac 容器解析通用接口的 IEnumerable

Question

我不确定这是否可行，我看到其他一些帖子问过类似的问题，但 none 有一个令人满意的答案。

我想做的是从 Autofac 解析具有不同泛型类型的接口集合。所以 class 的构造函数看起来像这样：

public class SomeClass<T> where T : class
{
    private readonly IEnumerable<ITestInterface<T>> _testInterfaces;

    public SomeClass(IEnumerable<ITestInterface<T>> testInterfaces)
    {
        _testInterfaces = testInterfaces;
    }
}

理想情况下，我希望能够像这样单独注册每个实例：

builder
    .RegisterType<ImplementationA>()
    .As<ITestInterface<A>>();

builder
    .RegisterType<ImplementationB>()
    .As<ITestInterface<B>>();

我已经尝试了 RegisterGeneric 等的各种组合，但 Enumerable 一直都是空的。

如有任何帮助，我们将不胜感激。

Answer 1

RegisterGeneric 应该可以正常工作：

builder.RegisterType<TestImplementationA>()
        .As<ITestInterface<A>>();
builder.RegisterType<TestImplementationB>()
        .As<ITestInterface<B>>();
builder.RegisterGeneric(typeof(SomeClass<>))
       .As(typeof(ISomeClass<>));

或

builder.RegisterType<TestImplementationA>()
        .As<ITestInterface<A>>();
builder.RegisterType<TestImplementationB>()
        .As<ITestInterface<B>>();
builder.RegisterGeneric(typeof(SomeClass<>))
       .AsSelf();

您将在下面找到一个工作示例：

public interface ISomeClass<T> where T : class
{
    Int32 Count { get; }
}
public class SomeClass<T> : ISomeClass<T> where T : class
{
    private readonly IEnumerable<ITestInterface<T>> _testInterfaces;

    public SomeClass(IEnumerable<ITestInterface<T>> testInterfaces)
    {
        _testInterfaces = testInterfaces;
    }

    public Int32 Count
    {
        get
        {
            return this._testInterfaces.Count();
        }
    }
}

public interface ITestInterface {}
public interface ITestInterface<T> : ITestInterface { }
public class A { }
public class B { }
public class TestImplementationA : ITestInterface<A> { }
public class TestImplementationB : ITestInterface<B> { }

class Program
{
    static void Main(string[] args)
    {
        ContainerBuilder builder = new ContainerBuilder();
        builder.RegisterType<TestImplementationA>()
               .As<ITestInterface<A>>()
               .As<ITestInterface>();

        builder.RegisterType<TestImplementationB>()
               .As<ITestInterface<B>>()
               .As<ITestInterface>();

        builder.RegisterGeneric(typeof(SomeClass<>))
               .As(typeof(ISomeClass<>));

        IContainer container = builder.Build();

        var x = container.Resolve<ISomeClass<A>>();

        Console.WriteLine(x.Count);

        var z = container.Resolve<IEnumerable<ITestInterface>>();
    }
}

Answer 2

我在尝试继承和通用约束后解决了这个问题。我最终得到的解决方案如下所示：

基础类/接口：

public abstract class BaseClass
{
    public abstract string IAM { get; }
}

public interface ITestInterface<out T> where T : BaseClass
{
    T GetSomething();
}

已实施类：

public class A : BaseClass
{
    public override string IAM => "I AM TYPE A";
}

public class AInterface : ITestInterface<A>
{
    public A GetSomething()
    {
        return new A();
    }
}

public class B : BaseClass
{
    public override string IAM => "I AM TYPE B";
}

public class BInterface : ITestInterface<B>
{
    public B GetSomething()
    {
        return new B();
    }
}

Class我们要解决：

public interface ISomeClass
{
    void DoSomething();
}

public class SomeClass<T> : ISomeClass where T : BaseClass
{
    private readonly IEnumerable<ITestInterface<T>> _testInterfaces;

    public SomeClass(IEnumerable<ITestInterface<T>> testInterfaces)
    {
        _testInterfaces = testInterfaces;
    }

    public void DoSomething()
    {
        foreach (var t in _testInterfaces)
        {
            var something = t.GetSomething();

            Console.WriteLine(something.IAM);
        }
    }
}

最后，Autofac 配置：

var builder = new ContainerBuilder();

builder
    .RegisterType<SomeClass<BaseClass>>()
    .AsSelf();

builder
    .RegisterType<AInterface>()
    .As<ITestInterface<BaseClass>>();

builder
    .RegisterType<BInterface>()
    .As<ITestInterface<BaseClass>>();

builder
    .RegisterType<SomeClass<BaseClass>>()
    .As<ISomeClass>();

var container = builder.Build();

var x = container.Resolve<ISomeClass>();

x.DoSomething();

输出：

I AM TYPE A

I AM TYPE B

希望这对以后的人有所帮助。

从 Autofac 容器解析通用接口的 IEnumerable

Resolving IEnumerable of generic interfaces from Autofac container

c#

dependency-injection

autofac