重构静态类以与依赖项注入一起使用

Question

我们需要在代码中使用具有静态方法的非托管库。我想在我的代码中介绍库操作作为依赖项。除了静态方法之外，库还有一个初始化方法和一个设置方法，这两个方法都是全局的。所以我不能把它包装在一个实例类中，因为如果一个实例更改了设置，所有其他实例都会受到影响，如果一个例子被初始化，所有其他的实例都会被重新初始化。

我曾考虑将它作为一个单例类引入。这样，它将在一个实例类中，但只有一个实例，因此我不必担心更改设置或初始化。你觉得这种方法怎么样？我对依赖注入模式还很陌生，我不确定单例模式是否是一个好的解决方案？对于类似的情况，您的解决方案是什么？

编辑：初始化也需要一个参数，所以我不能每次调用方法时都锁定方法调用并重新初始化和更改设置。

编辑2:以下是一些方法的签名：

public static void Initialize(int someParameter)
// Parameter can only be changed by re-initalization which
// will reset all the settings back to their default values.
public static float[] Method1(int someNumber, float[] someArray)
public static void ChangeSetting(string settingName, int settingValue)

Answer 1

如果您只需要在启动时设置一次设置，那么我建议创建一个非静态包装类，它在自己的静态构造函数中完成静态类的所有初始化。这样你就可以确信它只会发生一次：

public class MyWrapper
{
    public MyWrapper()
    {
        // Do any necessary instance initialization here
    }
    static MyWrapper()
    {
        UnManagedStaticClass.Initialize();
        UnManagedStaticClass.Settings = ...;
    }
    public void Method1()
    {
        UnManagedStaticClass.Method1();
    }
}

然而，如果你每次调用时都需要更改设置，并且你想让你的实例线程安全，那么我建议锁定一个静态对象，这样你就不会在静态设置仍被另一个线程使用时意外覆盖：

public class MyWrapper
{
    public MyWrapper()
    {
        // Do any necessary instance initialization here
    }
    static MyWrapper()
    {
        UnManagedStaticClass.Initialize();
    }
    static object lockRoot = new Object();
    public void Method1()
    {
        lock (lockRoot)
        {
            UnManagedStaticClass.Settings = ...;
            UnManagedStaticClass.Method1();
        }
    }
}   

如果您需要将初始化参数传递到类的实例构造函数中，那么您也可以通过具有静态标志字段来实现这一点：

public class MyWrapper
{
    public MyWrapper(InitParameters p)
    {
        lock (lockRoot)
        {
            if (!initialized)
            {
                UnManagedStaticClass.Initialize(p);
                initialized = true;
            }
        }
    }
    static bool initialized = false;
    static object lockRoot = new Object();
    public void Method1()
    {
        lock (lockRoot)
        {
            UnManagedStaticClass.Settings = ...;
            UnManagedStaticClass.Method1();
        }
    }
}

如果每次都需要重新初始化，但由于重新初始化太慢而担心性能，那么（除了可怕的singleton之外）唯一的其他选项是自动检测是否需要重新初始化并且只在必要时进行。至少在那时，只有当两个线程同时使用两个不同的实例时才会发生这种情况。你可以这样做：

public class MyWrapper
{
    public MyWrapper(InitParameters initParameters, Settings settings)
    {
        this.initParameters = initParameters;
        this.settings = settings;
    }
    private InitParameters initParameters;
    private Settings settings;
    static MyWrapper currentOwnerInstance;
    static object lockRoot = new Object();
    private void InitializeIfNecessary()
    {
        if (currentOwnerInstance != this)
        {
            currentOwnerInstance = this;
            UnManagedStaticClass.Initialize(initParameters);
            UnManagedStaticClass.Settings = settings;
        }
    }
    public void Method1()
    {
        lock (lockRoot)
        {
            InitializeIfNecessary();
            UnManagedStaticClass.Method1();
        }
    }
}

Answer 2

我将使用一个无状态服务类，并在每次方法调用时传递静态类的状态信息。在不了解类的任何细节的情况下，我将用一个c#静态类展示另一个例子。

public static class LegacyCode
{
    public static void Initialize(int p1, string p2)
    {
        //some static state
    }
    public static void ChangeSettings(bool p3, double p4)
    {
        //some static state
    }
    public static void DoSomething(string someOtherParam)
    {
        //execute based on some static state
    }
}
public class LegacyCodeFacadeService
{
    public void PerformLegacyCodeActivity(LegacyCodeState state, LegacyCodeParams legacyParams)
    {
        lock (_lockObject)
        {
            LegacyCode.Initialize(state.P1, state.P2);
            LegacyCode.ChangeSettings(state.P3, state.P4);
            LegacyCode.DoSomething(legacyParams.SomeOtherParam);
            //do something to reset state, perhaps
        }
    }
}

你必须稍微填空，但希望你能明白。关键是在所需的最短时间内设置静态对象的状态，并在整个时间内锁定对它的访问，这样其他调用方就不会受到全局状态更改的影响。您必须创建该类的新实例才能使用它，因此它是完全可注入和可测试的（除了提取接口的步骤，为了简洁起见，我跳过了这个步骤）。

这里有很多实现选项。例如，如果您必须大量更改LegacyCodeState，但仅限于少数特定状态，则可能会有重载来管理这些状态。

编辑

在很多方面，这比单例更可取，最重要的是，您将无法累积并耦合到全局状态：如果全局状态是静态类的唯一入口点，则将其转换为非全局状态。然而，如果您最终需要一个singleton，您可以通过在这里封装构造函数来简化切换。

public class LegacyCodeFacadeService
{
    private LegacyCodeFacadeService() { }
    public static LegacyCodeFacadeService GetInstance()
    {
        //now we can change lifestyle management strategies later, if needed
        return new LegacyCodeFacadeService();
    }
    public void PerformLegacyCodeActivity(LegacyCodeState state, LegacyCodeParams legacyParams)
    {
        lock (_lockObject)
        {
            LegacyCode.Initialize(state.P1, state.P2);
            LegacyCode.ChangeSettings(state.P3, state.P4);
            LegacyCode.DoSomething(legacyParams.SomeOtherParam);
            //do something to reset state, perhaps
        }
    }
}