.NET 6 + NUnit 3 单例类单元测试隔离问题解决方案咨询

问题根源 #

你的SingletonModel<T>通过Lazy<T>实现了全局唯一实例，而NUnit的所有测试默认在同一个AppDomain中运行，导致所有测试共用同一个SingletonModel<TestClass>实例，前序测试的残留数据会直接干扰后续测试的断言结果。

可行解决方案 #

方案1：给单例添加测试专用重置方法 #

在单例类中新增重置内部状态的方法，测试前后调用它清空数据：

public sealed class SingletonModel<T> : ISingletonModel<T>
{
    // 原有代码...

    // 仅在调试/测试环境启用的重置方法
    [Conditional("DEBUG")]
    public void ResetState()
    {
        ModelDictionary.Clear();
        // 若有其他内部状态，一并在此重置
    }
}

然后在测试的TearDown中调用：

[TearDown]
public void Cleanup()
{
    model.ResetState();
}

优点：改动极小，无需修改单例核心逻辑；缺点：需依赖条件编译避免生产环境误调用。

方案2：改用依赖注入实现环境隔离 #

通过依赖注入替换直接调用单例的方式，生产环境注册为单例，测试环境注册为瞬态实例：

1. 业务代码依赖接口而非具体单例类：

public class BusinessService
{
    private readonly ISingletonModel<TestClass> _model;

    public BusinessService(ISingletonModel<TestClass> model)
    {
        _model = model;
    }
}

2. 生产环境注册单例：

// Program.cs
builder.Services.AddSingleton<ISingletonModel<TestClass>, SingletonModel<TestClass>>();

3. 测试环境注册瞬态实例：

[SetUp]
public void Setup()
{
    var services = new ServiceCollection();
    // 每次测试都创建全新实例
    services.AddTransient<ISingletonModel<TestClass>, SingletonModel<TestClass>>();
    var provider = services.BuildServiceProvider();
    model = provider.GetRequiredService<ISingletonModel<TestClass>>();
    
    testData = GenerateTestData();
}

优点：符合依赖倒置原则，测试灵活性拉满；缺点：需调整业务代码的依赖方式，适合已有DI基础的项目。

方案3：反射重置单例实例（应急用） #

通过反射修改Lazy<T>的内部状态，强制重新创建实例：

[TearDown]
public void Cleanup()
{
    var singletonField = typeof(SingletonModel<TestClass>)
        .GetField("singletonModel", BindingFlags.NonPublic | BindingFlags.Static);
    if (singletonField != null)
    {
        var newLazy = new Lazy<SingletonModel<TestClass>>(() => new SingletonModel<TestClass>());
        singletonField.SetValue(null, newLazy);
    }
}

优点：无需修改单例类代码；缺点：依赖反射，代码脆弱，单例内部实现变动（如字段名修改）会直接失效，仅适合临时应急。

方案4：改造单例为测试友好型 #

将单例的创建逻辑抽为可替换的工厂，测试时替换为新实例工厂：

public sealed class SingletonModel<T> : ISingletonModel<T>
{
    // 可替换的实例工厂，默认生产单例
    public static Func<SingletonModel<T>> InstanceFactory { get; set; } = () => new SingletonModel<T>();

    private static Lazy<SingletonModel<T>> _singletonModel = new Lazy<SingletonModel<T>>(InstanceFactory);

    public static SingletonModel<T> Instance => _singletonModel.Value;

    // 原有代码...
}

测试时在SetUp中重置工厂和实例：

[SetUp]
public void Setup()
{
    // 重置工厂为创建新实例
    SingletonModel<TestClass>.InstanceFactory = () => new SingletonModel<TestClass>();
    // 重置Lazy实例
    var lazyField = typeof(SingletonModel<TestClass>)
        .GetField("_singletonModel", BindingFlags.NonPublic | BindingFlags.Static);
    lazyField.SetValue(null, new Lazy<SingletonModel<TestClass>>(SingletonModel<TestClass>.InstanceFactory));

    model = SingletonModel<TestClass>.Instance;
    testData = GenerateTestData();
}

优点：兼顾生产环境单例特性和测试灵活性；缺点：增加了单例类的复杂度。

总结 #

优先推荐方案2（依赖注入），这是最符合现代.NET开发规范的方式；若不想调整业务代码，**方案1（添加重置方法）**是最简单的选择；反射方案尽量少用，仅作为临时应急手段。

内容的提问来源于stack exchange，提问作者Garry A