Does Funq support ResolveAll?

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

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

但是，通常情况下，请求容器进行集合，而不是使用组合，这是更好的而不是。通过这种方式，您可以简单地注入一个IFoo作为依赖项，而不是强制该依赖项的使用者迭代列表。相反，您将在组合中嵌入循环IFoo实例列表的代码。这使您的代码保持干燥，并且当必须对项的迭代方式进行更改时，不会强迫您遍历分散在整个应用程序中的（可能的）数十个foreach (var foo in foos)语句。或者让我换一种说法：知道如何迭代所有IFoo s不是消费者的责任。

以下是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);
        }
    }
}

您可以将CompositeFoo注册为IFoo:，而不是注册IEnumerable<IFoo>

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

现在，您可以让容器将CompositeFoo注入接受IFoo参数的使用者中，这使他们不知道自己实际上正在处理IFoo元素的列表。

更新：

使用这种复合模式，您可以轻松地控制每个IFoo项目的使用寿命。这只是一个叫回集装箱的问题。有了Funq，它看起来是这样的：

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

通过这种方式，您可以将Foo1注册为singleton，将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);
        }
    }
}

现在，我们可以在构造函数中注入一些lambda，而不是将一些IFoo注入构造函数：

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

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

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

对于那些想要反模式的人，仅仅因为你可能不想实现工厂模式，这里是我基于上一个3.9.71的版本。

唯一的缺点是它增加了一点内存，并且您必须通过registerOneOfMany（）注册服务。您可能需要将包更改为带锁的列表（以便更快地读取），并切换到servicstack函数的默认值：ReuseScope.Default

public static class FunqExtensions
{
    private static readonly ConcurrentDictionary<Type,ConcurrentBag<string>> registrations = new ConcurrentDictionary<Type, ConcurrentBag<string>>();
    public static void RegisterOneOfMany<TBase, TImplementation>(this Container container, string name = null, ReuseScope scope  = ReuseScope.None) where TImplementation : TBase
    {
        if (name == null)
            name = Guid.NewGuid().ToString();
        var funq = Container.GenerateAutoWireFn<TImplementation>();
        container.Register<TBase>(name, (c) => funq(c))
          .ReusedWithin(scope);
        registrations.GetOrAdd(typeof(TBase), type => new ConcurrentBag<string>()).Add(name);
    }
    public static IEnumerable<T> ResolveAll<T>(this Container container)
    {
        ConcurrentBag<string> result;
        if (registrations.TryGetValue(typeof(T), out result))
        {
            var rator = result.GetEnumerator();
            while (rator.MoveNext())
            {
                yield return container.ResolveNamed<T>(rator.Current);
            }
        }
    }  
}