使用 Unity 的策略模式和依赖注入 [英] Strategy Pattern and Dependency Injection using Unity

问题描述

我终于开始使用依赖注入(早该)了；我开始使用 Unity 并遇到了策略模式的问题.我可以使用容器返回给我基于名称的策略的特定实现，但我没有看到我应该如何在上下文中获得正确的策略.
让我们用一个简单的例子来说明:上下文是一辆汽车，它有一个 IEngine(策略)，有 2 个实现，FastEngine 和 SlowEngine.代码将沿着以下几行:

I am finally getting my feet wet with Dependency Injection (long overdue); I got started playing with Unity and run into an issue with the strategy pattern. I can use the container to return to me specific implementations of a strategy based on a name, but what I don't see is how I am supposed to get the right strategy in the context.
Let's illustrate on a simple example: the context is a car, which has an IEngine (the strategy), with 2 implementations, FastEngine and SlowEngine. The code would look along these lines:

public interface IEngine
{
    double MaxSpeed
    {
        get;
    }
}

internal class FastEngine:IEngine
{
    public double MaxSpeed
    {
        get 
        { 
            return 100d; 
        }
    }
}

internal class SlowEngine:IEngine
{
    public double MaxSpeed
    {
        get
        {
            return 10d;
        }
    }
}

public class Car
{
    private IEngine engine;
    public double MaximumSpeed
    {
        get
        {
            return this.engine.MaxSpeed;
        }
    }

    public Car(IEngine engine)
    {
        this.engine = engine;
    }
}

我的问题如下:我应该如何实例化一辆快车或一辆慢车?我可以使用容器为我提供每个实现，并且我可以设置一个默认"实现来使用:

My problem is the following: how should I go about instantiating a fast car or a slow car? I can use the container to provide me with each implementation, and I can set a "default" implementation to use:

IUnityContainer container = new UnityContainer();
container.RegisterType<IEngine, FastEngine>();
container.RegisterType<IEngine, FastEngine>("Fast");
container.RegisterType<IEngine, SlowEngine>( "Slow" );
var car = container.Resolve<Car>();
Assert.AreEqual(100, car.MaximumSpeed);

但我想要的是能够请求具有特定策略实施的汽车 - 类似于

but what I would like is to be able to request a car with a specific implementation of the strategy - something like

var car = container.Resolve<Car>(??? use "Fast" or "Slow ???);

我可以使用容器来做到这一点吗?或者我应该写一个使用容器的工厂?任何指导将不胜感激 - 我不确定我的想法是否正确！

Can I use the container to do that? Or should I write a Factory which uses the container? Any guidance would be appreciated - I am not sure I am thinking right about this!

推荐答案

DI 中的一个常见模式是在运行时只有一个给定抽象的实现.这只会让生活变得更轻松，因为您无需处理您所描述的那种模棱两可的情况.

A common pattern in DI is that at run-time there's only going to be a single implementation of a given abstraction. That just makes life a whole lot easier, as you don't need to deal with the ambiguity such as the one you describe.

但是，有时，您需要根据上下文来改变实现，例如您提供的示例.许多 DI 容器提供了可以提供限定参数的方法，但这意味着您最终会将代码与特定的 DI 容器紧密耦合.

However, sometimes, you need to vary an implementation based on context, such as the example you give. Many DI Containers provide ways where you can provide a qualifying parameter, but that means that you will end up tightly coupling your code to a specific DI Container.

更好的解决方案是引入一个抽象工厂，它可以提供您所需要的东西.类似的东西

A much better solution would be to introduct an Abstract Factory that can provide what you need. Something like

public interface ICarFactory
{
    Car Create(IEngine engine);
}

如果您需要注入更多策略，也许 Builder 设计模式可能更适合.

If you need to inject more Strategies, perhaps the Builder design pattern might fit even better.

无论如何，重点是不要在容器中注册许多不同的 Car，而是注册一个 ICarFactory 实现.

In any case, the point is that instead of registering a lot of different Cars in the container, you would instead register a single ICarFactory implementation.

在您的客户端代码中，您将使用注入的 ICarFactory 来创建基于特定 IEngine 的 Car 实例.

In your client code, you would use the injected ICarFactory to create a Car instance based on a particular IEngine.

var car = factory.Create(engine);

这篇关于使用 Unity 的策略模式和依赖注入的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！