时间戳

首页 > 解决方案 > 我是否需要在逻辑请求端手动将 AsyncLocal 变量的值更改为“Dispose”/“Release”

c# - 我是否需要在逻辑请求端手动将 AsyncLocal 变量的值更改为“Dispose”/“Release”

问题描述

AsyncLocal<T>我从MSDN 文档中读到过，但有一点我还不清楚。

我正在研究诸如上下文绑定缓存/记忆之类的东西，其目的很简单，就是在逻辑请求中存储数据。这类似于旧的HttpContext.Current，其中数据存储在请求中，并将在请求结束时释放。然而，在我的情况下，我希望与环境无关，因此实现不绑定到例如 ASP.NET MVC、ASP.NET Core、WCF 等，同时仍然能够存储和检索数据绑定到逻辑请求，而不在逻辑不同的请求之间共享它。

为了根据问题简化我的代码，它看起来有点像这样：

class ContextualStorageAccessor
{
    // ConcurrentDictionary since it's okay if some parallel operations are used per logical request 
    private readonly AsyncLocal<ConcurrentDictionary<string, object>> _csm = new AsyncLocal<ConcurrentDictionary<string, object>>();

    public ConcurrentDictionary<string, object> Storage
    { 
        get
        {
            if (_csm.Value != null)
                return _csm.Value;

            _csm.Value = new ConcurrentDictionary<string, object>();

            return _csm.Value;
        }
    } 
}

的生命周期ContextualStorageAccessor是单例。

Value现在的问题是：每个请求我会有一个唯一的实例吗？换句话说，我是否需要继续_csm.Value手动分配默认值？或者我可以依靠应用程序本身的类型（例如，ASP.NET MVC、WCF 等）来处理它？

或者，换种说法：“异步流”的结尾在哪里，并ExecutionContext保证每个逻辑调用的唯一值将自动失效——在一个简单的场景中，null将被分配给AsyncLocal.Value——在逻辑调用结束时（对于 ASP. NET MVC，一个 Web 请求；对于 WCF，一个操作）是否AsyncLocal.Value使用？

标签： c#asynchronouscachingconcurrencyasync-await

解决方案

如果您尝试此代码，您将看到每个新的异步流都会创建一个新值。所以答案应该是：是的，每个请求都应该有一个唯一的值。

private static readonly AsyncLocal<object> Item = new AsyncLocal<object>();

public static async Task Main()
{
    async Task Request()
    {
        if (Item.Value is {})
        {
            Console.WriteLine("This should never happen.");
            throw new InvalidOperationException("Value should be null here.");
        }

        Item.Value = new object();
    }

    await Task.Run(Request); // Just to be sure that Item.Value is initialized once.

    await Task.WhenAll(
        Task.Run(Request),
        Task.Run(Request),
        Task.Run(Request),
        Task.Run(Request),
        Task.Run(Request));

    Console.WriteLine("finished");
}

演示

但我尝试了一个更复杂的示例来确定异步流程的结束位置。代码非常简单，但大量使用Console.WriteLine使它有点混乱。

public class Program
{
    public static async Task Main()
    {
        await Task.Run(async () => 
            {
                Console.WriteLine("Async flow entered...");             

                // Init async value
                if (Cache.Instance.Item.Value is {})
                    throw new InvalidOperationException("The async flow has just startet. A value should not be initialized.");

                var newValue = new object();
                Console.WriteLine($"Create: value = #{RuntimeHelpers.GetHashCode(newValue)}");

                Cache.Instance.Item.Value = newValue;
                await Foo();

                Console.WriteLine("Async flow exitted.");
            });

        Console.WriteLine("Main finished.\n\n");
    }

    private static async Task Foo()
    {
        Console.WriteLine($"Foo: entered...");
        await Bar();

        Console.WriteLine($"Foo: getting value...");
        var knownValue = Cache.Instance.Item.Value;
        Console.WriteLine($"Foo: value = #{RuntimeHelpers.GetHashCode(knownValue)}");
        Console.WriteLine($"Foo: exitted.");
    }

    private static async Task Bar()
    {
        Console.WriteLine($"Bar: entered...");
        await Task.CompletedTask;
        Console.WriteLine($"Bar: exitted.");
    }
}

public sealed class Cache
{
    public static Cache Instance = new Cache();

    public AsyncLocal<object> Item { get; } = new AsyncLocal<object>(OnValueChanged);

    private static void OnValueChanged(AsyncLocalValueChangedArgs<object> args)
    {
        Console.WriteLine($"OnValueChanged! Prev: #{RuntimeHelpers.GetHashCode(args.PreviousValue)} Current: #{RuntimeHelpers.GetHashCode(args.CurrentValue)}");
    }
}

演示

该代码的输出是：

Async flow entered...
Create: value = #6044116
OnValueChanged! Prev: #0 Current: #6044116
Foo: entered...
Bar: entered...
Bar: exitted.
Foo: getting value...
Foo: value = #6044116
Foo: exitted.
Async flow exitted.
OnValueChanged! Prev: #6044116 Current: #0
Main finished.

价值流是预期的。这回答了是否将值分配给默认值的问题- 是的。异步流在完成的地方Task.Run结束，这就是值被分配到的地方default。

但是，如果您更改await Task.CompletedTask;为. 输出看起来有很大不同：Barawait Task.Delay(1);

Async flow entered...
Create: value = #6044116
OnValueChanged! Prev: #0 Current: #6044116
Foo: entered...
Bar: entered...
OnValueChanged! Prev: #6044116 Current: #0
OnValueChanged! Prev: #0 Current: #6044116
Bar: exitted.
Foo: getting value...
Foo: value = #6044116
Foo: exitted.
Async flow exitted.
OnValueChanged! Prev: #6044116 Current: #0
Main finished.


OnValueChanged! Prev: #0 Current: #6044116
OnValueChanged! Prev: #6044116 Current: #0

奇怪的部分在Bar输入后开始。它看起来await Task.Delay(1)打破了异步流程。但是价值被正确地恢复了。在这里，我至少可以通过猜测来做出解释。

真正有趣的事情发生在 main 完成之后。值又恢复清零了……我这里缺乏想象力。我完全不知道为什么以及如何在Task.Run完成后恢复值并且异步流程也应该完成。这让我感觉在程序结束之前 GC 无法清除对象。

推荐阅读