c# - Funq 支持 ResolveAll 吗？

Question

Funq IoC 容器是否支持解析一个类型的所有注册？类似于以下任何一个:

IEnumerable<IFoo> foos = container.Resolve<IEnumerable<IFoo>>();
IEnumerable<IFoo> foos = container.ResolveAll<IFoo>();

Answer 1

Funq 没有 ResolveAll方法，但你可以简单地注册一个 IEnumerable<IFoo>并用 Resolve<IEnumerable<IFoo>>() 解决它正如您在问题中所展示的那样。

但一般来说，最好不要请求容器进行收集，而是使用composites。反而。这样你就可以简单地注入(inject)一个 IFoo作为依赖项，而不是强制该依赖项的消费者迭代列表。相反，您嵌入了循环 IFoo 列表的代码复合体中的实例。这将保留您的代码 DRY并且不会强制你经历(可能的)几十个foreach (var foo in foos)当必须对项的迭代方式进行更改时，分散在整个应用程序中的语句。或者让我换一种说法:知道如何迭代所有 IFoo 不是消费者的责任。

这是一个 IFoo 的例子复合:

// A composite is something that implements an interface
// (in this case IFoo) and wraps a list of items of that
// same interface.
public class FooComposite : IFoo
{
    private readonly IEnumerable<IFoo> foos;

    public FooComposite(params IFoo[] foos)
    {
        this.foos = foos;
    }

    void IFoo.FooThatThing(IBar bar)
    {
        foreach (var foo in this.foos)
        {
            foo.FooThatThing(bar);
        }
    }
}

而不是注册 IEnumerable<IFoo> , 你可以注册一个 CompositeFoo作为IFoo :

container.Register<IFoo>(c => new CompositeFoo(
    new Foo1(), new Foo2(), new Foo3()));

现在您可以让容器注入(inject) CompositeFoo在接受 IFoo 的消费者中争论，这让他们不知道他们实际上正在处理 IFoo 的列表元素。

更新:

使用这种复合模式，您可以轻松控制每个 IFoo 的生命周期元素。这只是回调容器的问题。使用 Funq，它看起来像这样:

container.Register<IFoo>(c => new CompositeFoo(
    c.Resolve<Foo1>(),
    c.Resolve<Foo2>(),
    c.Resolve<Foo3>()));

这样你就可以注册Foo1作为单例和 Foo2例如 transient 。当 CompositeFoo然而，被重复使用，Foo2不会真的是短暂的，但这只是改变 CompositeFoo 的问题及其注册来解决这个问题。例如，您可以更改 CompositeFoo到以下内容:

public class FooComposite : IFoo
{
    private readonly Func<IFoo>[] fooFactories;

    public FooComposite(params Func<IFoo>[] fooFactories)
    {
        this.fooFactories = fooFactories;
    }

    void IFoo.FooThatThing(IBar bar)
    {
        foreach (var fooFactory in this.fooFactories)
        {
            var foo = fooFactory();

            foo.FooThatThing(bar);
        }
    }
}

现在不用注入(inject)一些 IFoo s 到构造函数中，我们可以在其中注入(inject)一些 lambda:

container.Register<IFoo>(c => new CompositeFoo(
    () => c.Resolve<Foo1>(),
    () => c.Resolve<Foo2>(),
    () => c.Resolve<Foo3>()));

这将确保每次CompositeFoo的 FooThatThing被调用，容器被查询新的 IFoo实例。这允许 FooThatThing被同一消费者多次调用，甚至允许 CompositeFoo被注册为单例。

这个建议一般适用于所有容器和依赖注入(inject)，并不特定于 Funq 的使用。