用Ninject注入工厂字典-Java 学习之路

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

我有几个类，每个类都有一个关联的"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 类中有一个处理器工厂的静态字典，并在入口点手动注册绑定，但我想避免使用静态依赖项 . 或者在这种特殊情况下会更好吗？

UPDATE

我到达的另一种混合替代方案是这样的 . 我会在 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>();
  }
}

我知道我在这里使用了"evil"静态的东西，但是仍然可以很容易地利用DI并且以一种易读的方式利用模块的 Kernel 属性 .

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

任何想法都表示赞赏 .

2 回答

2
我正在用我的最终解决方案回答我的问题 .

我相信，在软件开发过程中，如果某些东西“不想被放在一起”，那么它就是一种气味的迹象，而且大多数时候我需要回到几个层次才能找到它 . 这里也有类似的东西 .

我意识到在这种情况下使用工厂模式不是一个好的设计，因为：
- 我认为实例化一个处理器对象永远不会那么昂贵，因为每个处理器对象都应该优化它们的资源，只有在调用 Process 时才使用它们 .
- 即使实例化很昂贵，使用我的原始模式，只要合适的对象在处理列表中，就会创建一个新实例 . （这可以由处理器处理，但仍然看起来不太好 . ）
- 无法根据优先级添加自定义处理器 . 假设 ProcessorA 进程 ClassA ， ClassB 扩展 ClassA 和 ProcessorB 进程 ClassB . 我无法阻止 ProcessorA 处理 ClassB 并允许其他（非自定义处理的） ClassA descendandts仍然同时使用 ProcessorA 处理 . 这是因为 Dictionary 结构 .
所以我决定简化实现并将一个 IProcessor 的可枚举数直接传递给主处理器，并在 IProcessor 中有一个 CanProcess(object obj) . 这样我就可以直接使用任何DI容器来注入所有绑定实现的列表 .
回复于 2024-05-02T20:27:58+08:00

如果你想要延迟初始化，那么工厂类而不是 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);
        }
    }
}

Update 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 .

当您尝试运行小提琴时出错，但您可以将代码抓取到.NET控制台项目中并运行 .

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

回复于 2024-05-02T20:27:58+08:00

用Ninject注入工厂字典

2 回答

相关问题