如何将 IFactory 绑定到具体实现？

Question

我需要一个工厂类做一些工作才能返回一个实例，所以我有一个这样的工厂方法：

public Foo Create(string bar, IEnumerable<SomeMetaData> metaData)
{
    var meta = new ObservableCollection<AnotherType>(
                        metaData.Select(e => new AnotherType { ... }).ToList());

    return Create(new ConstructorArgument("bar", bar),
                  new ConstructorArgument("metaData", meta));
}

具体工厂类派生自一个基础工厂，它省去了我的实际接线，以防你想知道IResolutionRoot 去了哪里：

public abstract class FactoryBase<T> where T : class
{
    private IResolutionRoot _resolutionRoot;
    protected FactoryBase(IResolutionRoot resolutionRoot)
    {
        _resolutionRoot = resolutionRoot;
    }

    protected T Create(params IParameter[] parameters)
    {
        return _resolutionRoot.Get<T>(parameters);
    }
}

（如果有人想评论这个抽象类，我在 CodeReview 上有一个问题：https://codereview.stackexchange.com/questions/25038/are-there-side-effects-to-having-a-generic-ninject-factory）

问题是在 NinjectModule 中，我不知道如何告诉 Ninject 使用特定的具体 FooFactory 类：

Bind<IFooFactory>().ToFactory(); // uses an abstract factory that doesn't do what I need
Bind<IFooFactory>().ToFactory<FooFactory>(); // doesn't build

我相信我需要的是这样的：

Bind<IFooFactory>().ToFactory<FooFactory>(Func<FooFactoryInstanceProvider>);

我需要做什么才能提供这个InstanceProvider？ 可能只是我对Func<T> 的误解，但我发现http://www.planetgeek.ch/2011/12/31/ninject-extensions-factory-introduction/ 对此过于模糊。

我想出了这个：

public class FooFactoryInstanceProvider : StandardInstanceProvider
{
    protected override Type GetType(MethodInfo methodInfo, object[] arguments)
    {
        return typeof(FooFactory);
    }
}

到目前为止这么好？下一步是什么？

Answer 1

如果您已经努力制作自己的 FooFactory 实现，为什么不直接以 非工厂 方式绑定到它：

代替：

Bind<IFooFactory>().ToFactory<FooFactory>();

用途：

Bind<IFooFactory>().To<FooFactory>();

如果您正在创建自己的工厂实现，那么究竟是什么促使您需要使用 Ninject Factory Extensions 中的 ToFactory() 方法？

编辑 1 - 将工厂扩展与自定义实例提供程序一起使用

这样，您可以将解析您想要的Foo 的逻辑放在自定义实例提供程序中。如果您可以获得与Foo 实现名称相匹配的逻辑，那么您就成功了。

public class BlueFiftyTwoFoo : Foo { }

Bind<IFooFactory>().ToFactory(() => new FooFactoryInstanceProvider());

自定义实例提供程序会根据您的 IFooFactory 的 `Create() 方法参数确定您想要的 Foo 实现的名称，如下所示：

public class FooFactoryInstanceProvider : StandardInstanceProvider
{
    protected override string GetName(MethodInfo methodInfo, object[] arguments)
    {
        // harvest the 1st factory method arg, cast as appropriate 
        string fooParamOne = (string)arguments[0];  // ex. "Blue"

        // harvest the 2nd factory method arg, cast as appropriate 
        string fooParamTwo = (string)arguments[1];  // ex. "FiftyTwo"

        // manipulate the params to come up with the **Name** of the 
        //  IFoo implementation you want
        var fooName = GetFooName(fooParamOne, fooParamTwo);

        return fooName; // ex. "BlueFiftyTwoFoo"
    }

    protected override ConstructorArgument[] GetConstructorArguments(MethodInfo methodInfo, object[] arguments)
    {
        // skip the number of params you're using above to come up with the implementation name
        return base.GetConstructorArguments(methodInfo, arguments).Skip(2).ToArray();
    }

    private string GetFooName(string fooParamOne, string fooParamTwo)
    {
        // do that voodoo that you do
        return fooParamOne + fooParamTwo + "Foo";
    }
}