diff --git a/src/Libraries/Microsoft.AspNetCore.AsyncState/AsyncStateHttpContextExtensions.cs b/src/Libraries/Microsoft.AspNetCore.AsyncState/AsyncStateHttpContextExtensions.cs index 6c289c96f77..d9141dbf83e 100644 --- a/src/Libraries/Microsoft.AspNetCore.AsyncState/AsyncStateHttpContextExtensions.cs +++ b/src/Libraries/Microsoft.AspNetCore.AsyncState/AsyncStateHttpContextExtensions.cs @@ -16,6 +16,7 @@ public static class AsyncStateHttpContextExtensions /// /// Adds default implementations for , , and services, /// scoped to the lifetime of instances. + /// Please note that implementations of these interfaces are not thread safe. /// /// The to add the service to. /// The value of . diff --git a/src/Libraries/Microsoft.AspNetCore.AsyncState/README.md b/src/Libraries/Microsoft.AspNetCore.AsyncState/README.md index d5bc4f0a353..5bce6aa3a99 100644 --- a/src/Libraries/Microsoft.AspNetCore.AsyncState/README.md +++ b/src/Libraries/Microsoft.AspNetCore.AsyncState/README.md @@ -4,6 +4,9 @@ This provides the ability to store and retrieve state objects that flow with the The lifetime of the shared data is controlled automatically and will be the same as of `HttpContext`. +> [!NOTE] +> Please note, the implementation of `IAsyncContext` provided by this library is not thread-safe. + ## Install the package From the command-line: diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/AsyncState.cs b/src/Libraries/Microsoft.Extensions.AsyncState/AsyncState.cs index 9fc79930954..4d782409238 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/AsyncState.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/AsyncState.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections.Generic; using System.Threading; using Microsoft.Extensions.ObjectPool; using Microsoft.Shared.Diagnostics; @@ -12,7 +13,7 @@ namespace Microsoft.Extensions.AsyncState; internal sealed class AsyncState : IAsyncState { private static readonly AsyncLocal _asyncContextCurrent = new(); - private static readonly ObjectPool _featuresPool = PoolFactory.CreatePool(new FeaturesPooledPolicy()); + private static readonly ObjectPool> _featuresPool = PoolFactory.CreatePool(new FeaturesPooledPolicy()); private int _contextCount; public void Initialize() @@ -21,12 +22,12 @@ public void Initialize() // Use an object indirection to hold the AsyncContext in the AsyncLocal, // so it can be cleared in all ExecutionContexts when its cleared. - var asyncStateHolder = new AsyncStateHolder + var features = new AsyncStateHolder { Features = _featuresPool.Get() }; - _asyncContextCurrent.Value = asyncStateHolder; + _asyncContextCurrent.Value = features; } public void Reset() @@ -59,7 +60,9 @@ public bool TryGet(AsyncStateToken token, out object? value) return false; } - value = _asyncContextCurrent.Value.Features.Get(token.Index); + EnsureCount(_asyncContextCurrent.Value.Features, token.Index + 1); + + value = _asyncContextCurrent.Value.Features[token.Index]; return true; } @@ -83,14 +86,28 @@ public void Set(AsyncStateToken token, object? value) Throw.InvalidOperationException("Context is not initialized"); } - _asyncContextCurrent.Value.Features.Set(token.Index, value); + EnsureCount(_asyncContextCurrent.Value.Features, token.Index + 1); + + _asyncContextCurrent.Value.Features[token.Index] = value; + } + + internal static void EnsureCount(List features, int count) + { +#if NET6_0_OR_GREATER + features.EnsureCapacity(count); +#endif + var difference = count - features.Count; + + for (int i = 0; i < difference; i++) + { + features.Add(null); + } } internal int ContextCount => Volatile.Read(ref _contextCount); private sealed class AsyncStateHolder { - public Features? Features { get; set; } + public List? Features { get; set; } } - } diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/AsyncStateExtensions.cs b/src/Libraries/Microsoft.Extensions.AsyncState/AsyncStateExtensions.cs index 9baabc82d3a..a25a8156b1a 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/AsyncStateExtensions.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/AsyncStateExtensions.cs @@ -15,6 +15,7 @@ public static class AsyncStateExtensions { /// /// Adds default implementations for , , and services. + /// Please note that implementations of these interfaces are not thread safe. /// /// The dependency injection container to add the implementations to. /// The value of . diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/Features.cs b/src/Libraries/Microsoft.Extensions.AsyncState/Features.cs deleted file mode 100644 index 940efa69c26..00000000000 --- a/src/Libraries/Microsoft.Extensions.AsyncState/Features.cs +++ /dev/null @@ -1,45 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; - -namespace Microsoft.Extensions.AsyncState; - -internal sealed class Features -{ - private readonly List _items = []; - - public object? Get(int index) - { - return _items.Count <= index ? null : _items[index]; - } - - public void Set(int index, object? value) - { - if (_items.Count <= index) - { - lock (_items) - { - var count = index + 1; - -#if NET6_0_OR_GREATER - _items.EnsureCapacity(count); -#endif - - var difference = count - _items.Count; - - for (int i = 0; i < difference; i++) - { - _items.Add(null); - } - } - } - - _items[index] = value; - } - - public void Clear() - { - _items.Clear(); - } -} diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/FeaturesPooledPolicy.cs b/src/Libraries/Microsoft.Extensions.AsyncState/FeaturesPooledPolicy.cs index 6c6f442c817..3b045465595 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/FeaturesPooledPolicy.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/FeaturesPooledPolicy.cs @@ -1,22 +1,27 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Collections.Generic; using Microsoft.Extensions.ObjectPool; namespace Microsoft.Extensions.AsyncState; -internal sealed class FeaturesPooledPolicy : IPooledObjectPolicy +internal sealed class FeaturesPooledPolicy : IPooledObjectPolicy> { /// - public Features Create() + public List Create() { - return new Features(); + return []; } /// - public bool Return(Features obj) + public bool Return(List obj) { - obj.Clear(); + for (int i = 0; i < obj.Count; i++) + { + obj[i] = null; + } + return true; } } diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncContext.cs b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncContext.cs index f1c07ee94f8..aef151f3016 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncContext.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncContext.cs @@ -8,6 +8,7 @@ namespace Microsoft.Extensions.AsyncState; /// /// Provides access to the current async context. +/// Some implementations of this interface may not be thread safe. /// /// The type of the asynchronous state. [SuppressMessage("Naming", "CA1716:Identifiers should not match keywords", Justification = "Getter and setter throw exceptions.")] diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncLocalContext.cs b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncLocalContext.cs index 746909d1b8c..9873375a78b 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncLocalContext.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncLocalContext.cs @@ -7,6 +7,7 @@ namespace Microsoft.Extensions.AsyncState; /// /// Provides access to the current async context stored outside of the HTTP pipeline. +/// Some implementations of this interface may not be thread safe. /// /// The type of the asynchronous state. /// This type is intended for internal use. Use instead. diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncState.cs b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncState.cs index 960d6672967..ec15b72c2c9 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncState.cs +++ b/src/Libraries/Microsoft.Extensions.AsyncState/IAsyncState.cs @@ -9,6 +9,7 @@ namespace Microsoft.Extensions.AsyncState; /// /// Encapsulates all information within the asynchronous flow in an variable. +/// Some implementations of this interface may not be thread safe. /// [SuppressMessage("Naming", "CA1716:Identifiers should not match keywords", Justification = "Getter and setter throw exceptions.")] public interface IAsyncState diff --git a/src/Libraries/Microsoft.Extensions.AsyncState/README.md b/src/Libraries/Microsoft.Extensions.AsyncState/README.md index a58555d0389..46a0c434d61 100644 --- a/src/Libraries/Microsoft.Extensions.AsyncState/README.md +++ b/src/Libraries/Microsoft.Extensions.AsyncState/README.md @@ -1,12 +1,14 @@ # Microsoft.Extensions.AsyncState This provides the ability to store and retrieve objects that flow with the current asynchronous context. - It has a few advantages over using the [`AsyncLocal`](https://learn.microsoft.com/dotnet/api/system.threading.asynclocal-1) class directly: - By abstracting the way the ambient data is stored we can use more optimized implementations, for instance when using ASP.NET Core, without exposing these components. - Improves the performance by minimizing the number of `AsyncLocal` instances required when multiple objects are shared. - Provides a way to manage the lifetime of the ambient data objects. +> [!NOTE] +> Please note, the implementations of `IAsyncState` and `IAsyncContext` are not thread-safe. + ## Install the package From the command-line: diff --git a/test/Libraries/Microsoft.Extensions.AsyncState.Tests/AsyncStateTests.cs b/test/Libraries/Microsoft.Extensions.AsyncState.Tests/AsyncStateTests.cs index e541ee04865..f7a7b050eb1 100644 --- a/test/Libraries/Microsoft.Extensions.AsyncState.Tests/AsyncStateTests.cs +++ b/test/Libraries/Microsoft.Extensions.AsyncState.Tests/AsyncStateTests.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading; using System.Threading.Tasks; @@ -204,4 +205,28 @@ public void RegisterContextCorrectly() Assert.Equal(3, asyncState.ContextCount); } + + [Fact] + public void EnsureCount_IncreasesCountCorrectly() + { + var l = new List(); + AsyncState.EnsureCount(l, 5); + Assert.Equal(5, l.Count); + } + + [Fact] + public void EnsureCount_WhenCountLessThanExpected() + { + var l = new List(new object?[5]); + AsyncState.EnsureCount(l, 2); + Assert.Equal(5, l.Count); + } + + [Fact] + public void EnsureCount_WhenCountEqualWithExpected() + { + var l = new List(new object?[5]); + AsyncState.EnsureCount(l, 5); + Assert.Equal(5, l.Count); + } } diff --git a/test/Libraries/Microsoft.Extensions.AsyncState.Tests/FeaturesPooledPolicyTests.cs b/test/Libraries/Microsoft.Extensions.AsyncState.Tests/FeaturesPooledPolicyTests.cs index 6e360789cd9..909389acb95 100644 --- a/test/Libraries/Microsoft.Extensions.AsyncState.Tests/FeaturesPooledPolicyTests.cs +++ b/test/Libraries/Microsoft.Extensions.AsyncState.Tests/FeaturesPooledPolicyTests.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections.Generic; using Xunit; namespace Microsoft.Extensions.AsyncState.Test; @@ -12,7 +13,7 @@ public void Return_ShouldBeTrue() { var policy = new FeaturesPooledPolicy(); - Assert.True(policy.Return(new Features())); + Assert.True(policy.Return([])); } [Fact] @@ -20,14 +21,12 @@ public void Return_ShouldNullList() { var policy = new FeaturesPooledPolicy(); - var features = policy.Create(); - features.Set(0, string.Empty); - features.Set(1, Array.Empty()); - features.Set(2, new object()); + var list = policy.Create(); + list.Add(string.Empty); + list.Add(Array.Empty()); + list.Add(new object()); - Assert.True(policy.Return(features)); - Assert.Null(features.Get(0)); - Assert.Null(features.Get(1)); - Assert.Null(features.Get(2)); + Assert.True(policy.Return(list)); + Assert.All(list, el => Assert.Null(el)); } }