用Ninject注入工厂字典

本文关键字：字典 工厂 注入 Ninject | 更新日期: 2023-09-27 18:29:55

我知道如何通过构造函数注入将一个或一组依赖接口实例注入到类中。然而，在我目前的情况下，我有一个不同的任务。

我有几个类，每个类都有一个相关的"Processor"类。这些处理器实现了相同的IProcessor接口，一个通用的Processor类将处理一组对象，为每个对象使用适当的处理器。为一个类型创建一个处理器可能很昂贵，所以我使用工厂，只在需要的时候实例化处理器。

代码看起来像这样。

public interface IProcessor {
  void Process(object item);
}
public class Processor {
  private readonly Dictionary<Type, Func<IProcessor>> _processors;
  public Processor(IDictionary<Type, Func<IProcessor>> processors) {
    _processors = processors;
  }
  public void Process(IEnumerable items) {
    foreach (var item in items) {
      var processorFactory = _processors.GetValueOrDefault(item.GetType());
      if (processorFactory == null) continue; // for simplicity
      var processor = processorFactory();
      processor.Process(item);
    }
  }
}

如何在Ninject中注册此绑定？或者有没有更"DI友好"的替代模式？

我想在应用程序入口点级别配置这些"处理器绑定"。

另一种选择是在Processor类中有一个处理器工厂的静态字典，并在入口点手动注册绑定，但我希望避免使用静态依赖关系。还是在这种特殊情况下会更好？

更新

我想到的另一种混合动力的替代方案是这样的。我会在Processor类中有一个静态的Factories字典。在那里，我可以将基本的默认实现作为门面。

然后在我的Ninject模块中，我可以写这样的东西。

public class MyModule : NinjectModule
{
  public override void Load()
  {
    // ... my "standard" bindings
    Processor.Factories[typeof(MyItem1)] = () => Kernel.Get<MyItem1Processor>();
    Processor.Factories[typeof(MyItem2)] = () => Kernel.Get<MyItem2Processor>();
  }
}

我知道我在这里使用了"邪恶"的静态内容，但仍然可以很容易地使用DI，并以可读的方式使用模块的Kernel属性。

在Load方法中使用模块的Kernel属性是否安全？我的意思是，例如，一个模块可以加载到更多的内核中吗？

任何想法都值得赞赏。

用Ninject注入工厂字典

我用我的最终解决方案来回答我的问题。

我相信，在软件开发过程中，如果某个东西"不想放在一起"，那么这表明有一些气味，大多数时候我需要回到几个级别才能找到它。这里也有类似的情况。

我意识到在这种情况下使用工厂模式不是一个好的设计，因为：

  1. 我认为实例化一个处理器对象永远不应该如此昂贵，因为每个处理器对象都应该优化它们的资源，以便只有在调用Process时才能使用它们
  2. 即使实例化很昂贵，使用我的原始模式，只要处理列表中有合适的对象，就会创建一个新的实例。（这可以由处理器处理，但看起来仍然不太好。）
  3. 无法添加与优先级相关的自定义处理器。假设ProcessorA处理ClassA，ClassB扩展ClassA，ProcessorB处理ClassB。我没有办法阻止ProcessorA处理ClassB，并允许其他（非自定义处理的）ClassA descendant同时仍用ProcessorA处理。这是因为Dictionary结构

因此，我决定简化实现，将可枚举的IProcessor s直接传递给主处理器，并在IProcessor中有一个CanProcess(object obj)。通过这种方式，我可以直接使用任何DI容器来注入所有绑定实现的列表。

如果您想要延迟初始化，不如使用工厂类而不是Func？

有一个基本的工厂类别：

public abstract class ProcessorFactory
{
    public abstract Type ItemType { get; }
    public abstract IProcessor GetProcessor();
}

为每个项类型创建一个类的具体实例，并将这些实例的集合注入到构造函数中。然后根据这个构建你的字典：

public class Processor
{
    private readonly Dictionary<Type, ProcessorFactory> _processors;
    public Processor(IEnumerable<ProcessorFactory> processors)
    {
        _processors = processors.ToDictionary<ProcessorFactory, Type>(p => p.ItemType);
    }
    public void Process(IEnumerable items)
    {
        foreach (var item in items)
        {
            var processorFactory = _processors.GetValueOrDefault(item.GetType());
            if (processorFactory == null) continue; // for simplicity
            var processor = processorFactory.GetProcessor();
            processor.Process(item);
        }
    }
}

更新1

以下是完整工厂实现的示例代码：

首先我把工厂改成了一个接口：

public interface IProcessorFactory
{
    Type ItemType { get; }
    IProcessor GetProcessor();
}

然后我为工厂创建了一个抽象的通用基类：

public abstract class ProcessorFactoryBase<TItem> : IProcessorFactory
{
    private Lazy<IProcessor> _factory;
    public ProcessorFactoryBase(Func<IProcessor> factory)
    {
        _factory = new Lazy<IProcessor>(factory);
    }
    public Type ItemType
    {
        get { return typeof(TItem); }
    }
    public IProcessor GetProcessor()
    {
        return _factory.Value;
    }
}

要创建工厂，只需从具有适当项目类型的基础继承并实现构造函数：

public class ProcessorFactoryA : ProcessorFactoryBase<ItemA>
{
    public ProcessorFactoryA(Func<IProcessor> factory) : base(factory) { }
}

请注意，工厂类绑定到项目类型；处理器类型是通过绑定注入的：

public class Bindings : NinjectModule
{
    public override void Load()
    {
        Bind<IProcessorFactory>().ToMethod(context => new ProcessorFactoryA(() => context.Kernel.Get<ProcessorX>()));
        Bind<IProcessorFactory>().ToMethod(context => new ProcessorFactoryB(() => context.Kernel.Get<ProcessorY>()));
        Bind<IProcessorFactory>().ToMethod(context => new ProcessorFactoryC(() => context.Kernel.Get<ProcessorZ>()));
        // Note that item type D is handled by processor X
        Bind<IProcessorFactory>().ToMethod(context => new ProcessorFactoryD(() => context.Kernel.Get<ProcessorX>()));
    }
}

我用.NET篡改了完整的工作代码：http://dotnetfiddle.net/aD9E2y.

当您尝试运行fiddle时，它会出错，但您可以将代码抓取到.NET控制台项目中，然后它就会运行。

有些人不喜欢它们，但我使用T4模板来做一些事情，比如使用反射自动生成处理器工厂类。但是，绑定仍然必须手动创建，因为无法推断项类型和处理器之间的关联。

相关文章：