C# xUnit测试类跨方法共享字典缓存失效问题求解

xUnit 测试框架默认会为每个标记了[Fact]/[Theory]的测试方法单独初始化一次测试类实例，定义在测试类中的实例字段_cacheExecutor会随每个新实例重新创建，自然无法在同个测试类的不同测试方法间共享缓存状态，这就是缓存始终失效的核心原因。

优先使用xUnit原生的Fixture生命周期机制管理共享缓存，完全贴合框架设计逻辑，不需要额外处理静态资源泄漏、测试间脏数据干扰问题：

方案1：单测试类内共享缓存（适配当前场景） #

把缓存字典从测试类实例字段迁移到独立的Fixture类中，通过IClassFixture注入，同一个测试类下的所有测试方法会共享同一个Fixture实例，缓存可以直接跨方法复用。

1. 先定义独立的缓存Fixture：

public class SchemaExecutorCacheFixture
{
    // 用并发字典替代普通字典，避免测试并行执行时出现线程安全问题
    public ConcurrentDictionary<(Type EntityType, object TestData), Task<IRequestExecutor>> Cache { get; } = new();
}

2. 调整测试类，注入缓存Fixture：

// 原有的PostgreSqlResource依赖保留，多个Fixture直接追加到IClassFixture的泛型参数即可
public class CodesAndGuidelinesTest : SchemaCache, IClassFixture<PostgreSqlResource>, IClassFixture<SchemaExecutorCacheFixture>
{       
    private readonly SchemaExecutorCacheFixture _cacheFixture;
    public CodesAndGuidelinesTest(PostgreSqlResource resource, SchemaExecutorCacheFixture cacheFixture) :base(resource) 
    {
        _cacheFixture = cacheFixture;
    }

    [Fact]
    public async Task Create_Name_Contains_Expression()
    {
        IRequestExecutor requestExecutor = await CreateSchemaAsync(CodesAndGuidelinesMockFixture.codeStandardGuidelines, _cacheFixture.Cache);
        // 原有测试逻辑
    }

    [Fact]
    public async Task Create_Name_NotContains_Expression()
    {
        IRequestExecutor requestExecutor = await CreateSchemaAsync(CodesAndGuidelinesMockFixture.codeStandardGuidelines, _cacheFixture.Cache);
        // 原有测试逻辑
    }
}

方案2：跨多个测试类共享缓存 #

如果项目中多个测试类都需要复用同一份Schema执行器缓存，可以改用xUnit的CollectionFixture机制，把缓存放到集合级别的Fixture中，同一个测试集合下的所有测试类都会共享同一个缓存实例，能进一步减少重复创建Schema的开销。

当前缓存键逻辑存在缺陷：作为键组成部分的测试数据是数组类型，默认的字典相等比较器对数组使用引用相等判断——哪怕两个数组内容完全一致，只要是不同的实例，就会被判定为不同的键，依然会重复执行创建逻辑。
修复方式是给缓存字典传入自定义的相等比较器，对数组类型的测试数据做逐元素内容比较：

public class EntityCacheKeyComparer : IEqualityComparer<(Type EntityType, object TestData)>
{
    public bool Equals((Type EntityType, object TestData) x, (Type EntityType, object TestData) y)
    {
        if (x.EntityType != y.EntityType) return false;
        if (x.TestData is Array xArr && y.TestData is Array yArr)
        {
            if (xArr.Length != yArr.Length) return false;
            for (int i = 0; i < xArr.Length; i++)
            {
                if (!Equals(xArr.GetValue(i), yArr.GetValue(i))) return false;
            }
            return true;
        }
        return Equals(x.TestData, y.TestData);
    }

    public int GetHashCode((Type EntityType, object TestData) obj)
    {
        HashCode hash = new();
        hash.Add(obj.EntityType);
        if (obj.TestData is Array arr)
        {
            foreach (var item in arr)
            {
                hash.Add(item);
            }
        }
        else
        {
            hash.Add(obj.TestData);
        }
        return hash.ToHashCode();
    }
}

初始化并发字典时传入该比较器即可生效：

public ConcurrentDictionary<(Type EntityType, object TestData), Task<IRequestExecutor>> Cache { get; } 
    = new(new EntityCacheKeyComparer());

直接把缓存字典标记为static虽然也能实现跨实例共享，但存在两个明显缺陷：

• 静态字段生命周期随测试运行的AppDomain存在，不同测试批次运行时可能残留旧缓存，导致测试结果不稳定、出现偶发失败
• 全局静态对象需要自行处理线程安全、测试隔离逻辑，不符合xUnit的生命周期设计规范，后续调试问题的成本很高

内容的提问来源于stack exchange，提问作者Glory Raj