A brief analysis of the implementation principle of AsyncLocal in .NET

public class HttpContextAccessor : IHttpContextAccessor
{
    private static AsyncLocal<HttpContextHolder> _httpContextCurrent = new AsyncLocal<HttpContextHolder>();
	// Other codes are not displayed here}

class Program
{
    [ThreadStatic]
    private static string _value;
    static void Main(string[] args)
    {
        (0, 4, _ =>
        {
            var threadId = ;
            _value ??= $"This is from the thread{threadId}Data of";
            ($"Thread：{threadId}; Value：{_value}");
        });
    }
}

class Program
{
    [ThreadStatic]
    private static string _threadStatic;
    private static ThreadLocal<string> _threadLocal = new ThreadLocal<string>();
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static void Main(string[] args)
    {
        (0, 4, _ =>
        {
            var threadId = ;
            var value = $"This is from the thread{threadId}Data of";
            _threadStatic ??= value;
            ("value", value);
            _threadLocal.Value ??= value;
            _asyncLocal.Value ??= value;
            ($"Use ThreadStaticAttribute; Thread：{threadId}; Value：{_threadStatic}");
            ($"Use CallContext;           Thread：{threadId}; Value：{("value")}");
            ($"Use ThreadLocal;           Thread：{threadId}; Value：{_threadLocal.Value}");
            ($"Use AsyncLocal;            Thread：{threadId}; Value：{_asyncLocal.Value}");
        });
        ();
    }
}

class Program
{
    [ThreadStatic]
    private static string _threadStatic;
    private static ThreadLocal<string> _threadLocal = new ThreadLocal<string>();
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static void Main(string[] args)
    {
        _threadStatic = "ThreadStatic saved data";
        _threadLocal.Value = "ThreadLocal saved data";
        _asyncLocal.Value = "AsyncLocal saved data";
        PrintValuesInAnotherThread();
        ();
    }
    private static void PrintValuesInAnotherThread()
    {
        (() =>
        {
            ($"ThreadStatic: {_threadStatic}");
            ($"ThreadLocal: {_threadLocal.Value}");
            ($"AsyncLocal: {_asyncLocal.Value}");
        });
    }
}

public sealed class AsyncLocal<T> : IAsyncLocal
{
    private readonly Action<AsyncLocalValueChangedArgs<T>>? m_valueChangedHandler;
    // Non-parameter structure    public AsyncLocal()
    {
    }
    // You can register the constructor of the callback. When Value is changed in any thread, the callback will be called    public AsyncLocal(Action<AsyncLocalValueChangedArgs<T>>? valueChangedHandler)
    {
        m_valueChangedHandler = valueChangedHandler;
    }
    [MaybeNull]
    public T Value
    {
        get
        {
            // Get the value from the ExecutionContext as the Key            object? obj = (this);
            return (obj == null) ? default : (T)obj;
        }
        // Whether to register a callback will affect whether the ExecutionContext saves its reference        set => (this, value, m_valueChangedHandler != null);
    }
    // In ExecutionContext, if the value has changed, this method will be called    void (object? previousValueObj, object? currentValueObj, bool contextChanged)
    {
        (m_valueChangedHandler != null);
        T previousValue = previousValueObj == null ? default! : (T)previousValueObj;
        T currentValue = currentValueObj == null ? default! : (T)currentValueObj;
        m_valueChangedHandler(new AsyncLocalValueChangedArgs<T>(previousValue, currentValue, contextChanged));
    }
}
internal interface IAsyncLocal
{
    void OnValueChanged(object? previousValue, object? currentValue, bool contextChanged);
}

public class ExecutionContext
{
    internal static object? GetLocalValue(IAsyncLocal local);
    internal static void SetLocalValue(
        IAsyncLocal local,
        object? newValue,
        bool needChangeNotifications);
}

class ExecutionContext
{
    public static ExecutionContext? Capture()
    {
        ExecutionContext? executionContext = ._executionContext;
        if (executionContext == null)
        {
            executionContext = Default;
        }
        else if (executionContext.m_isFlowSuppressed)
        {
            executionContext = null;
        }
        return executionContext;
    }
}

class Thread
{
	// Save the execution context associated with the current thread    internal ExecutionContext? _executionContext;
    [ThreadStatic]
    private static Thread? t_currentThread;
    public static Thread CurrentThread => t_currentThread ?? InitializeCurrentThread();
	public ExecutionContext? ExecutionContext => ();
}

public sealed class ExecutionContext : IDisposable, ISerializable
{
    // Default execution context    internal static readonly ExecutionContext Default = new ExecutionContext(isDefault: true);
    // Default context after execution context prohibits flow    internal static readonly ExecutionContext DefaultFlowSuppressed = new ExecutionContext(, <IAsyncLocal>(), isFlowSuppressed: true);
	// Save the Value values ​​of all AsyncLocals registered with modified callbacks. This article does not involve specific discussions on this field.    private readonly IAsyncLocalValueMap? m_localValues;
    // Save all AsyncLocal object references registered with callbacks    private readonly IAsyncLocal[]? m_localChangeNotifications;
    // Whether the current thread prohibits context flow    private readonly bool m_isFlowSuppressed;
    // Is the current context the default context    private readonly bool m_isDefault;
}

public class ExecutionContext
{
    private readonly IAsyncLocalValueMap m_localValues;
}

// This interface is used to save the mapping relationship of IAsyncLocal => object in the ExecutionContext.// Its implementation is set to immutable, and as the number of elements increases, the spatial complexity and time complexity also increase.internal interface IAsyncLocalValueMap
{
    bool TryGetValue(IAsyncLocal key, out object? value);
	// Add AsyncLocal or modify existing AsyncLocal through this method    // If the number does not change, return the IAsyncLocalValueMap implementation class instance of the same type.	// If the number changes (increase or decrease, it will decrease when the value is set to null), it may return different types of IAsyncLocalValueMap implementation class instances    IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent);
}

internal static class AsyncLocalValueMap
{
    // EmptyAsyncLocalValueMap is only instantiated here, and is used as a constant in other places.    public static IAsyncLocalValueMap Empty { get; } = new EmptyAsyncLocalValueMap();
    public static bool IsEmpty(IAsyncLocalValueMap asyncLocalValueMap)
    {
        (asyncLocalValueMap != null);
        (asyncLocalValueMap == Empty || () != typeof(EmptyAsyncLocalValueMap));
        return asyncLocalValueMap == Empty;
    }
    public static IAsyncLocalValueMap Create(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent)
    {
        // Create the initial instance        // If AsyncLocal registers a callback, it is necessary to save the value of null so that the callback will be triggered due to the change in the next time a non-null value is set        return value != null || !treatNullValueAsNonexistent ?
            new OneElementAsyncLocalValueMap(key, value) :
            Empty;
    }
}

private sealed class ThreeElementAsyncLocalValueMap : IAsyncLocalValueMap
{
	// Declare three private fields to save key    private readonly IAsyncLocal _key1, _key2, _key3;
	// Declare three private fields to save    private readonly object? _value1, _value2, _value3;
    public ThreeElementAsyncLocalValueMap(IAsyncLocal key1, object? value1, IAsyncLocal key2, object? value2, IAsyncLocal key3, object? value3)
    {
        _key1 = key1; _value1 = value1;
        _key2 = key2; _value2 = value2;
        _key3 = key3; _value3 = value3;
    }
    public IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent)
    {
		// If AsyncLocal has registered a callback, the value of treatNullValueAsNoneexistent is false.		// means that even if value is null, it is considered valid        if (value != null || !treatNullValueAsNonexistent)
        {
			// If the current map has saved the incoming key, a new map instance with updated value is returned            if (ReferenceEquals(key, _key1)) return new ThreeElementAsyncLocalValueMap(key, value, _key2, _value2, _key3, _value3);
            if (ReferenceEquals(key, _key2)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, key, value, _key3, _value3);
            if (ReferenceEquals(key, _key3)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value);
            // If the current key does not exist in the map, a map that can store the fourth key is needed            var multi = new MultiElementAsyncLocalValueMap(4);
            (0, _key1, _value1);
            (1, _key2, _value2);
            (2, _key3, _value3);
            (3, key, value);
            return multi;
        }
        else
        {
			// value is null, the corresponding key will be ignored or removed from the map. There will be two situations here			// 1. If the current key exists in the map, remove this key and the map type is downgraded to TwoElementAsyncLocalValueMap            return
                ReferenceEquals(key, _key1) ? new TwoElementAsyncLocalValueMap(_key2, _value2, _key3, _value3) :
                ReferenceEquals(key, _key2) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key3, _value3) :
                ReferenceEquals(key, _key3) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key2, _value2) :
				// 2. If the current key does not exist in the map, it will be directly ignored                (IAsyncLocalValueMap)this;
        }
    }
	// You can find the corresponding value by comparing it at most three times    public bool TryGetValue(IAsyncLocal key, out object? value)
    {
        if (ReferenceEquals(key, _key1))
        {
            value = _value1;
            return true;
        }
        else if (ReferenceEquals(key, _key2))
        {
            value = _value2;
            return true;
        }
        else if (ReferenceEquals(key, _key3))
        {
            value = _value3;
            return true;
        }
        else
        {
            value = null;
            return false;
        }
    }
}

