枚举类模式是否与 DI 不兼容？

Question

在进入 DI 之前，我非常喜欢使用所谓的枚举类（或我脑海中的强枚举），其中枚举被转换为类，但设置为以与枚举类似的方式使用。这使得真正属于特定枚举的逻辑能够被封装在正确的位置，并防止代码库中出现大量混乱。

一个例子是在这里找到的http://lostechies.com/jimmybogard/2008/08/12/enumeration-classes/

一旦将 DI 带入方程，由于依赖静态变量，它会出现问题。

有什么方法可以继续支持这种模式并同时使用 DI？

编辑： 如果我想向 EmployeeType 注入一些新的东西，这是一个有问题的类型示例。由于静态变量，我无法使用容器。

public class EmployeeType : Enumeration
{
    public static readonly EmployeeType Manager 
        = new ManagerType (0, "Manager");
    public static readonly EmployeeType Servant 
        = new EmployeeType(1, "Servant");
    public static readonly EmployeeType AssistantToTheRegionalManager 
        = new EmployeeType(2, "Assistant to the Regional Manager");

    private EmployeeType() { }
    private EmployeeType(int value, string displayName) : base(value, displayName) { }
}

public class ManagerType : EmployeeType
{
}

Answer 1

我想你可以在这里使用Strategy pattern。您可以保留枚举类型或使用任何类型来帮助您识别策略（我将在示例中使用字符串）。然后为每个值实施一个策略。

interface IEmployeeHandler
{
    string EmployeeType { get; }
    void Handle(Employee employee);
}

class ManagerHandler : IEmployeeHandler
{
    public ManagerHandler()
    {
        EmployeeType = "Manager";
    }

    public string EmployeeType { get; private set; }
    public void Handle(Employee employee) { }
}

class ServantHandler : IEmployeeHandler
{
    public ServantHandler()
    {
        EmployeeType = "Servant";
    }

    public string EmployeeType { get; private set; }
    public void Handle(Employee employee) { }
}

由于 DI 容器可以注入接口的多个实现，您可以像这样编写策略提供程序类：

class EmployeeStrategyProvider
{
    private readonly IEmployeeHandler[] _employeeHandlers;

    public EmployeeStrategyProvider(IEmployeeHandler[] employeeHandlers)
    {
        _employeeHandlers = employeeHandlers;
    }

    public IEmployeeHandler GetStrategy(string employeeType)
    {
        return _employeeHandlers.FirstOrDefault(item => item.EmployeeType == employeeType);
    }
}

您可以使用此类根据员工类型获取正确的策略。这就是我使用 DI 容器实现策略模式的方式。它可以使用一些改进，但我 很高兴听到一些建议。

Answer 2

我自己使用这种模式已经有一段时间了，但从未考虑过需要向其中注入服务。但是，嘿，这应该是可能的吧？

一种解决方案是将依赖于服务实例的任何枚举的创建延迟到需要它们之前 - 其他一切看起来和行为都像常规静态类型。

这是 EmployeeType 类，添加了依赖于 IBonusService 的 Manager 的延迟实例化：

public class EmployeeType : Enumeration
{
    public static Func<IBonusService> BonusService { private get; set; }

    private static EmployeeType _manager = null;
    public static EmployeeType Manager { 
        get 
        {
            if (_manager == null) _manager = new ManagerType(BonusService());
            return _manager;
        } }

    public static readonly EmployeeType Servant
        = new EmployeeType(1, "Servant");
    public static readonly EmployeeType AssistantToTheRegionalManager
        = new EmployeeType(2, "Assistant to the Regional Manager");
    private EmployeeType(int value, string displayName) :
       base(value, displayName) { }

    public virtual decimal BonusSize { get { return 0; } }

    private class ManagerType : EmployeeType
    {
        private readonly IBonusService service;
        public ManagerType(IBonusService service) : base(0, "Manager")
        {
            this.service = service;
        }

        public override decimal BonusSize {
            get { return this.service.currentManagerBonus; } }
    }
}

然后您在组合根目录中配置依赖项：

[Test]
public void EmployeeType_Manager_HasBonusService()
{
    Container container = new Container();
    container.Register<IBonusService, BonusServiceStub>();
    EmployeeType.BonusService = () => container.GetInstance<IBonusService>();

    BonusServiceStub.constructed = false;
    container.Verify();
    //Verify has ensured the container can create instances of IBonusService
    Assert.That(BonusServiceStub.constructed, Is.True);

    EmployeeType manager = EmployeeType.Manager;
    Assert.That(manager.BonusSize == 999m);
}


public class BonusServiceStub : IBonusService
{
    public static bool constructed = false;

    public BonusServiceStub() { constructed = true; }

    public decimal currentManagerBonus { get { return 999m; } }
}

---

专门注入 Func<IBonusService> 而不是 IBonusService 的原因是，服务的生命周期范围（以及装饰等）在组合根中进行管理，并且独立于使用者。

Answer 3

你可以为你的枚举类使用单例。