与其他测试一起运行时，异步本地测试失败

Question

我正在尝试创建一个名为＜code＞AuditScope＜code＞的自定义范围类，通过＜code＞AuditScope.current＜code＞可以访问当前范围。

如果有嵌套的作用域，则当前作用域是嵌套最多的作用域。

我希望这是线程安全的，所以我使用AsyncLocal来确保当前范围属于当前异步上下文，并且不会与其他请求发生冲突。如果你们有人遇到过，这类似于TransactionScope类。

下面是我的作用域类:

public sealed class AuditScope : IDisposable
{
    private static readonly AsyncLocal<Stack<AuditScope>> ScopeStack = new();

    public int ExecutedByUserId { get; }

    public AuditScope(int executedByUserId)
    {
        ExecutedByUserId = executedByUserId;

        if (ScopeStack.Value == null)
        {
            ScopeStack.Value = new Stack<AuditScope>();
        }

        ScopeStack.Value.Push(this);
    }

    public static AuditScope? Current
    {
        get
        {
            if (ScopeStack.Value == null || ScopeStack.Value.Count == 0)
            {
                return null;
            }

            return ScopeStack.Value.Peek();
        }
    }

    public void Dispose()
    {
        ScopeStack.Value?.Pop();
    }
}

我的所有测试都单独通过，但是如果我同时运行所有测试，有一个测试总是失败:

[Test]
public async Task GivenThreadCreatesScope_AndSecondThreadCreatesScope_WhenCurrentScopeAccessedOnBothThreads_ThenCorrectScopeReturned()
{
    // Arrange
    static async Task createScopeWithLifespan(int lifespanInMilliseconds)
    {
        // This line throws the error, saying it is not null (for the 2000ms scope)
        // No scope has been created yet for this async context, so current should be null
        Assert.IsNull(AuditScope.Current);

        using (var scope = new AuditScope(1))
        {
            // Scope has been created, so current should match
            Assert.AreEqual(scope, AuditScope.Current);

            await Task.Delay(lifespanInMilliseconds);

            // Scope has not been disposed, so current should still match
            Assert.AreEqual(scope, AuditScope.Current);
        }

        // Scope has been disposed, so current should be null
        Assert.IsNull(AuditScope.Current);
    }

    // Act & Assert
    await Task.WhenAll(
        createScopeWithLifespan(1000),
        createScopeWithLifespan(2000));
}

当然，由于使用语句的在不同的上下文中，这应该可以工作吗？为什么在单独运行时会通过，而在与其他测试一起运行时不会通过？

为了完整起见，下面是我正在运行的其他测试，但我严重怀疑它们是否会直接影响到它们:

[Test]
public void GivenNoCurrentScope_WhenCurrentScopeAccessed_ThenNull()
{
    // Act
    var result = AuditScope.Current;

    // Arrange
    Assert.Null(result);
}

[Test]
public void GivenScope_WhenScopeDisposed_ThenNull()
{
    // Arrange
    using (var scope = new AuditScope(1))
    {
    }

    // Act
    var result = AuditScope.Current;

    // Arrange
    Assert.Null(result);
}

[Test]
public void GivenScopeCreated_WhenCurrentScopeAccessed_ThenScopeReturned()
{
    // Arrange
    using (var scope = new AuditScope(1))
    {
        // Act
        var result = AuditScope.Current;

        // Arrange
        Assert.NotNull(result);
        Assert.AreEqual(scope, result);
    }
}

[Test]
public void GivenNestedScopeCreated_WhenCurrentScopeAccessed_ThenNestedScopeReturned()
{
    // Arrange
    using (var scope = new AuditScope(1))
    {
        using (var nestedScope = new AuditScope(2))
        {
            // Act
            var result = AuditScope.Current;

            // Arrange
            Assert.NotNull(result);
            Assert.AreEqual(nestedScope, result);
        }
    }
}

[Test]
public void GivenNestedScopeCreated_WhenNestedScopeDisposed_ThenCurrentScopeRevertsToParent()
{
    // Arrange
    using (var scope = new AuditScope(1))
    {
        using (var nestedScope = new AuditScope(2))
        {
        }

        // Act
        var result = AuditScope.Current;

        // Arrange
        Assert.NotNull(result);
        Assert.AreEqual(scope, result);
    }
}




Answer 1

我也有同样的问题。像我一样，我相信你的问题是在你的处置:

public void Dispose()
{
    ScopeStack.Value?.Pop();
}

如果你把它换成这个，我愿意打赌吗？

public void Dispose()
{
    ScopeStack.Value?.Pop();
    if(ScopeStack.Value.Count == 0)
         ScopeStack.Value = null;
}

...即使没有不变堆栈，您的代码也会按预期工作。

异步本地感觉类似于线程静态，并且在异步上下文（如 MVC）中使用时也是如此。它给出了您期望的每个调用上下文的相同分离，但解决了由不同线程提供服务的上下文所创建的问题。

但是与ThreadStatic不同，AsyncLocal上下文确实向下流到同一个调用上下文中的子线程。

在我们的单元测试中，初始调用上下文是测试运行器，它可能在同一线程中运行其他测试。当它到达有问题的测试时，ScopeStack被初始化，然后传递到子线程。您可能会在启动任务之前简单地创建并销毁ScopeStack，从而重现相同的错误。

将它设置为null允许它在线程内部重新初始化，而AsyncLocal不会流回(子线程都将初始化自己的线程，因为它们不会看到它已经建立)。

ImmutableStack修复了它，因为即使它向下流动，您也永远不会真正对原始版本进行更改。这里唯一的问题是，如果您想进行一些无效的嵌套检测或不允许在子范围之前从父范围进行处置，您将无法看到子范围所做的此类更改。当然，如果您需要从同一个父范围启动多个兄弟姐妹，这可能已经是遥不可及的了（此时他们不能共享一个堆栈）。

Answer 2

事实证明，在某个地方一定存在引用问题，因为替换了Stack