internal static void SetLocalValue(IAsyncLocal local, object? newValue, bool needChangeNotifications)
{
	// Get the current execution context    ExecutionContext? current = ._executionContext;
    object? previousValue = null;
    bool hadPreviousValue = false;
    if (current != null)
    {
        (!);
        (current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
		// Determine whether the AsyncLocal currently has a corresponding Value as a Key        hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue);
    }
	// If the value has not changed twice, continue processing    if (previousValue == newValue)
    {
        return;
    }
	// Description of treatmentNullValueAsNoneexistent: !needChangeNotifications	// If AsyncLocal registers a callback, then needChangeNotifications is ture, m_localValues ​​will save the null value so that the change callback will be triggered next time    IAsyncLocal[]? newChangeNotifications = null;
    IAsyncLocalValueMap newValues;
    bool isFlowSuppressed = false;
    if (current != null)
    {
        (!);
        (current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
        isFlowSuppressed = current.m_isFlowSuppressed;
		// This step is very critical. Modify the map by calling m_localValues.Set, which will produce a new map instance.        newValues = current.m_localValues.Set(local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
        newChangeNotifications = current.m_localChangeNotifications;
    }
    else
    {
        // If the current context does not exist, create the first IAsyncLocalValueMap instance        newValues = (local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
    }
    // If AsyncLocal registers a callback, you need to save the reference to AsyncLocal    // There will be two situations here, one is that the array has not been created, and the other is that the array has existed    if (needChangeNotifications)
    {
        if (hadPreviousValue)
        {
            (newChangeNotifications != null);
            ((newChangeNotifications, local) >= 0);
        }
        else if (newChangeNotifications == null)
        {
            newChangeNotifications = new IAsyncLocal[1] { local };
        }
        else
        {
            int newNotificationIndex = ;
			// This method will create a new array and copy the original element in the past			(ref newChangeNotifications, newNotificationIndex + 1);
            newChangeNotifications[newNotificationIndex] = local;
        }
    }
	// If AsyncLocal has a valid value and allows execution context flow, a new ExecutionContext instance is created, and the new instance will save all AsyncLocal values ​​and all AsyncLocal references that need to be notified.    ._executionContext =
        (!isFlowSuppressed && (newValues)) ?
        null : // No values, return to Default context
        new ExecutionContext(newValues, newChangeNotifications, isFlowSuppressed);
    if (needChangeNotifications)
    {
		// Call the previously registered delegation        (previousValue, newValue, contextChanged: false);
    }
}

internal static object? GetLocalValue(IAsyncLocal local)
{
    ExecutionContext? current = ._executionContext;
    if (current == null)
    {
        return null;
    }
    (!);
    (current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
    current.m_localValues.TryGetValue(local, out object? value);
    return value;
}

class Program
{
    static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "AsyncLocal saved data";
        new Thread(() =>
        {
            ($"new Thread: {_asyncLocal.Value}");
        })
        {
            IsBackground = true
        }.Start();
        (_ =>
        {
            ($": {_asyncLocal.Value}");
        });
        (() =>
        {
            ($": {_asyncLocal.Value}");
        });
        await (100);
        ($"after await: {_asyncLocal.Value}");
    }
}

class Program
{
    static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "AsyncLocal saved data";
        ("default:");
        PrintAsync(); // Without await, the subsequent thread will not be switched        (1000); // Make sure that all threads in the above method are executed        ();
        ("SuppressFlow：");
        PrintAsync();
        (1000);
        ("RestoreFlow：");
        ();
        await PrintAsync();
        ();
    }
    static async ValueTask PrintAsync()
    {
        new Thread(() =>
        {
            ($"    new Thread: {_asyncLocal.Value}");
        })
        {
            IsBackground = true
        }.Start();
        (100); // Ensure the output order        (_ =>
        {
            ($"    : {_asyncLocal.Value}");
        });
        (100);
        (() =>
        {
            ($"    : {_asyncLocal.Value}");
        });
        await (100);
        ($"    after await: {_asyncLocal.Value}");
        ();
    }
}

class Program
{
    static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static void Main(string[] args)
    {
        _asyncLocal.Value = "A => B";
        ();
        new Thread((() =>
        {
            ($"ThreadB：{_asyncLocal.Value}"); // Output thread B:            _asyncLocal.Value = "B => C";
            new Thread((() =>
            {
                ($"ThreadC：{_asyncLocal.Value}"); // Output thread C: B => C            }))
            {
                IsBackground = true
            }.Start();
        }))
        {
            IsBackground = true
        }.Start();
        ();
    }
}

public static void Run(ExecutionContext executionContext, ContextCallback callback, object? state)
{
    if (executionContext == null)
    {
        ThrowNullContext();
    }
	// The RestoreChangedContextToThread method will be called internally    RunInternal(executionContext, callback, state);
}

internal static void RestoreChangedContextToThread(Thread currentThread, ExecutionContext? contextToRestore, ExecutionContext? currentContext)
{
    (currentThread == );
    (contextToRestore != currentContext);
	// Assign the previous ExecutionContext to the current thread here    currentThread._executionContext = contextToRestore;
    if ((currentContext != null && ) ||
        (contextToRestore != null && ))
    {
        OnValuesChanged(currentContext, contextToRestore);
    }
}

        public void Start()
        {
#if FEATURE_COMINTEROP_APARTMENT_SUPPORT
            // Eagerly initialize the COM Apartment state of the thread if we're allowed to.
            StartupSetApartmentStateInternal();
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
            // Attach current thread's security principal object to the new
            // thread. Be careful not to bind the current thread to a principal
            // if it's not already bound.
            if (_delegate != null)
            {
                // If we reach here with a null delegate, something is broken. But we'll let the StartInternal method take care of
                // reporting an error. Just make sure we don't try to dereference a null delegate.
                (_delegate.Target is ThreadHelper);
                // Since _delegate points to the instance method of ThreadHelper, _delegate.Target points to the ThreadHelper instance.                var t = (ThreadHelper)_delegate.Target;
                ExecutionContext? ec = ();
                (ec);
            }
            StartInternal();
        }

class ThreadHelper
{
    internal ThreadHelper(Delegate start)
    {
        _start = start;
    }
    internal void SetExecutionContextHelper(ExecutionContext? ec)
    {
        _executionContext = ec;
    }
    // This method is to wrap the delegate passed in by the Thread constructor    internal void ThreadStart()
    {
        (_start is ThreadStart);
        ExecutionContext? context = _executionContext;
        if (context != null)
        {
			// Bind the ExecutionContext with CurrentThread            (context, s_threadStartContextCallback, this);
        }
        else
        {
            InitializeCulture();
            ((ThreadStart)_start)();
        }
    }
}