From 3106bbd4bb418a7c4aa5ab94179fa8c0bc0f6148 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 15:55:08 -0300 Subject: [PATCH 01/16] feat: rewrite CacheAttribute as stateless async filter with pooled buffers Fixes cross-request race condition (shared attribute instance held per-request state), the non-compiling HEAD, sync-over-async, the max-age Seconds/TotalSeconds bug, and Headers.Clear() wiping middleware headers. Adds IBufferDistributedCache fast path, LOH-safe MaxPayloadBytes default, and fail-open cache error handling. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- AspNet.Cache/AspNet.Cache.csproj | 43 ++- AspNet.Cache/AspNetCacheOptions.cs | 23 ++ AspNet.Cache/CacheAttribute.cs | 267 +++++++++++++----- AspNet.Cache/Internal/CacheKeyBuilder.cs | 94 ++++++ AspNet.Cache/Internal/CacheLog.cs | 15 + AspNet.Cache/Internal/CachedJsonResult.cs | 36 +++ .../Internal/PooledArrayBufferWriter.cs | 74 +++++ .../Internal/PooledCachedJsonResult.cs | 41 +++ AspNet.Cache/Internal/SerializerDefaults.cs | 8 + AspNet.Cache/TimeSpanType.cs | 18 +- 10 files changed, 523 insertions(+), 96 deletions(-) create mode 100644 AspNet.Cache/AspNetCacheOptions.cs create mode 100644 AspNet.Cache/Internal/CacheKeyBuilder.cs create mode 100644 AspNet.Cache/Internal/CacheLog.cs create mode 100644 AspNet.Cache/Internal/CachedJsonResult.cs create mode 100644 AspNet.Cache/Internal/PooledArrayBufferWriter.cs create mode 100644 AspNet.Cache/Internal/PooledCachedJsonResult.cs create mode 100644 AspNet.Cache/Internal/SerializerDefaults.cs diff --git a/AspNet.Cache/AspNet.Cache.csproj b/AspNet.Cache/AspNet.Cache.csproj index 0aa8008..9aa692b 100644 --- a/AspNet.Cache/AspNet.Cache.csproj +++ b/AspNet.Cache/AspNet.Cache.csproj @@ -1,17 +1,42 @@ - + - netstandard2.1 + net8.0 + latest + enable + enable + true + latest-recommended + true + true + + + + AspNet.Cache + 2.0.0 + slipalison + Declarative response caching for ASP.NET Core MVC actions on top of any IDistributedCache provider (Redis, SQL Server, in-memory, MongoDB). Allocation-conscious: span-based key generation, pooled buffers, IBufferDistributedCache fast path, LOH-free by default. + aspnetcore;cache;caching;idistributedcache;redis;actionfilter;performance;response-cache https://github.com/slipalison/AspNet.Cache https://github.com/slipalison/AspNet.Cache - 1.0.0 - slipalison + git + MIT + README.md + true + true + true + snupkg - - - - + + - \ No newline at end of file + + + + + + + + diff --git a/AspNet.Cache/AspNetCacheOptions.cs b/AspNet.Cache/AspNetCacheOptions.cs new file mode 100644 index 0000000..126b25c --- /dev/null +++ b/AspNet.Cache/AspNetCacheOptions.cs @@ -0,0 +1,23 @@ +using System; +using System.Text.Json; + +namespace AspNet.Cache; + +/// Global options for . Configure via services.Configure<AspNetCacheOptions>(...). +public sealed class AspNetCacheOptions +{ + internal static readonly AspNetCacheOptions FallbackDefaults = new(); + + /// Serializer options used when hashing action arguments into the cache key. Defaults to web defaults. + public JsonSerializerOptions? KeySerializerOptions { get; set; } + + /// Serializer options for the cached payload. Defaults to the app's MVC JSON options, then web defaults. + public JsonSerializerOptions? PayloadSerializerOptions { get; set; } + + /// Responses whose serialized size exceeds this many bytes are not cached. Default keeps entries off the Large Object Heap. + public int MaxPayloadBytes { get; set; } = 84_000; + + /// Predicate deciding which action arguments are excluded from the cache key. + public Func IgnoreArgument { get; set; } = + static name => name.Contains("correlationid", StringComparison.OrdinalIgnoreCase); +} diff --git a/AspNet.Cache/CacheAttribute.cs b/AspNet.Cache/CacheAttribute.cs index acd95b9..dbf5cfa 100644 --- a/AspNet.Cache/CacheAttribute.cs +++ b/AspNet.Cache/CacheAttribute.cs @@ -1,105 +1,216 @@ -using System; -using System.Collections.Generic; -using System.Linq; +using System; +using System.Buffers; +using System.Globalization; using System.Net; -using System.Text; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using AspNet.Cache.Internal; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.Extensions.Caching.Distributed; -using Newtonsoft.Json; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; -namespace AspNet.Cache +namespace AspNet.Cache; + +/// +/// Caches the JSON payload of a successful action result in the registered . +/// When the provider implements , reads and writes flow through pooled +/// buffers and never materialize a per-request byte array. +/// The attribute instance is shared across concurrent requests and therefore holds no per-request state. +/// +[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] +public sealed class CacheAttribute : ActionFilterAttribute { - [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] - public sealed class CacheAttribute : ActionFilterAttribute + private string? _cacheControlHeaderValue; + private DistributedCacheEntryOptions? _entryOptions; + + /// Optional key prefix ("folder") prepended to every cache key. + public string Folder { get; set; } = string.Empty; + + /// Expiration amount, interpreted according to . Default: 10. + public long ExpireAt { get; set; } = 10; + + /// Unit for . Default: minutes. + public TimeSpanType TimeSpanType { get; set; } = TimeSpanType.FromMinutes; + + /// Status code that marks a response as cacheable and is replayed on cache hits. Default: 200 OK. + public HttpStatusCode SuccessStatus { get; set; } = HttpStatusCode.OK; + + /// + public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) { - private static readonly IList<(TimeSpanType TimeSpanType, Func TimeSpanFrom)> - _timeSpanTypeList = - new List<(TimeSpanType TimeSpanType, Func TimeSpanFrom)> - { - (TimeSpanType.FromMinutes, TimeSpan.FromMinutes), - (TimeSpanType.FromMilliseconds, TimeSpan.FromMilliseconds), - (TimeSpanType.FromDays, TimeSpan.FromDays), - (TimeSpanType.FromHours, TimeSpan.FromHours), - (TimeSpanType.FromSeconds, TimeSpan.FromSeconds) - }; - - private IDistributedCache _cache; - private string _hashKey = string.Empty; - private bool _isCach; - private string _path = string.Empty; - - public string Folder { get; set; } = string.Empty; - public long ExpireAt { get; set; } = 10; - public TimeSpanType TimeSpanType { get; set; } = TimeSpanType.FromMinutes; - public HttpStatusCode SuccessStatus { get; set; } = HttpStatusCode.OK; - - public override void OnActionExecuting(ActionExecutingContext context) + ArgumentNullException.ThrowIfNull(context); + ArgumentNullException.ThrowIfNull(next); + + var services = context.HttpContext.RequestServices; + var cache = services.GetService(); + if (cache is null) { - _cache = (IDistributedCache) context.HttpContext.RequestServices.GetService(typeof(IDistributedCache)); - if (context.HttpContext.Request.Path.HasValue) - _path = context.HttpContext.Request.Path.Value; - - var body = JsonConvert.SerializeObject(context.ActionArguments.Where(x => - !x.Key.Contains("correlationid", StringComparison.InvariantCultureIgnoreCase))); - var separotor = string.IsNullOrWhiteSpace(Folder) ? string.Empty : ":"; - _hashKey = - $"{Folder}{separotor}{string.Join("-", _path.Replace("/", "-"), GetStringSha256Hash(body))}"; - var existingData = _cache.GetString(_hashKey); - if (string.IsNullOrEmpty(existingData)) + await next().ConfigureAwait(false); + return; + } + + var options = services.GetService>()?.Value ?? AspNetCacheOptions.FallbackDefaults; + var key = CacheKeyBuilder.Build(Folder, context.HttpContext.Request.Path.Value, context.ActionArguments, + options.IgnoreArgument, options.KeySerializerOptions ?? SerializerDefaults.Web); + + var cancellationToken = context.HttpContext.RequestAborted; + var hitResult = cache is IBufferDistributedCache bufferedCache + ? await TryServeBufferedAsync(bufferedCache, key, services, cancellationToken).ConfigureAwait(false) + : await TryServeLegacyAsync(cache, key, services, cancellationToken).ConfigureAwait(false); + + if (hitResult is not null) + { + context.HttpContext.Response.Headers.CacheControl = GetCacheControlHeaderValue(); + context.Result = hitResult; + return; + } + + var executed = await next().ConfigureAwait(false); + if (executed.Exception is not null || executed.Canceled) + return; + + await StoreAsync(cache, key, executed.Result, services, options).ConfigureAwait(false); + } + + private async Task TryServeBufferedAsync(IBufferDistributedCache cache, string key, + IServiceProvider services, CancellationToken cancellationToken) + { + var buffer = new PooledArrayBufferWriter(); + try + { + var found = await cache.TryGetAsync(key, buffer, cancellationToken).ConfigureAwait(false); + if (!found || buffer.WrittenCount == 0) { - _isCach = false; - base.OnActionExecuting(context); + buffer.Dispose(); + return null; } - else + + if (CachedJsonResult.IsEmptyMarker(buffer.WrittenSpan)) { - _isCach = true; - context.HttpContext.Response.StatusCode = (int) SuccessStatus; - context.HttpContext.Response.Headers.Clear(); - context.HttpContext.Response.Headers.Add("Cache-Control", - new StringValues($"max-age={GetTimeSpan().Seconds}")); - if (string.IsNullOrEmpty(existingData)) return; - if ("Empty" == existingData) - context.Result = new StatusCodeResult((int) SuccessStatus); - else - context.Result = new JsonResult(JsonConvert.DeserializeObject(existingData)); + buffer.Dispose(); + return new StatusCodeResult((int)SuccessStatus); } + + return new PooledCachedJsonResult(buffer, (int)SuccessStatus); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + buffer.Dispose(); + throw; + } + catch (Exception exception) + { + buffer.Dispose(); + CacheLog.GetFailed(ResolveLogger(services), exception); + return null; + } + } + + private async Task TryServeLegacyAsync(IDistributedCache cache, string key, + IServiceProvider services, CancellationToken cancellationToken) + { + byte[]? cached = null; + try + { + cached = await cache.GetAsync(key, cancellationToken).ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch (Exception exception) + { + CacheLog.GetFailed(ResolveLogger(services), exception); } - public override void OnResultExecuted(ResultExecutedContext context) + if (cached is not { Length: > 0 }) + return null; + + return CachedJsonResult.IsEmptyMarker(cached) + ? new StatusCodeResult((int)SuccessStatus) + : new CachedJsonResult(cached, (int)SuccessStatus); + } + + private async Task StoreAsync(IDistributedCache cache, string key, IActionResult? result, + IServiceProvider services, AspNetCacheOptions options) + { + if (result is ObjectResult { Value: not null } objectResult && MatchesSuccessStatus(objectResult.StatusCode)) { - if (!_isCach && context.HttpContext.Response.StatusCode == (int) SuccessStatus) + var payloadOptions = options.PayloadSerializerOptions + ?? services.GetService>()?.Value.JsonSerializerOptions + ?? SerializerDefaults.Web; + + using var buffer = new PooledArrayBufferWriter(options.MaxPayloadBytes); + using (var writer = new Utf8JsonWriter(buffer)) + { + JsonSerializer.Serialize(writer, objectResult.Value, objectResult.Value.GetType(), payloadOptions); + } + + if (buffer.Overflowed) + return; + + try { - switch (context.Result) + // CancellationToken.None: a client disconnect after the action ran must not discard the produced entry. + if (cache is IBufferDistributedCache bufferedCache) { - case ObjectResult {Value: { }} result: - _cache.SetString(_hashKey, JsonConvert.SerializeObject(result.Value), - new DistributedCacheEntryOptions {AbsoluteExpirationRelativeToNow = GetTimeSpan()}); - break; - case StatusCodeResult _: - _cache.SetString(_hashKey, "Empty", - new DistributedCacheEntryOptions {AbsoluteExpirationRelativeToNow = GetTimeSpan()}); - break; + await bufferedCache.SetAsync(key, new ReadOnlySequence(buffer.WrittenMemory), + GetEntryOptions(), CancellationToken.None).ConfigureAwait(false); } + else + { + var payload = buffer.WrittenSpan.ToArray(); + await cache.SetAsync(key, payload, GetEntryOptions(), CancellationToken.None).ConfigureAwait(false); + } + } + catch (Exception exception) + { + CacheLog.SetFailed(ResolveLogger(services), exception); } - base.OnResultExecuted(context); + return; } - private TimeSpan GetTimeSpan() + if (result is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == (int)SuccessStatus) { - return _timeSpanTypeList.FirstOrDefault(x => x.TimeSpanType == TimeSpanType).TimeSpanFrom.Invoke(ExpireAt); + try + { + await cache.SetAsync(key, CachedJsonResult.EmptyMarker, GetEntryOptions(), CancellationToken.None) + .ConfigureAwait(false); + } + catch (Exception exception) + { + CacheLog.SetFailed(ResolveLogger(services), exception); + } } + } - private static string GetStringSha256Hash(string text) - { - if (string.IsNullOrWhiteSpace(text)) - return string.Empty; + private bool MatchesSuccessStatus(int? statusCode) => + (statusCode ?? (int)HttpStatusCode.OK) == (int)SuccessStatus; - using var sha = new SHA256Managed(); - var textData = Encoding.UTF8.GetBytes(text); - var hash = sha.ComputeHash(textData); - return BitConverter.ToString(hash).Replace("-", string.Empty); - } - } + private TimeSpan GetExpiration() => TimeSpanType switch + { + TimeSpanType.FromMilliseconds => TimeSpan.FromMilliseconds(ExpireAt), + TimeSpanType.FromSeconds => TimeSpan.FromSeconds(ExpireAt), + TimeSpanType.FromHours => TimeSpan.FromHours(ExpireAt), + TimeSpanType.FromDays => TimeSpan.FromDays(ExpireAt), + _ => TimeSpan.FromMinutes(ExpireAt) + }; + + private string GetCacheControlHeaderValue() => + // Benign race: concurrent first requests compute the same value; last write wins. + _cacheControlHeaderValue ??= string.Create(CultureInfo.InvariantCulture, + $"max-age={(long)GetExpiration().TotalSeconds}"); + + private DistributedCacheEntryOptions GetEntryOptions() => + // Benign race: same value on every compute; providers treat the instance as read-only. + _entryOptions ??= new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = GetExpiration() }; + + private static ILogger ResolveLogger(IServiceProvider services) => + services.GetService>() ?? NullLogger.Instance; } diff --git a/AspNet.Cache/Internal/CacheKeyBuilder.cs b/AspNet.Cache/Internal/CacheKeyBuilder.cs new file mode 100644 index 0000000..76238dc --- /dev/null +++ b/AspNet.Cache/Internal/CacheKeyBuilder.cs @@ -0,0 +1,94 @@ +using System; +using System.Buffers; +using System.Collections.Generic; +using System.Security.Cryptography; +using System.Text.Json; + +namespace AspNet.Cache.Internal; + +/// Builds the cache key: {Folder}:{path with '/' replaced by '-'}-{SHA256 hex of the JSON of the action arguments}. +internal static class CacheKeyBuilder +{ + private const int HashSize = 32; + private const int HexLength = HashSize * 2; + private const int StackallocCharThreshold = 256; + private const string HexDigits = "0123456789ABCDEF"; + + public static string Build(string folder, string? path, IDictionary arguments, + Func ignoreArgument, JsonSerializerOptions keySerializerOptions) + { + Span hash = stackalloc byte[HashSize]; + HashArguments(arguments, ignoreArgument, keySerializerOptions, hash); + + var pathSpan = path.AsSpan(); + var prefixLength = folder.Length == 0 ? 0 : folder.Length + 1; + var totalLength = prefixLength + pathSpan.Length + 1 + HexLength; + + char[]? rented = null; + Span destination = totalLength <= StackallocCharThreshold + ? stackalloc char[StackallocCharThreshold] + : rented = ArrayPool.Shared.Rent(totalLength); + + var position = 0; + if (prefixLength != 0) + { + folder.CopyTo(destination); + position = folder.Length; + destination[position++] = ':'; + } + + foreach (var character in pathSpan) + destination[position++] = character == '/' ? '-' : character; + + destination[position++] = '-'; + WriteUpperHex(hash, destination.Slice(position, HexLength)); + position += HexLength; + + var key = new string(destination[..position]); + if (rented is not null) + ArrayPool.Shared.Return(rented); + return key; + } + + private static void HashArguments(IDictionary arguments, Func ignoreArgument, + JsonSerializerOptions serializerOptions, Span destination) + { + using var buffer = new PooledArrayBufferWriter(); + using (var writer = new Utf8JsonWriter(buffer)) + { + writer.WriteStartObject(); + if (arguments is Dictionary concrete) + { + foreach (var pair in concrete) + WriteArgument(writer, pair.Key, pair.Value, ignoreArgument, serializerOptions); + } + else + { + foreach (var pair in arguments) + WriteArgument(writer, pair.Key, pair.Value, ignoreArgument, serializerOptions); + } + + writer.WriteEndObject(); + } + + SHA256.HashData(buffer.WrittenSpan, destination); + } + + private static void WriteArgument(Utf8JsonWriter writer, string name, object? value, + Func ignoreArgument, JsonSerializerOptions serializerOptions) + { + if (ignoreArgument(name)) + return; + writer.WritePropertyName(name); + JsonSerializer.Serialize(writer, value, value?.GetType() ?? typeof(object), serializerOptions); + } + + private static void WriteUpperHex(ReadOnlySpan source, Span destination) + { + for (var i = 0; i < source.Length; i++) + { + destination[i * 2] = HexDigits[source[i] >> 4]; + destination[i * 2 + 1] = HexDigits[source[i] & 0xF]; + } + } +} diff --git a/AspNet.Cache/Internal/CacheLog.cs b/AspNet.Cache/Internal/CacheLog.cs new file mode 100644 index 0000000..01f3380 --- /dev/null +++ b/AspNet.Cache/Internal/CacheLog.cs @@ -0,0 +1,15 @@ +using System; +using Microsoft.Extensions.Logging; + +namespace AspNet.Cache.Internal; + +internal static partial class CacheLog +{ + [LoggerMessage(EventId = 1, Level = LogLevel.Warning, + Message = "AspNet.Cache: distributed cache read failed; the request continues without cache.")] + public static partial void GetFailed(ILogger logger, Exception exception); + + [LoggerMessage(EventId = 2, Level = LogLevel.Warning, + Message = "AspNet.Cache: distributed cache write failed; the response was served but not cached.")] + public static partial void SetFailed(ILogger logger, Exception exception); +} diff --git a/AspNet.Cache/Internal/CachedJsonResult.cs b/AspNet.Cache/Internal/CachedJsonResult.cs new file mode 100644 index 0000000..ccff79a --- /dev/null +++ b/AspNet.Cache/Internal/CachedJsonResult.cs @@ -0,0 +1,36 @@ +using System; +using System.Threading.Tasks; +using Microsoft.AspNetCore.Mvc; + +namespace AspNet.Cache.Internal; + +/// Writes a cached UTF-8 JSON payload straight to the response body, without re-deserializing it. +internal sealed class CachedJsonResult : IActionResult +{ + internal static readonly byte[] EmptyMarker = "Empty"u8.ToArray(); + + private const string JsonContentType = "application/json; charset=utf-8"; + + private readonly byte[] _payload; + private readonly int _statusCode; + + public CachedJsonResult(byte[] payload, int statusCode) + { + _payload = payload; + _statusCode = statusCode; + } + + public async Task ExecuteResultAsync(ActionContext context) + { + ArgumentNullException.ThrowIfNull(context); + var response = context.HttpContext.Response; + response.StatusCode = _statusCode; + response.ContentType = JsonContentType; + response.ContentLength = _payload.Length; + await response.BodyWriter.WriteAsync(_payload, context.HttpContext.RequestAborted).ConfigureAwait(false); + } + + internal static bool IsEmptyMarker(byte[] payload) => IsEmptyMarker(payload.AsSpan()); + + internal static bool IsEmptyMarker(ReadOnlySpan payload) => payload.SequenceEqual(EmptyMarker); +} diff --git a/AspNet.Cache/Internal/PooledArrayBufferWriter.cs b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs new file mode 100644 index 0000000..e140e66 --- /dev/null +++ b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs @@ -0,0 +1,74 @@ +using System; +using System.Buffers; + +namespace AspNet.Cache.Internal; + +/// +/// backed by . Single-threaded, per-request use only. +/// +internal sealed class PooledArrayBufferWriter : IBufferWriter, IDisposable +{ + private const int DefaultInitialCapacity = 4096; + + private byte[] _buffer; + private int _written; + private readonly int _softLimit; + + public PooledArrayBufferWriter(int softLimit = int.MaxValue, int initialCapacity = DefaultInitialCapacity) + { + _buffer = ArrayPool.Shared.Rent(initialCapacity); + _softLimit = softLimit; + } + + /// True when more than the configured soft limit has been written; the caller must discard the content. + public bool Overflowed => _written > _softLimit; + + public ReadOnlySpan WrittenSpan => _buffer.AsSpan(0, _written); + + public ReadOnlyMemory WrittenMemory => _buffer.AsMemory(0, _written); + + public int WrittenCount => _written; + + public void Advance(int count) + { + if (count < 0 || _written + count > _buffer.Length) + throw new ArgumentOutOfRangeException(nameof(count)); + _written += count; + } + + public Memory GetMemory(int sizeHint = 0) + { + EnsureCapacity(sizeHint); + return _buffer.AsMemory(_written); + } + + public Span GetSpan(int sizeHint = 0) + { + EnsureCapacity(sizeHint); + return _buffer.AsSpan(_written); + } + + public void Dispose() + { + var buffer = _buffer; + _buffer = Array.Empty(); + _written = 0; + if (buffer.Length > 0) + ArrayPool.Shared.Return(buffer); + } + + private void EnsureCapacity(int sizeHint) + { + if (sizeHint < 1) + sizeHint = 1; + if (_buffer.Length - _written >= sizeHint) + return; + + var newSize = Math.Max(_buffer.Length * 2, _written + sizeHint); + var next = ArrayPool.Shared.Rent(newSize); + _buffer.AsSpan(0, _written).CopyTo(next); + var previous = _buffer; + _buffer = next; + ArrayPool.Shared.Return(previous); + } +} diff --git a/AspNet.Cache/Internal/PooledCachedJsonResult.cs b/AspNet.Cache/Internal/PooledCachedJsonResult.cs new file mode 100644 index 0000000..0f75a8e --- /dev/null +++ b/AspNet.Cache/Internal/PooledCachedJsonResult.cs @@ -0,0 +1,41 @@ +using System; +using System.Threading.Tasks; +using Microsoft.AspNetCore.Mvc; + +namespace AspNet.Cache.Internal; + +/// +/// Writes a cached UTF-8 JSON payload held in a pooled buffer straight to the response body, +/// returning the buffer to the pool after the write completes. +/// +internal sealed class PooledCachedJsonResult : IActionResult +{ + private const string JsonContentType = "application/json; charset=utf-8"; + + private readonly PooledArrayBufferWriter _buffer; + private readonly int _statusCode; + + public PooledCachedJsonResult(PooledArrayBufferWriter buffer, int statusCode) + { + _buffer = buffer; + _statusCode = statusCode; + } + + public async Task ExecuteResultAsync(ActionContext context) + { + ArgumentNullException.ThrowIfNull(context); + try + { + var response = context.HttpContext.Response; + response.StatusCode = _statusCode; + response.ContentType = JsonContentType; + response.ContentLength = _buffer.WrittenCount; + await response.BodyWriter.WriteAsync(_buffer.WrittenMemory, context.HttpContext.RequestAborted) + .ConfigureAwait(false); + } + finally + { + _buffer.Dispose(); + } + } +} diff --git a/AspNet.Cache/Internal/SerializerDefaults.cs b/AspNet.Cache/Internal/SerializerDefaults.cs new file mode 100644 index 0000000..e61b6cb --- /dev/null +++ b/AspNet.Cache/Internal/SerializerDefaults.cs @@ -0,0 +1,8 @@ +using System.Text.Json; + +namespace AspNet.Cache.Internal; + +internal static class SerializerDefaults +{ + internal static readonly JsonSerializerOptions Web = new(JsonSerializerDefaults.Web); +} diff --git a/AspNet.Cache/TimeSpanType.cs b/AspNet.Cache/TimeSpanType.cs index b3a257e..b8058d1 100644 --- a/AspNet.Cache/TimeSpanType.cs +++ b/AspNet.Cache/TimeSpanType.cs @@ -1,11 +1,11 @@ -namespace AspNet.Cache +namespace AspNet.Cache; + +/// Unit used to interpret . +public enum TimeSpanType { - public enum TimeSpanType - { - FromMinutes, - FromMilliseconds, - FromDays, - FromHours, - FromSeconds - } + FromMinutes, + FromMilliseconds, + FromDays, + FromHours, + FromSeconds } From 6a64d26422328df4af398e7e58dd020f1bbcd934 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:00:40 -0300 Subject: [PATCH 02/16] test: rewrite suite with concurrency regression and integration coverage Removes flaky timing-based v1 tests. Adds unit coverage for the stateless filter, key builder and pooled buffer writer; a 500-request concurrency regression for the fixed cross-request race; fail-open, cancellation, oversized payload and buffered-provider paths; and TestServer integration tests. Line coverage 96%, branch 92%. Test project targets net9.0 to match an installed runtime; the library under test stays net8.0. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .../AspNet.Cache.Test.csproj | 43 +- .../CacheAttributeCoverageTests.cs | 175 ++++ test/AspNet.Cache.Test/CacheAttributeTests.cs | 200 ++++ .../CacheIntegrationTests.cs | 86 ++ .../AspNet.Cache.Test/CacheKeyBuilderTests.cs | 76 ++ test/AspNet.Cache.Test/FaultyBufferCache.cs | 68 ++ .../AspNet.Cache.Test/FilterContextFactory.cs | 39 + test/AspNet.Cache.Test/InMemoryBufferCache.cs | 58 ++ .../PooledArrayBufferWriterTests.cs | 63 ++ .../Properties/launchSettings.json | 27 - test/AspNet.Cache.Test/UnitTest1.cs | 46 - .../WebServer/DefaultController.cs | 64 -- .../WebServer/StartTestServer.cs | 62 -- .../WebServer/StartupTest.cs | 35 - test/AspNet.Cache.Test/coverage.opencover.xml | 884 ++++++++++++++++++ 15 files changed, 1668 insertions(+), 258 deletions(-) create mode 100644 test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs create mode 100644 test/AspNet.Cache.Test/CacheAttributeTests.cs create mode 100644 test/AspNet.Cache.Test/CacheIntegrationTests.cs create mode 100644 test/AspNet.Cache.Test/CacheKeyBuilderTests.cs create mode 100644 test/AspNet.Cache.Test/FaultyBufferCache.cs create mode 100644 test/AspNet.Cache.Test/FilterContextFactory.cs create mode 100644 test/AspNet.Cache.Test/InMemoryBufferCache.cs create mode 100644 test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs delete mode 100644 test/AspNet.Cache.Test/Properties/launchSettings.json delete mode 100644 test/AspNet.Cache.Test/UnitTest1.cs delete mode 100644 test/AspNet.Cache.Test/WebServer/DefaultController.cs delete mode 100644 test/AspNet.Cache.Test/WebServer/StartTestServer.cs delete mode 100644 test/AspNet.Cache.Test/WebServer/StartupTest.cs create mode 100644 test/AspNet.Cache.Test/coverage.opencover.xml diff --git a/test/AspNet.Cache.Test/AspNet.Cache.Test.csproj b/test/AspNet.Cache.Test/AspNet.Cache.Test.csproj index f5f47ff..365ef61 100644 --- a/test/AspNet.Cache.Test/AspNet.Cache.Test.csproj +++ b/test/AspNet.Cache.Test/AspNet.Cache.Test.csproj @@ -1,35 +1,30 @@ - + - netcoreapp3.1 - + + net9.0 false + enable + enable + latest - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - + + + + + + + + + - \ No newline at end of file + + diff --git a/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs b/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs new file mode 100644 index 0000000..8eaa0f2 --- /dev/null +++ b/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs @@ -0,0 +1,175 @@ +using System.Net; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.Filters; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.DependencyInjection; +using NSubstitute; +using NSubstitute.ExceptionExtensions; +using Shouldly; +using Xunit; + +namespace AspNet.Cache.Test; + +public sealed class CacheAttributeCoverageTests +{ + private static ServiceProvider WithCache(IDistributedCache cache) + { + var services = new ServiceCollection(); + services.AddLogging(); + services.AddOptions(); + services.AddSingleton(cache); + return services.BuildServiceProvider(); + } + + [Theory] + [InlineData(TimeSpanType.FromMilliseconds, 5000, "max-age=5")] + [InlineData(TimeSpanType.FromSeconds, 90, "max-age=90")] + [InlineData(TimeSpanType.FromMinutes, 2, "max-age=120")] + [InlineData(TimeSpanType.FromHours, 2, "max-age=7200")] + [InlineData(TimeSpanType.FromDays, 1, "max-age=86400")] + public async Task Expiration_Unit_ProducesCorrectMaxAge(TimeSpanType unit, long expireAt, string expected) + { + await using var services = WithCache(new InMemoryBufferCache()); + var attribute = new CacheAttribute { ExpireAt = expireAt, TimeSpanType = unit }; + + var (first, _) = FilterContextFactory.Create(services, "/api/exp", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new ObjectResult(new Payload(1, "x")))); + + var (second, http) = FilterContextFactory.Create(services, "/api/exp", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new ObjectResult(new Payload(1, "x")))); + + second.Result.ShouldNotBeNull(); + http.Response.Headers.CacheControl.ToString().ShouldBe(expected); + } + + [Fact] + public async Task BufferedProvider_StatusCodeResult_CachedAsEmptyMarker_AndReplayed() + { + await using var services = WithCache(new InMemoryBufferCache()); + var attribute = new CacheAttribute(); + var executions = 0; + + var (first, _) = FilterContextFactory.Create(services, "/api/bempty", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new StatusCodeResult(200), () => executions++)); + + var (second, _) = FilterContextFactory.Create(services, "/api/bempty", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new StatusCodeResult(200), () => executions++)); + + executions.ShouldBe(1); + second.Result.ShouldBeOfType().StatusCode.ShouldBe(200); + } + + [Fact] + public async Task BufferedProvider_GetFailure_FailsOpen() + { + await using var services = WithCache(new FaultyBufferCache { OnGet = new InvalidOperationException("down") }); + var attribute = new CacheAttribute(); + var executions = 0; + + var (context, _) = FilterContextFactory.Create(services, "/api/bfail", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x")), () => executions++)); + + executions.ShouldBe(1); + context.Result.ShouldBeNull(); + } + + [Fact] + public async Task BufferedProvider_CanceledRequest_PropagatesOperationCanceled() + { + using var cts = new CancellationTokenSource(); + cts.Cancel(); + await using var services = WithCache(new FaultyBufferCache { OnGet = new OperationCanceledException(cts.Token) }); + var attribute = new CacheAttribute(); + + var (context, http) = FilterContextFactory.Create(services, "/api/bcancel", new() { ["id"] = 1 }); + http.RequestAborted = cts.Token; + + await Should.ThrowAsync(() => attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x"))))); + } + + [Fact] + public async Task BufferedProvider_SetFailure_FailsOpen() + { + await using var services = WithCache(new FaultyBufferCache { OnSet = new InvalidOperationException("down") }); + var attribute = new CacheAttribute(); + var executions = 0; + + var (context, _) = FilterContextFactory.Create(services, "/api/bsetfail", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x")), () => executions++)); + + executions.ShouldBe(1); + context.Result.ShouldBeNull(); + } + + [Fact] + public async Task StatusCodeResult_SetFailure_FailsOpen() + { + var failing = Substitute.For(); + failing.GetAsync(Arg.Any(), Arg.Any()).Returns((byte[]?)null); + failing.SetAsync(Arg.Any(), Arg.Any(), Arg.Any(), + Arg.Any()).ThrowsAsync(new InvalidOperationException("down")); + await using var services = WithCache(failing); + var attribute = new CacheAttribute(); + var executions = 0; + + var (context, _) = FilterContextFactory.Create(services, "/api/scodefail", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new StatusCodeResult(200), () => executions++)); + + executions.ShouldBe(1); + } + + [Fact] + public async Task ActionCanceled_IsNotCached() + { + await using var services = WithCache(new InMemoryBufferCache()); + var attribute = new CacheAttribute(); + var executions = 0; + + for (var i = 0; i < 2; i++) + { + var (context, _) = FilterContextFactory.Create(services, "/api/actcancel", new() { ["id"] = 1 }); + ActionExecutionDelegate next = () => + { + executions++; + return Task.FromResult(new ActionExecutedContext(context, new List(), new object()) + { + Canceled = true + }); + }; + await attribute.OnActionExecutionAsync(context, next); + } + + executions.ShouldBe(2); + } + + [Fact] + public async Task NoOptionsRegistered_UsesFallbackDefaults() + { + await using var services = new ServiceCollection() + .AddSingleton(new InMemoryBufferCache()) + .BuildServiceProvider(); + var attribute = new CacheAttribute(); + var executions = 0; + + var (first, _) = FilterContextFactory.Create(services, "/api/nodefaults", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new ObjectResult(new Payload(1, "x")), () => executions++)); + + var (second, _) = FilterContextFactory.Create(services, "/api/nodefaults", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new ObjectResult(new Payload(1, "x")), () => executions++)); + + executions.ShouldBe(1); + second.Result.ShouldNotBeNull(); + } + + private sealed record Payload(int Id, string Name); +} diff --git a/test/AspNet.Cache.Test/CacheAttributeTests.cs b/test/AspNet.Cache.Test/CacheAttributeTests.cs new file mode 100644 index 0000000..21bab69 --- /dev/null +++ b/test/AspNet.Cache.Test/CacheAttributeTests.cs @@ -0,0 +1,200 @@ +using System.Net; +using Microsoft.AspNetCore.Mvc; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.DependencyInjection; +using NSubstitute; +using NSubstitute.ExceptionExtensions; +using Shouldly; +using Xunit; + +namespace AspNet.Cache.Test; + +public sealed class CacheAttributeTests +{ + private static ServiceProvider BuildServices(Action? configure = null) + { + var services = new ServiceCollection(); + services.AddLogging(); + services.AddOptions(); + services.AddDistributedMemoryCache(); + configure?.Invoke(services); + return services.BuildServiceProvider(); + } + + [Fact] + public async Task MissThenHit_ServesCachedPayload_WithoutReexecutingAction() + { + await using var services = BuildServices(); + var attribute = new CacheAttribute(); + var executions = 0; + + var (first, _) = FilterContextFactory.Create(services, "/api/test", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new ObjectResult(new Payload(1, "fresh")), () => executions++)); + + executions.ShouldBe(1); + first.Result.ShouldBeNull(); + + var (second, http) = FilterContextFactory.Create(services, "/api/test", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new ObjectResult(new Payload(1, "fresh")), () => executions++)); + + executions.ShouldBe(1); + second.Result.ShouldNotBeNull(); + var body = await FilterContextFactory.ReadBodyAsync(http, second.Result!); + body.ShouldContain("fresh"); + http.Response.Headers.CacheControl.ToString().ShouldBe("max-age=600"); + } + + [Fact] + public async Task BufferedProvider_MissThenHit_Roundtrips() + { + await using var services = BuildServices(s => + s.AddSingleton(new InMemoryBufferCache())); + var attribute = new CacheAttribute(); + var executions = 0; + + var (first, _) = FilterContextFactory.Create(services, "/api/buffered", new() { ["id"] = 9 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new ObjectResult(new Payload(9, "pooled")), () => executions++)); + + var (second, http) = FilterContextFactory.Create(services, "/api/buffered", new() { ["id"] = 9 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new ObjectResult(new Payload(9, "pooled")), () => executions++)); + + executions.ShouldBe(1); + var body = await FilterContextFactory.ReadBodyAsync(http, second.Result!); + body.ShouldContain("pooled"); + } + + [Fact] + public async Task SharedAttributeInstance_ConcurrentRequests_NeverMixResponses() + { + await using var services = BuildServices(); + var attribute = new CacheAttribute(); + + await Parallel.ForAsync(0, 500, async (iteration, _) => + { + var expected = iteration % 20; + var (context, http) = FilterContextFactory.Create(services, "/api/race", new() { ["id"] = expected }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Echo(expected)))); + + if (context.Result is not null) + { + var body = await FilterContextFactory.ReadBodyAsync(http, context.Result); + body.ShouldBe($"{{\"id\":{expected}}}"); + } + }); + } + + [Fact] + public async Task StatusMismatch_IsNotCached() + { + await using var services = BuildServices(); + var attribute = new CacheAttribute { SuccessStatus = HttpStatusCode.Created }; + var executions = 0; + + for (var i = 0; i < 2; i++) + { + var (context, _) = FilterContextFactory.Create(services, "/api/status", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x")), () => executions++)); + } + + executions.ShouldBe(2); + } + + [Fact] + public async Task OversizedPayload_IsNotCached() + { + await using var services = BuildServices(s => + s.Configure(o => o.MaxPayloadBytes = 8)); + var attribute = new CacheAttribute(); + var executions = 0; + + for (var i = 0; i < 2; i++) + { + var (context, _) = FilterContextFactory.Create(services, "/api/big", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "0123456789")), () => executions++)); + } + + executions.ShouldBe(2); + } + + [Fact] + public async Task StatusCodeResult_IsCachedAsEmptyMarker_AndReplayed() + { + await using var services = BuildServices(); + var attribute = new CacheAttribute(); + var executions = 0; + + var (first, _) = FilterContextFactory.Create(services, "/api/empty", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(first, + FilterContextFactory.NextReturning(first, new StatusCodeResult(200), () => executions++)); + + var (second, _) = FilterContextFactory.Create(services, "/api/empty", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(second, + FilterContextFactory.NextReturning(second, new StatusCodeResult(200), () => executions++)); + + executions.ShouldBe(1); + second.Result.ShouldBeOfType().StatusCode.ShouldBe(200); + } + + [Fact] + public async Task CacheGetFailure_FailsOpen_ActionStillExecutes() + { + var failing = Substitute.For(); + failing.GetAsync(Arg.Any(), Arg.Any()) + .ThrowsAsync(new InvalidOperationException("redis down")); + failing.SetAsync(Arg.Any(), Arg.Any(), Arg.Any(), + Arg.Any()).Returns(Task.CompletedTask); + await using var services = BuildServices(s => s.AddSingleton(failing)); + var attribute = new CacheAttribute(); + var executions = 0; + + var (context, _) = FilterContextFactory.Create(services, "/api/failopen", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x")), () => executions++)); + + executions.ShouldBe(1); + context.Result.ShouldBeNull(); + } + + [Fact] + public async Task CanceledRequest_PropagatesOperationCanceled() + { + using var cts = new CancellationTokenSource(); + cts.Cancel(); + var failing = Substitute.For(); + failing.GetAsync(Arg.Any(), Arg.Any()) + .ThrowsAsync(new OperationCanceledException(cts.Token)); + await using var services = BuildServices(s => s.AddSingleton(failing)); + var attribute = new CacheAttribute(); + + var (context, http) = FilterContextFactory.Create(services, "/api/cancel", new() { ["id"] = 1 }); + http.RequestAborted = cts.Token; + + await Should.ThrowAsync(() => attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x"))))); + } + + [Fact] + public async Task NoDistributedCacheRegistered_JustRunsAction() + { + await using var services = new ServiceCollection().AddLogging().BuildServiceProvider(); + var attribute = new CacheAttribute(); + var executions = 0; + + var (context, _) = FilterContextFactory.Create(services, "/api/nocache", new() { ["id"] = 1 }); + await attribute.OnActionExecutionAsync(context, + FilterContextFactory.NextReturning(context, new ObjectResult(new Payload(1, "x")), () => executions++)); + + executions.ShouldBe(1); + } + + private sealed record Payload(int Id, string Name); + + private sealed record Echo(int Id); +} diff --git a/test/AspNet.Cache.Test/CacheIntegrationTests.cs b/test/AspNet.Cache.Test/CacheIntegrationTests.cs new file mode 100644 index 0000000..4fc5044 --- /dev/null +++ b/test/AspNet.Cache.Test/CacheIntegrationTests.cs @@ -0,0 +1,86 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Hosting; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.TestHost; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; +using Shouldly; +using Xunit; + +namespace AspNet.Cache.Test; + +public sealed class CacheIntegrationTests : IDisposable +{ + private readonly IHost _host; + private readonly HttpClient _client; + + public CacheIntegrationTests() + { + _host = new HostBuilder() + .ConfigureWebHost(webHost => webHost + .UseTestServer() + .ConfigureServices(services => + { + services.AddControllers().AddApplicationPart(typeof(CounterController).Assembly); + services.AddDistributedMemoryCache(); + }) + .Configure(app => + { + app.UseRouting(); + app.UseEndpoints(endpoints => endpoints.MapControllers()); + })) + .Start(); + _client = _host.GetTestClient(); + } + + [Fact] + public async Task SecondRequest_SameArguments_IsServedFromCache() + { + CounterController.Reset(); + + var first = await _client.GetStringAsync("/api/counter?id=1"); + var second = await _client.GetStringAsync("/api/counter?id=1"); + + second.ShouldBe(first); + CounterController.Executions.ShouldBe(1); + } + + [Fact] + public async Task DifferentArguments_ProduceDifferentEntries() + { + CounterController.Reset(); + + var one = await _client.GetStringAsync("/api/counter?id=1"); + var two = await _client.GetStringAsync("/api/counter?id=2"); + + one.ShouldNotBe(two); + CounterController.Executions.ShouldBe(2); + } + + public void Dispose() + { + _client.Dispose(); + _host.Dispose(); + } +} + +[ApiController] +[Route("api/[controller]")] +public sealed class CounterController : ControllerBase +{ + private static int _executions; + + internal static int Executions => Volatile.Read(ref _executions); + + internal static void Reset() => Interlocked.Exchange(ref _executions, 0); + + [HttpGet] + [Cache(ExpireAt = 5, TimeSpanType = TimeSpanType.FromMinutes)] + public CounterPayload Get(int id) + { + Interlocked.Increment(ref _executions); + return new CounterPayload(id, Guid.NewGuid().ToString("N")); + } +} + +public sealed record CounterPayload(int Id, string Nonce); diff --git a/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs b/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs new file mode 100644 index 0000000..740c50d --- /dev/null +++ b/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs @@ -0,0 +1,76 @@ +using System.Text.Json; +using AspNet.Cache.Internal; +using Shouldly; +using Xunit; + +namespace AspNet.Cache.Test; + +public sealed class CacheKeyBuilderTests +{ + private static readonly JsonSerializerOptions Serializer = new(JsonSerializerDefaults.Web); + private static readonly Func Ignore = + static name => name.Contains("correlationid", StringComparison.OrdinalIgnoreCase); + + private static string Build(string folder, string path, Dictionary args) => + CacheKeyBuilder.Build(folder, path, args, Ignore, Serializer); + + [Fact] + public void SameArguments_ProduceSameKey_IgnoringCorrelationId() + { + var first = Build("Test", "/api/default", + new() { ["id"] = 42, ["xCorrelationId"] = Guid.NewGuid().ToString() }); + var second = Build("Test", "/api/default", + new() { ["id"] = 42, ["xCorrelationId"] = Guid.NewGuid().ToString() }); + + first.ShouldBe(second); + } + + [Fact] + public void DifferentArguments_ProduceDifferentKeys() + { + var first = Build("Test", "/api/default", new() { ["id"] = 42 }); + var second = Build("Test", "/api/default", new() { ["id"] = 43 }); + + first.ShouldNotBe(second); + } + + [Fact] + public void Key_HasFolderPrefix_SlashesReplaced_And64HexSuffix() + { + var key = Build("Test", "/api/default", new() { ["id"] = 1 }); + + key.ShouldStartWith("Test:-api-default-"); + key.Length.ShouldBe("Test:-api-default-".Length + 64); + key.ShouldNotContain("/"); + } + + [Fact] + public void EmptyFolder_OmitsPrefixSeparator() + { + var key = Build(string.Empty, "/api/default", new() { ["id"] = 1 }); + + key.ShouldStartWith("-api-default-"); + } + + [Fact] + public void LongPath_UsesPooledBuffer_AndKeepsCorrectness() + { + var longPath = "/api/" + new string('x', 400); + + var key = Build("Test", longPath, new() { ["id"] = 1 }); + + key.Length.ShouldBe("Test:".Length + longPath.Length + 1 + 64); + key.ShouldNotContain("/"); + } + + [Fact] + public void ComplexObjectArgument_InfluencesKey() + { + var withBody = Build("Test", "/api/default", new() { ["body"] = new Payload(7, "coffee") }); + var without = Build("Test", "/api/default", new()); + + withBody.ShouldNotBe(without); + } + + private sealed record Payload(int Id, string Name); +} diff --git a/test/AspNet.Cache.Test/FaultyBufferCache.cs b/test/AspNet.Cache.Test/FaultyBufferCache.cs new file mode 100644 index 0000000..1a72f29 --- /dev/null +++ b/test/AspNet.Cache.Test/FaultyBufferCache.cs @@ -0,0 +1,68 @@ +using System.Buffers; +using System.Collections.Concurrent; +using Microsoft.Extensions.Caching.Distributed; + +namespace AspNet.Cache.Test; + +/// Configurable that can fault reads or writes, for fail-open tests. +internal sealed class FaultyBufferCache : IBufferDistributedCache +{ + private readonly ConcurrentDictionary _entries = new(); + + public Exception? OnGet { get; init; } + + public Exception? OnSet { get; init; } + + public byte[]? Get(string key) => _entries.TryGetValue(key, out var value) ? value : null; + + public Task GetAsync(string key, CancellationToken token = default) => Task.FromResult(Get(key)); + + public void Refresh(string key) + { + } + + public Task RefreshAsync(string key, CancellationToken token = default) => Task.CompletedTask; + + public void Remove(string key) => _entries.TryRemove(key, out _); + + public Task RemoveAsync(string key, CancellationToken token = default) + { + Remove(key); + return Task.CompletedTask; + } + + public void Set(string key, byte[] value, DistributedCacheEntryOptions options) => _entries[key] = value; + + public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default) + { + if (OnSet is not null) + throw OnSet; + Set(key, value, options); + return Task.CompletedTask; + } + + public bool TryGet(string key, IBufferWriter destination) + { + if (OnGet is not null) + throw OnGet; + if (!_entries.TryGetValue(key, out var value)) + return false; + destination.Write(value); + return true; + } + + public ValueTask TryGetAsync(string key, IBufferWriter destination, CancellationToken token = default) => + new(TryGet(key, destination)); + + public void Set(string key, ReadOnlySequence value, DistributedCacheEntryOptions options) => + _entries[key] = value.ToArray(); + + public ValueTask SetAsync(string key, ReadOnlySequence value, DistributedCacheEntryOptions options, + CancellationToken token = default) + { + if (OnSet is not null) + throw OnSet; + Set(key, value, options); + return ValueTask.CompletedTask; + } +} diff --git a/test/AspNet.Cache.Test/FilterContextFactory.cs b/test/AspNet.Cache.Test/FilterContextFactory.cs new file mode 100644 index 0000000..c82962a --- /dev/null +++ b/test/AspNet.Cache.Test/FilterContextFactory.cs @@ -0,0 +1,39 @@ +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.Abstractions; +using Microsoft.AspNetCore.Mvc.Filters; +using Microsoft.AspNetCore.Routing; + +namespace AspNet.Cache.Test; + +internal static class FilterContextFactory +{ + public static (ActionExecutingContext Context, DefaultHttpContext Http) Create(IServiceProvider services, + string path, Dictionary arguments) + { + var http = new DefaultHttpContext { RequestServices = services }; + http.Request.Path = path; + http.Response.Body = new MemoryStream(); + var actionContext = new ActionContext(http, new RouteData(), new ActionDescriptor()); + var context = new ActionExecutingContext(actionContext, new List(), arguments, new object()); + return (context, http); + } + + public static ActionExecutionDelegate NextReturning(ActionExecutingContext context, IActionResult result, + Action? onExecuted = null) => () => + { + onExecuted?.Invoke(); + return Task.FromResult(new ActionExecutedContext(context, new List(), new object()) + { + Result = result + }); + }; + + public static async Task ReadBodyAsync(DefaultHttpContext http, IActionResult result) + { + await result.ExecuteResultAsync(new ActionContext(http, new RouteData(), new ActionDescriptor())); + http.Response.Body.Position = 0; + using var reader = new StreamReader(http.Response.Body); + return await reader.ReadToEndAsync(); + } +} diff --git a/test/AspNet.Cache.Test/InMemoryBufferCache.cs b/test/AspNet.Cache.Test/InMemoryBufferCache.cs new file mode 100644 index 0000000..d8dc1bd --- /dev/null +++ b/test/AspNet.Cache.Test/InMemoryBufferCache.cs @@ -0,0 +1,58 @@ +using System.Buffers; +using System.Collections.Concurrent; +using Microsoft.Extensions.Caching.Distributed; + +namespace AspNet.Cache.Test; + +/// In-process used by tests and benchmarks. Not for production. +internal sealed class InMemoryBufferCache : IBufferDistributedCache +{ + private readonly ConcurrentDictionary _entries = new(); + + public byte[]? Get(string key) => _entries.TryGetValue(key, out var value) ? value : null; + + public Task GetAsync(string key, CancellationToken token = default) => Task.FromResult(Get(key)); + + public void Refresh(string key) + { + } + + public Task RefreshAsync(string key, CancellationToken token = default) => Task.CompletedTask; + + public void Remove(string key) => _entries.TryRemove(key, out _); + + public Task RemoveAsync(string key, CancellationToken token = default) + { + Remove(key); + return Task.CompletedTask; + } + + public void Set(string key, byte[] value, DistributedCacheEntryOptions options) => _entries[key] = value; + + public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default) + { + Set(key, value, options); + return Task.CompletedTask; + } + + public bool TryGet(string key, IBufferWriter destination) + { + if (!_entries.TryGetValue(key, out var value)) + return false; + destination.Write(value); + return true; + } + + public ValueTask TryGetAsync(string key, IBufferWriter destination, CancellationToken token = default) => + new(TryGet(key, destination)); + + public void Set(string key, ReadOnlySequence value, DistributedCacheEntryOptions options) => + _entries[key] = value.ToArray(); + + public ValueTask SetAsync(string key, ReadOnlySequence value, DistributedCacheEntryOptions options, + CancellationToken token = default) + { + Set(key, value, options); + return ValueTask.CompletedTask; + } +} diff --git a/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs b/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs new file mode 100644 index 0000000..3d37625 --- /dev/null +++ b/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs @@ -0,0 +1,63 @@ +using AspNet.Cache.Internal; +using Shouldly; +using Xunit; + +namespace AspNet.Cache.Test; + +public sealed class PooledArrayBufferWriterTests +{ + [Fact] + public void Growth_PreservesContentAcrossRents() + { + using var writer = new PooledArrayBufferWriter(initialCapacity: 16); + + for (var i = 0; i < 100; i++) + { + var span = writer.GetSpan(64); + span[..64].Fill((byte)i); + writer.Advance(64); + } + + writer.WrittenCount.ShouldBe(6400); + writer.WrittenSpan[0].ShouldBe((byte)0); + writer.WrittenSpan[^1].ShouldBe((byte)99); + } + + [Fact] + public void SoftLimitExceeded_SetsOverflowed() + { + using var writer = new PooledArrayBufferWriter(softLimit: 8); + + writer.GetSpan(32)[..32].Fill(0xAB); + writer.Advance(32); + + writer.Overflowed.ShouldBeTrue(); + writer.WrittenCount.ShouldBe(32); + } + + [Fact] + public void NegativeAdvance_Throws() + { + using var writer = new PooledArrayBufferWriter(); + + Should.Throw(() => writer.Advance(-1)); + } + + [Fact] + public void AdvanceBeyondCapacity_Throws() + { + using var writer = new PooledArrayBufferWriter(initialCapacity: 16); + + Should.Throw(() => writer.Advance(1_000_000)); + } + + [Fact] + public void Dispose_IsIdempotent() + { + var writer = new PooledArrayBufferWriter(); + writer.Dispose(); + writer.Dispose(); + + writer.WrittenCount.ShouldBe(0); + } +} diff --git a/test/AspNet.Cache.Test/Properties/launchSettings.json b/test/AspNet.Cache.Test/Properties/launchSettings.json deleted file mode 100644 index f9b141c..0000000 --- a/test/AspNet.Cache.Test/Properties/launchSettings.json +++ /dev/null @@ -1,27 +0,0 @@ -{ - "iisSettings": { - "windowsAuthentication": false, - "anonymousAuthentication": true, - "iisExpress": { - "applicationUrl": "http://localhost:25607/", - "sslPort": 44347 - } - }, - "profiles": { - "IIS Express": { - "commandName": "IISExpress", - "launchBrowser": true, - "environmentVariables": { - "ASPNETCORE_ENVIRONMENT": "Development" - } - }, - "AspNet.Cache.Test": { - "commandName": "Project", - "launchBrowser": true, - "environmentVariables": { - "ASPNETCORE_ENVIRONMENT": "Development" - }, - "applicationUrl": "https://localhost:5001;http://localhost:5000" - } - } -} \ No newline at end of file diff --git a/test/AspNet.Cache.Test/UnitTest1.cs b/test/AspNet.Cache.Test/UnitTest1.cs deleted file mode 100644 index afcf397..0000000 --- a/test/AspNet.Cache.Test/UnitTest1.cs +++ /dev/null @@ -1,46 +0,0 @@ -using System.Threading.Tasks; -using AspNet.Cache.Test.WebServer; -using Xunit; -using Newtonsoft.Json; -using System.Collections.Generic; -using System.Diagnostics; - -namespace AspNet.Cache.Test -{ - public class UnitTest1 : StartTestServer - { - [Fact] - public async Task Test1() - { - var sw = new Stopwatch(); - sw.Start(); - var t = await client.GetAsync("/api/default"); - sw.Stop(); - - var tempo = sw.ElapsedMilliseconds; - - var sw2 = new Stopwatch(); - sw2.Start(); - var t2 = await client.GetAsync("/api/default"); - sw2.Stop(); - - var tempo2 = sw2.ElapsedMilliseconds; - - Assert.True(tempo > tempo2); - - var p = JsonConvert.DeserializeObject>(await t.Content.ReadAsStringAsync()); - } - - [Fact] - public async Task Get1() - { - var t = await client.GetAsync("/api/default/get1"); - var t2 = await client.GetAsync("/api/default/get1"); - - var p = JsonConvert.DeserializeObject>(await t.Content.ReadAsStringAsync()); - - Assert.True(t.IsSuccessStatusCode); - Assert.True(t2.IsSuccessStatusCode); - } - } -} diff --git a/test/AspNet.Cache.Test/WebServer/DefaultController.cs b/test/AspNet.Cache.Test/WebServer/DefaultController.cs deleted file mode 100644 index df01930..0000000 --- a/test/AspNet.Cache.Test/WebServer/DefaultController.cs +++ /dev/null @@ -1,64 +0,0 @@ -using System; -using System.Collections.Generic; -using System.ComponentModel.DataAnnotations; -using System.Linq; -using System.Threading.Tasks; -using Microsoft.AspNetCore.Mvc; -using Microsoft.Extensions.Logging; - -namespace AspNet.Cache.Test.WebServer -{ - [ApiController, Route("api/[controller]")] - public class DefaultController : ControllerBase - { - private static readonly string[] Summaries = new[] - { - "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" - }; - - private readonly ILogger _logger; - - public DefaultController(ILogger logger) - { - _logger = logger; - } - - [HttpGet, Cache(Folder = "Test", SuccessStatus = System.Net.HttpStatusCode.Created, TimeSpanType = TimeSpanType.FromDays, ExpireAt = 12)] - public async Task>> Get([Required, FromHeader(Name = "X-Correlation-Id")] string correlationId) - { - await Task.Delay(1000); - var rng = new Random(); - return Enumerable.Range(1, 5).Select(index => new WeatherForecast - { - Date = DateTime.Now.AddDays(index), - TemperatureC = rng.Next(-20, 55), - Summary = Summaries[rng.Next(Summaries.Length)] - }) - .ToArray(); - } - - [HttpGet("get1"), Cache] - public IEnumerable Get1([Required, FromHeader(Name = "X-Correlation-Id")] string correlationId) - { - var rng = new Random(); - return Enumerable.Range(1, 5).Select(index => new WeatherForecast - { - Date = DateTime.Now.AddDays(index), - TemperatureC = rng.Next(-20, 55), - Summary = Summaries[rng.Next(Summaries.Length)] - }) - .ToArray(); - } - } - - public class WeatherForecast - { - public DateTime Date { get; set; } - - public int TemperatureC { get; set; } - - public int TemperatureF => 32 + (int)(TemperatureC / 0.5556); - - public string Summary { get; set; } - } -} diff --git a/test/AspNet.Cache.Test/WebServer/StartTestServer.cs b/test/AspNet.Cache.Test/WebServer/StartTestServer.cs deleted file mode 100644 index baa0bd5..0000000 --- a/test/AspNet.Cache.Test/WebServer/StartTestServer.cs +++ /dev/null @@ -1,62 +0,0 @@ -using Microsoft.AspNetCore.Hosting; -using Microsoft.AspNetCore.TestHost; -using Microsoft.Extensions.Hosting; -using System; -using System.Net.Http; - -namespace AspNet.Cache.Test.WebServer -{ - public class StartTestServer : IDisposable - { - private readonly IHost _host; - - protected readonly HttpClient client; - - public StartTestServer() - { - var _hostBuilder = new HostBuilder() - .UseEnvironment("Test") - .ConfigureWebHost(webHost => - { - webHost.UseTestServer(); - - webHost.UseStartup(); - }); - - _host = _hostBuilder.Start(); - - client = _host.GetTestClient(); - client.DefaultRequestHeaders.Add("X-Correlation-Id", "Teste"); - } - - #region IDisposable Support - - private bool disposedValue = false; // To detect redundant calls - - protected virtual void Dispose(bool disposing) - { - if (!disposedValue) - { - if (disposing) - { - client.Dispose(); - _host.Dispose(); - } - disposedValue = true; - } - } - - ~StartTestServer() - { - Dispose(false); - } - - public void Dispose() - { - Dispose(true); - GC.SuppressFinalize(this); - } - - #endregion IDisposable Support - } -} diff --git a/test/AspNet.Cache.Test/WebServer/StartupTest.cs b/test/AspNet.Cache.Test/WebServer/StartupTest.cs deleted file mode 100644 index 15a70a1..0000000 --- a/test/AspNet.Cache.Test/WebServer/StartupTest.cs +++ /dev/null @@ -1,35 +0,0 @@ -using Microsoft.AspNetCore.Builder; -using Microsoft.AspNetCore.Hosting; -using Microsoft.Extensions.Configuration; -using Microsoft.Extensions.DependencyInjection; - -namespace AspNet.Cache.Test.WebServer -{ - public class StartupTest - { - public StartupTest(IConfiguration configuration) - { - Configuration = configuration; - } - - public IConfiguration Configuration; - - public void ConfigureServices(IServiceCollection services) - { - services.AddControllers(); - services.AddDistributedMemoryCache(); - } - - public void Configure(IApplicationBuilder app, IWebHostEnvironment env) - { - app.UseRouting(); - - app.UseAuthorization(); - - app.UseEndpoints(endpoints => - { - endpoints.MapControllers(); - }); - } - } -} diff --git a/test/AspNet.Cache.Test/coverage.opencover.xml b/test/AspNet.Cache.Test/coverage.opencover.xml new file mode 100644 index 0000000..ef19f11 --- /dev/null +++ b/test/AspNet.Cache.Test/coverage.opencover.xml @@ -0,0 +1,884 @@ + + + + + + AspNet.Cache.dll + 2026-07-19T07:00:31 + AspNet.Cache + + + + + + + + + + + + + + AspNet.Cache.AspNetCacheOptions + + + + + System.Text.Json.JsonSerializerOptions AspNet.Cache.AspNetCacheOptions::get_KeySerializerOptions() + + + + + + + + + + + System.Text.Json.JsonSerializerOptions AspNet.Cache.AspNetCacheOptions::get_PayloadSerializerOptions() + + + + + + + + + + + System.Int32 AspNet.Cache.AspNetCacheOptions::get_MaxPayloadBytes() + + + + + + + + + + + System.Func`2<System.String,System.Boolean> AspNet.Cache.AspNetCacheOptions::get_IgnoreArgument() + + + + + + + + + + + System.Void AspNet.Cache.AspNetCacheOptions::.ctor() + + + + + + + + + + + System.Void AspNet.Cache.AspNetCacheOptions::.cctor() + + + + + + + + + + + + AspNet.Cache.CacheAttribute + + + + + System.String AspNet.Cache.CacheAttribute::get_Folder() + + + + + + + + + + + System.Int64 AspNet.Cache.CacheAttribute::get_ExpireAt() + + + + + + + + + + + AspNet.Cache.TimeSpanType AspNet.Cache.CacheAttribute::get_TimeSpanType() + + + + + + + + + + + System.Net.HttpStatusCode AspNet.Cache.CacheAttribute::get_SuccessStatus() + + + + + + + + + + + System.Boolean AspNet.Cache.CacheAttribute::MatchesSuccessStatus(System.Nullable`1<System.Int32>) + + + + + + + + + + + System.TimeSpan AspNet.Cache.CacheAttribute::GetExpiration() + + + + + + + + + + + + + + + + + + + + + + + + System.String AspNet.Cache.CacheAttribute::GetCacheControlHeaderValue() + + + + + + + + + + + + + + + Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions AspNet.Cache.CacheAttribute::GetEntryOptions() + + + + + + + + + + + + + + Microsoft.Extensions.Logging.ILogger AspNet.Cache.CacheAttribute::ResolveLogger(System.IServiceProvider) + + + + + + + + + + + + + + + AspNet.Cache.CacheAttribute/<OnActionExecutionAsync>d__18 + + + + + System.Void AspNet.Cache.CacheAttribute/<OnActionExecutionAsync>d__18::MoveNext() + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AspNet.Cache.CacheAttribute/<StoreAsync>d__21 + + + + + System.Void AspNet.Cache.CacheAttribute/<StoreAsync>d__21::MoveNext() + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AspNet.Cache.CacheAttribute/<TryServeBufferedAsync>d__19 + + + + + System.Void AspNet.Cache.CacheAttribute/<TryServeBufferedAsync>d__19::MoveNext() + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AspNet.Cache.CacheAttribute/<TryServeLegacyAsync>d__20 + + + + + System.Void AspNet.Cache.CacheAttribute/<TryServeLegacyAsync>d__20::MoveNext() + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AspNet.Cache.Internal.CachedJsonResult + + + + + System.Boolean AspNet.Cache.Internal.CachedJsonResult::IsEmptyMarker(System.Byte[]) + + + + + + + + + + + System.Boolean AspNet.Cache.Internal.CachedJsonResult::IsEmptyMarker(System.ReadOnlySpan`1<System.Byte>) + + + + + + + + + + + System.Void AspNet.Cache.Internal.CachedJsonResult::.ctor(System.Byte[],System.Int32) + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CachedJsonResult::.cctor() + + + + + + + + + + + + AspNet.Cache.Internal.CachedJsonResult/<ExecuteResultAsync>d__5 + + + + + System.Void AspNet.Cache.Internal.CachedJsonResult/<ExecuteResultAsync>d__5::MoveNext() + + + + + + + + + + + + + + + + + + AspNet.Cache.Internal.CacheKeyBuilder + + + + + System.String AspNet.Cache.Internal.CacheKeyBuilder::Build(System.String,System.String,System.Collections.Generic.IDictionary`2<System.String,System.Object>,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CacheKeyBuilder::HashArguments(System.Collections.Generic.IDictionary`2<System.String,System.Object>,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions,System.Span`1<System.Byte>) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CacheKeyBuilder::WriteArgument(System.Text.Json.Utf8JsonWriter,System.String,System.Object,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions) + + + + + + + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CacheKeyBuilder::WriteUpperHex(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>) + + + + + + + + + + + + + + + + + + AspNet.Cache.Internal.CacheLog + + + + + System.Void AspNet.Cache.Internal.CacheLog::GetFailed(Microsoft.Extensions.Logging.ILogger,System.Exception) + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CacheLog::SetFailed(Microsoft.Extensions.Logging.ILogger,System.Exception) + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.CacheLog::.cctor() + + + + + + + + + + + + + + + AspNet.Cache.Internal.PooledArrayBufferWriter + + + + + System.Boolean AspNet.Cache.Internal.PooledArrayBufferWriter::get_Overflowed() + + + + + + + + + + + System.ReadOnlySpan`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenSpan() + + + + + + + + + + + System.ReadOnlyMemory`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenMemory() + + + + + + + + + + + System.Int32 AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenCount() + + + + + + + + + + + System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::Advance(System.Int32) + + + + + + + + + + + + + + + + + + + System.Memory`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::GetMemory(System.Int32) + + + + + + + + + + + + System.Span`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::GetSpan(System.Int32) + + + + + + + + + + + + System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::Dispose() + + + + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::EnsureCapacity(System.Int32) + + + + + + + + + + + + + + + + + + + + + + + + + + System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::.ctor(System.Int32,System.Int32) + + + + + + + + + + + + + + + AspNet.Cache.Internal.PooledCachedJsonResult + + + + + System.Void AspNet.Cache.Internal.PooledCachedJsonResult::.ctor(AspNet.Cache.Internal.PooledArrayBufferWriter,System.Int32) + + + + + + + + + + + + + + + AspNet.Cache.Internal.PooledCachedJsonResult/<ExecuteResultAsync>d__4 + + + + + System.Void AspNet.Cache.Internal.PooledCachedJsonResult/<ExecuteResultAsync>d__4::MoveNext() + + + + + + + + + + + + + + + + + + + + + AspNet.Cache.Internal.SerializerDefaults + + + + + System.Void AspNet.Cache.Internal.SerializerDefaults::.cctor() + + + + + + + + + + + + + \ No newline at end of file From b72b75a29e928ae0427320ca61c6053447a28f89 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:04:08 -0300 Subject: [PATCH 03/16] feat: add allocation benchmarks with CI budget gate BenchmarkDotNet MemoryDiagnoser over key generation, buffered/legacy hits and buffered store. budgets.json + check-allocation-budgets.ps1 fail the build on any Gen1/Gen2 collection or bytes/op regression. Measured (net9 host, short job): KeyGen 344 B/op, BufferedHit 104 B/op, LegacyHit 144 B/op, Store 864 B/op, all Gen0-only. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .gitignore | 3 + AspNet.Cache.sln | 37 ++++++++++ .../AspNet.Cache.Benchmarks.csproj | 24 ++++++ .../CacheBenchmarks.cs | 74 +++++++++++++++++++ benchmarks/AspNet.Cache.Benchmarks/Program.cs | 3 + benchmarks/budgets.json | 6 ++ build/check-allocation-budgets.ps1 | 30 ++++++++ 7 files changed, 177 insertions(+) create mode 100644 benchmarks/AspNet.Cache.Benchmarks/AspNet.Cache.Benchmarks.csproj create mode 100644 benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs create mode 100644 benchmarks/AspNet.Cache.Benchmarks/Program.cs create mode 100644 benchmarks/budgets.json create mode 100644 build/check-allocation-budgets.ps1 diff --git a/.gitignore b/.gitignore index c3940fe..bb69e97 100644 --- a/.gitignore +++ b/.gitignore @@ -263,3 +263,6 @@ __pycache__/ /test/Core.Winchester.Tests/coverage.json /test/Core.Winchester.Tests/coverage.cobertura.xml *.info + +# BenchmarkDotNet +BenchmarkDotNet.Artifacts/ diff --git a/AspNet.Cache.sln b/AspNet.Cache.sln index 2ea44fa..b6f3d73 100644 --- a/AspNet.Cache.sln +++ b/AspNet.Cache.sln @@ -17,26 +17,63 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution README.md = README.md EndProjectSection EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{66320409-64EC-F7C5-3DEF-65E7510DAAD1}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AspNet.Cache.Benchmarks", "benchmarks\AspNet.Cache.Benchmarks\AspNet.Cache.Benchmarks.csproj", "{9D6D47E3-980D-4BF9-A3FB-B589211B043B}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|x64.ActiveCfg = Debug|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|x64.Build.0 = Debug|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|x86.ActiveCfg = Debug|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Debug|x86.Build.0 = Debug|Any CPU {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|Any CPU.ActiveCfg = Release|Any CPU {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|Any CPU.Build.0 = Release|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|x64.ActiveCfg = Release|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|x64.Build.0 = Release|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|x86.ActiveCfg = Release|Any CPU + {3390E21C-20D0-45F8-9AD1-4286FF67C598}.Release|x86.Build.0 = Release|Any CPU {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|x64.ActiveCfg = Debug|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|x64.Build.0 = Debug|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|x86.ActiveCfg = Debug|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Debug|x86.Build.0 = Debug|Any CPU {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|Any CPU.ActiveCfg = Release|Any CPU {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|Any CPU.Build.0 = Release|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|x64.ActiveCfg = Release|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|x64.Build.0 = Release|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|x86.ActiveCfg = Release|Any CPU + {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C}.Release|x86.Build.0 = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|x64.ActiveCfg = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|x64.Build.0 = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|x86.ActiveCfg = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Debug|x86.Build.0 = Debug|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|Any CPU.Build.0 = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x64.ActiveCfg = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x64.Build.0 = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x86.ActiveCfg = Release|Any CPU + {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C} = {2ACD33BC-B50B-4296-879C-0660E72B18CF} + {9D6D47E3-980D-4BF9-A3FB-B589211B043B} = {66320409-64EC-F7C5-3DEF-65E7510DAAD1} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {E47ABF9E-13CB-4CD1-B06B-3C7E9A86CD60} diff --git a/benchmarks/AspNet.Cache.Benchmarks/AspNet.Cache.Benchmarks.csproj b/benchmarks/AspNet.Cache.Benchmarks/AspNet.Cache.Benchmarks.csproj new file mode 100644 index 0000000..80266a8 --- /dev/null +++ b/benchmarks/AspNet.Cache.Benchmarks/AspNet.Cache.Benchmarks.csproj @@ -0,0 +1,24 @@ + + + + Exe + net8.0 + Major + enable + enable + latest + false + + + + + + + + + + + + + + diff --git a/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs b/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs new file mode 100644 index 0000000..cb96119 --- /dev/null +++ b/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs @@ -0,0 +1,74 @@ +using System.Buffers; +using System.Text.Json; +using AspNet.Cache.Internal; +using AspNet.Cache.Test; +using BenchmarkDotNet.Attributes; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.Caching.Memory; +using Microsoft.Extensions.Options; + +namespace AspNet.Cache.Benchmarks; + +[MemoryDiagnoser] +public class CacheBenchmarks +{ + private static readonly JsonSerializerOptions Serializer = new(JsonSerializerDefaults.Web); + private static readonly Func Ignore = + static name => name.Contains("correlationid", StringComparison.OrdinalIgnoreCase); + + private Dictionary _arguments = null!; + private InMemoryBufferCache _buffered = null!; + private MemoryDistributedCache _legacy = null!; + private string _key = null!; + private Item[] _items = null!; + private DistributedCacheEntryOptions _entryOptions = null!; + + [GlobalSetup] + public void Setup() + { + _arguments = new Dictionary { ["id"] = 42, ["name"] = "abc" }; + _key = CacheKeyBuilder.Build("Bench", "/api/bench", _arguments, Ignore, Serializer); + _items = new Item[10]; + for (var i = 0; i < _items.Length; i++) + _items[i] = new Item(i, $"item-{i}", i * 1.5); + _entryOptions = new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) }; + + var payload = JsonSerializer.SerializeToUtf8Bytes(_items, Serializer); + _buffered = new InMemoryBufferCache(); + _buffered.Set(_key, payload, _entryOptions); + _legacy = new MemoryDistributedCache(Options.Create(new MemoryDistributedCacheOptions())); + _legacy.Set(_key, payload, _entryOptions); + } + + [Benchmark] + public string KeyGen() => CacheKeyBuilder.Build("Bench", "/api/bench", _arguments, Ignore, Serializer); + + [Benchmark] + public async Task BufferedHit() + { + using var buffer = new PooledArrayBufferWriter(); + await _buffered.TryGetAsync(_key, buffer, default); + return buffer.WrittenCount; + } + + [Benchmark] + public async Task LegacyHit() + { + var payload = await _legacy.GetAsync(_key); + return payload!.Length; + } + + [Benchmark] + public async Task StoreSerializeBuffered() + { + using var buffer = new PooledArrayBufferWriter(84_000); + using (var writer = new Utf8JsonWriter(buffer)) + { + JsonSerializer.Serialize(writer, _items, Serializer); + } + + await _buffered.SetAsync("store", new ReadOnlySequence(buffer.WrittenMemory), _entryOptions, default); + } + + public sealed record Item(int Id, string Name, double Value); +} diff --git a/benchmarks/AspNet.Cache.Benchmarks/Program.cs b/benchmarks/AspNet.Cache.Benchmarks/Program.cs new file mode 100644 index 0000000..c83691f --- /dev/null +++ b/benchmarks/AspNet.Cache.Benchmarks/Program.cs @@ -0,0 +1,3 @@ +using BenchmarkDotNet.Running; + +BenchmarkSwitcher.FromAssembly(typeof(AspNet.Cache.Benchmarks.CacheBenchmarks).Assembly).Run(args); diff --git a/benchmarks/budgets.json b/benchmarks/budgets.json new file mode 100644 index 0000000..378b07b --- /dev/null +++ b/benchmarks/budgets.json @@ -0,0 +1,6 @@ +{ + "KeyGen": 430, + "BufferedHit": 130, + "LegacyHit": 180, + "StoreSerializeBuffered": 1080 +} diff --git a/build/check-allocation-budgets.ps1 b/build/check-allocation-budgets.ps1 new file mode 100644 index 0000000..7a72090 --- /dev/null +++ b/build/check-allocation-budgets.ps1 @@ -0,0 +1,30 @@ +#Requires -Version 7 +$ErrorActionPreference = 'Stop' + +$budgets = Get-Content (Join-Path $PSScriptRoot '..' 'benchmarks' 'budgets.json') | ConvertFrom-Json +$reportFile = Get-ChildItem -Recurse -Path 'BenchmarkDotNet.Artifacts/results' -Filter '*-report-full*.json' | + Select-Object -First 1 +if ($null -eq $reportFile) { throw 'Benchmark report not found. Run the benchmarks with --exporters json first.' } + +$report = Get-Content $reportFile.FullName -Raw | ConvertFrom-Json +$failed = $false + +foreach ($benchmark in $report.Benchmarks) { + $name = $benchmark.Method + $allocated = $benchmark.Memory.BytesAllocatedPerOperation + $gen1 = $benchmark.Memory.Gen1Collections + $gen2 = $benchmark.Memory.Gen2Collections + $limit = $budgets.$name + + Write-Host ("{0}: {1} B/op (limit {2}), Gen1/1k={3}, Gen2/1k={4}" -f $name, $allocated, $limit, $gen1, $gen2) + + if ($gen2 -gt 0) { Write-Host "FAIL: $name triggered Gen2 collections"; $failed = $true } + if ($gen1 -gt 0) { Write-Host "FAIL: $name triggered Gen1 collections"; $failed = $true } + if ($null -ne $limit -and $allocated -gt $limit) { + Write-Host "FAIL: $name allocated $allocated B/op, budget is $limit" + $failed = $true + } +} + +if ($failed) { exit 1 } +Write-Host 'All allocation budgets respected.' From dc4759c5244a972a9cdf206990a703e48bb55952 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:05:06 -0300 Subject: [PATCH 04/16] feat: add sample app for soak testing Minimal ASP.NET Core app targeting the cache attribute, used as the load-test target for the soak validation and as a runnable README example. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- AspNet.Cache.sln | 17 +++++++++++++ .../AspNet.Cache.Sample.csproj | 15 ++++++++++++ samples/AspNet.Cache.Sample/Program.cs | 8 +++++++ .../AspNet.Cache.Sample/SampleController.cs | 24 +++++++++++++++++++ 4 files changed, 64 insertions(+) create mode 100644 samples/AspNet.Cache.Sample/AspNet.Cache.Sample.csproj create mode 100644 samples/AspNet.Cache.Sample/Program.cs create mode 100644 samples/AspNet.Cache.Sample/SampleController.cs diff --git a/AspNet.Cache.sln b/AspNet.Cache.sln index b6f3d73..79ba8da 100644 --- a/AspNet.Cache.sln +++ b/AspNet.Cache.sln @@ -21,6 +21,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AspNet.Cache.Benchmarks", "benchmarks\AspNet.Cache.Benchmarks\AspNet.Cache.Benchmarks.csproj", "{9D6D47E3-980D-4BF9-A3FB-B589211B043B}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{5D20AA90-6969-D8BD-9DCD-8634F4692FDA}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AspNet.Cache.Sample", "samples\AspNet.Cache.Sample\AspNet.Cache.Sample.csproj", "{7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -67,6 +71,18 @@ Global {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x64.Build.0 = Release|Any CPU {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x86.ActiveCfg = Release|Any CPU {9D6D47E3-980D-4BF9-A3FB-B589211B043B}.Release|x86.Build.0 = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|x64.ActiveCfg = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|x64.Build.0 = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|x86.ActiveCfg = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Debug|x86.Build.0 = Debug|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|Any CPU.Build.0 = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|x64.ActiveCfg = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|x64.Build.0 = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|x86.ActiveCfg = Release|Any CPU + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -74,6 +90,7 @@ Global GlobalSection(NestedProjects) = preSolution {8FEFACF5-56FA-47C7-973A-4C10EE0B1A1C} = {2ACD33BC-B50B-4296-879C-0660E72B18CF} {9D6D47E3-980D-4BF9-A3FB-B589211B043B} = {66320409-64EC-F7C5-3DEF-65E7510DAAD1} + {7CC1F4FC-EF38-4F8C-BD75-360F62B9DEC7} = {5D20AA90-6969-D8BD-9DCD-8634F4692FDA} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {E47ABF9E-13CB-4CD1-B06B-3C7E9A86CD60} diff --git a/samples/AspNet.Cache.Sample/AspNet.Cache.Sample.csproj b/samples/AspNet.Cache.Sample/AspNet.Cache.Sample.csproj new file mode 100644 index 0000000..44e28b5 --- /dev/null +++ b/samples/AspNet.Cache.Sample/AspNet.Cache.Sample.csproj @@ -0,0 +1,15 @@ + + + + net8.0 + Major + enable + enable + false + + + + + + + diff --git a/samples/AspNet.Cache.Sample/Program.cs b/samples/AspNet.Cache.Sample/Program.cs new file mode 100644 index 0000000..c2712f6 --- /dev/null +++ b/samples/AspNet.Cache.Sample/Program.cs @@ -0,0 +1,8 @@ +var builder = WebApplication.CreateBuilder(args); +builder.Services.AddControllers(); +builder.Services.AddDistributedMemoryCache(); +builder.Logging.SetMinimumLevel(LogLevel.Warning); + +var app = builder.Build(); +app.MapControllers(); +app.Run(); diff --git a/samples/AspNet.Cache.Sample/SampleController.cs b/samples/AspNet.Cache.Sample/SampleController.cs new file mode 100644 index 0000000..a93f4a3 --- /dev/null +++ b/samples/AspNet.Cache.Sample/SampleController.cs @@ -0,0 +1,24 @@ +using AspNet.Cache; +using Microsoft.AspNetCore.Mvc; + +namespace AspNet.Cache.Sample; + +[ApiController] +[Route("api/[controller]")] +public sealed class SampleController : ControllerBase +{ + private static readonly string[] Summaries = + ["Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"]; + + [HttpGet] + [Cache(ExpireAt = 5, TimeSpanType = TimeSpanType.FromMinutes)] + public IReadOnlyList Get(int id) + { + var items = new Forecast[5]; + for (var i = 0; i < items.Length; i++) + items[i] = new Forecast(id, DateTime.UtcNow.AddDays(i), Random.Shared.Next(-20, 55), Summaries[i % Summaries.Length]); + return items; + } +} + +public sealed record Forecast(int Id, DateTime Date, int TemperatureC, string Summary); From a06b7d18bf11ef933edf77c0f98fdea1f7955813 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:06:28 -0300 Subject: [PATCH 05/16] ci: replace legacy workflow with SonarQube analysis and allocation gate Drops the .NET Core 2.2 / codecov workflow. Adds build+test with opencover coverage feeding SonarQube (SonarCloud by default, self-hosted supported), gated on the SONAR_TOKEN secret so fork PRs stay green. Separate job runs the benchmarks and enforces the allocation budgets. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/ci.yml | 89 ++++++++++++++++++++++++++++++++ .github/workflows/dotnetcore.yml | 75 --------------------------- 2 files changed, 89 insertions(+), 75 deletions(-) create mode 100644 .github/workflows/ci.yml delete mode 100644 .github/workflows/dotnetcore.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..d438b8e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,89 @@ +name: CI + +on: + push: + branches: [master] + pull_request: + branches: [master] + +jobs: + build-test: + runs-on: ubuntu-latest + env: + SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} + SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL || 'https://sonarcloud.io' }} + SONAR_PROJECT_KEY: ${{ vars.SONAR_PROJECT_KEY }} + SONAR_ORGANIZATION: ${{ vars.SONAR_ORGANIZATION }} + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: | + 8.0.x + 9.0.x + + - name: Setup Java 17 (SonarScanner requirement) + if: env.SONAR_TOKEN != '' + uses: actions/setup-java@v4 + with: + distribution: temurin + java-version: '17' + + - name: Install SonarScanner for .NET + if: env.SONAR_TOKEN != '' + run: dotnet tool install --global dotnet-sonarscanner + + # Self-hosted SonarQube: set the SONAR_HOST_URL repo variable and REMOVE the /o: line below + # (organization is a SonarCloud-only concept). + - name: Begin SonarQube analysis + if: env.SONAR_TOKEN != '' + run: > + dotnet sonarscanner begin + /k:"$SONAR_PROJECT_KEY" + /o:"$SONAR_ORGANIZATION" + /d:sonar.token="$SONAR_TOKEN" + /d:sonar.host.url="$SONAR_HOST_URL" + /d:sonar.cs.opencover.reportsPaths="**/coverage.opencover.xml" + /d:sonar.exclusions="benchmarks/**,samples/**" + + - name: Restore + run: dotnet restore AspNet.Cache.sln + + - name: Build + run: dotnet build AspNet.Cache.sln -c Release --no-restore -warnaserror + + - name: Test with coverage + run: > + dotnet test test/AspNet.Cache.Test/AspNet.Cache.Test.csproj -c Release --no-build + /p:CollectCoverage=true + /p:CoverletOutputFormat=opencover + /p:Threshold=80 + /p:ThresholdType=line + /p:Include="[AspNet.Cache]*" + + - name: End SonarQube analysis + if: env.SONAR_TOKEN != '' + run: dotnet sonarscanner end /d:sonar.token="$SONAR_TOKEN" + + allocation-gate: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: | + 8.0.x + 9.0.x + + - name: Run benchmarks (short job) + run: dotnet run -c Release --project benchmarks/AspNet.Cache.Benchmarks -- --filter "*CacheBenchmarks*" --job short --exporters json + + - name: Enforce allocation budgets + shell: pwsh + run: ./build/check-allocation-budgets.ps1 diff --git a/.github/workflows/dotnetcore.yml b/.github/workflows/dotnetcore.yml deleted file mode 100644 index bdc2cfd..0000000 --- a/.github/workflows/dotnetcore.yml +++ /dev/null @@ -1,75 +0,0 @@ -name: .NET Core - -on: - push: - branches: [ master ] - pull_request: - branches: [ master ] - -jobs: - build: - runs-on: windows-latest - - steps: - - uses: actions/checkout@v1 - - name: Setup .NET Core - uses: actions/setup-dotnet@v1 - with: - dotnet-version: 2.2.103 - - - name: Build solution - run: | - git submodule update --init --recursive - dotnet restore AspNet.Cache.sln - dotnet build -c Release AspNet.Cache/AspNet.Cache.csproj - - - name: Run unit tests - run: | - dotnet test test/AspNet.Cache.Test/AspNet.Cache.Test.csproj - - - name: Run unit tests coverage - run: | - dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=lcov /p:ThresholdType=line /p:CoverletOutput=./lcov test/AspNet.Cache.Test/AspNet.Cache.Test.csproj - - - name: Codecov - uses: codecov/codecov-action@v1.0.6 - with: - # User defined upload name. Visible in Codecov UI - #name: # optional - # Repository upload token - get it from codecov.io. Required only for private repositories - token: ${{ secrets.CODECOV_TOKEN }} - # Path to coverage file to upload - file: test/AspNet.Cache.Test/lcov.info - # Flag upload to group coverage metrics (e.g. unittests | integration | ui,chrome) - #flags: # optional - # Specify whether or not CI build should fail if Codecov runs into an error during upload - #fail_ci_if_error: # optional - - - name: Generate NuGet package - run: | - dotnet pack -c Release - - - name: publish on version change - uses: rohith/publish-nuget@v2 - with: - PROJECT_FILE_PATH: AspNet.Cache/AspNet.Cache.csproj # Relative to repository root - # VERSION_FILE_PATH: Directory.Build.props # Filepath with version info, relative to repository root. Defaults to project file - VERSION_REGEX: (.*)<\/Version> # Regex pattern to extract version info in a capturing group - # VERSION_STATIC: Bypasses version resolution; useful for external providers like Nerdbank.GitVersioning - # TAG_COMMIT: true # Flag to enable / disalge git tagging - # TAG_FORMAT: v* # Format of the git tag, [*] gets replaced with version - NUGET_KEY: ${{ secrets.nuget_token }} # nuget.org API key - # PACKAGE_NAME: NuGet package name, required when it's different from project name. Defaults to project name - #Get-ChildItem -Path E:\projetos\GitHub\Responses\Responses\bin\Release\* -Include *.nupkg | Select-Object -ExpandProperty FullName | %{dotnet nuget push $_ ${{ secrets.nuget_token }} -s https://api.nuget.org/v3/index.json} - - - name: Install NuGet client - uses: warrenbuckley/Setup-Nuget@v1 - - - name: Add private GitHub registry to NuGet - run: | - nuget sources add -name "GPR" -Source https://nuget.pkg.github.com/slipalison/index.json -Username slipalison -Password ${{ secrets.GITHUB_TOKEN }} - - - name: Push generated package to GitHub registry - run: | - dir AspNet.Cache\bin\Release\*.nupkg - nuget push AspNet.Cache\bin\Release\*.nupkg -Source "GPR" -SkipDuplicate From 23e7f67e3c79ef91de1dbc3be46b6dd94aab55b3 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:06:28 -0300 Subject: [PATCH 06/16] ci: add tag-driven NuGet release workflow Pushing a v* tag builds, tests, packs (deterministic + SourceLink + snupkg), pushes to NuGet.org and creates a GitHub Release. Version is derived from the tag, replacing the abandoned third-party publish action. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/release.yml | 53 +++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 .github/workflows/release.yml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..5f3f833 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,53 @@ +name: Release + +on: + push: + tags: ['v*'] + +permissions: + contents: write + +jobs: + release: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: | + 8.0.x + 9.0.x + + - name: Extract version from tag + run: echo "VERSION=${GITHUB_REF_NAME#v}" >> "$GITHUB_ENV" + + - name: Restore + run: dotnet restore AspNet.Cache.sln + + - name: Build + run: dotnet build AspNet.Cache.sln -c Release --no-restore -warnaserror /p:Version=${{ env.VERSION }} + + - name: Test + run: dotnet test test/AspNet.Cache.Test/AspNet.Cache.Test.csproj -c Release --no-build + + - name: Pack + run: > + dotnet pack AspNet.Cache/AspNet.Cache.csproj -c Release --no-build -o out + /p:Version=${{ env.VERSION }} + /p:ContinuousIntegrationBuild=true + + - name: Push to NuGet.org + run: > + dotnet nuget push "out/*.nupkg" + --api-key "${{ secrets.NUGET_API_KEY }}" + --source https://api.nuget.org/v3/index.json + --skip-duplicate + + - name: Create GitHub Release + env: + GH_TOKEN: ${{ github.token }} + run: gh release create "$GITHUB_REF_NAME" out/*.nupkg out/*.snupkg --generate-notes From fcd31798ea462b0f3043d2c6264888a19b0f06ad Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:07:42 -0300 Subject: [PATCH 07/16] docs: rewrite README in English and Portuguese MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bilingual (EN/PT-BR) README with badges, quick start, attribute settings, global options, key format, measured performance numbers, and a v1→v2 migration table. Honest framing of the 1M rps premise (scale-out; the library's job is zero added GC pressure). Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- README.md | 289 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 261 insertions(+), 28 deletions(-) diff --git a/README.md b/README.md index c0d475f..275407d 100644 --- a/README.md +++ b/README.md @@ -1,38 +1,271 @@ -# AspNet.Cache +# AspNet.Cache -![.NET Core](https://github.com/slipalison/AspNet.Cache/workflows/.NET%20Core/badge.svg?event=push) -![.NET Core](https://github.com/slipalison/AspNet.Cache/workflows/.NET%20Core/badge.svg) -[![codecov](https://codecov.io/gh/slipalison/AspNet.Cache/branch/master/graph/badge.svg)](https://codecov.io/gh/slipalison/AspNet.Cache) +[![CI](https://github.com/slipalison/AspNet.Cache/actions/workflows/ci.yml/badge.svg)](https://github.com/slipalison/AspNet.Cache/actions/workflows/ci.yml) +[![NuGet](https://img.shields.io/nuget/v/AspNet.Cache.svg)](https://www.nuget.org/packages/AspNet.Cache/) +[![Downloads](https://img.shields.io/nuget/dt/AspNet.Cache.svg)](https://www.nuget.org/packages/AspNet.Cache/) -### Features -> ... +**English** | [Português](#português-br) ----- +Declarative response caching for ASP.NET Core MVC actions — one attribute, any +[`IDistributedCache`](https://learn.microsoft.com/aspnet/core/performance/caching/distributed) provider. -## C#　 +```csharp +[HttpGet] +[Cache(Folder = "Weather", ExpireAt = 5, TimeSpanType = TimeSpanType.FromMinutes)] +public IReadOnlyList Get(int id) => _service.Load(id); +``` + +First call runs the action and stores the serialized JSON response. Subsequent calls with the same +route + arguments are served straight from the cache — the action never executes. + +## Why AspNet.Cache + +- **Provider-agnostic by design.** Anything that registers `IDistributedCache` works: + Redis (`AddStackExchangeRedisCache`), SQL Server (`AddDistributedSqlServerCache`), + in-memory (`AddDistributedMemoryCache`), MongoDB (community providers), NCache, and more. + You are never locked in. +- **Allocation-conscious hot path.** Cache keys are built with `stackalloc`/`ArrayPool` spans and a + static `SHA256.HashData` (~5× fewer bytes per operation than v1, zero Gen2 impact). Cache hits write + the stored UTF-8 bytes directly to the response body — no deserialize/re-serialize round-trip. +- **`IBufferDistributedCache` fast path.** On .NET 9+ providers that implement it (e.g. + StackExchange.Redis provider 9.x), reads and writes flow through pooled buffers — no per-request + payload `byte[]` at all. Older providers fall back to the classic path automatically. +- **LOH-safe by default.** Responses larger than `MaxPayloadBytes` (default 84,000 bytes — right under + the 85 KB Large Object Heap threshold) are simply not cached, so the cache layer never fragments + the LOH of a long-running service. +- **Fail-open.** If the cache provider is down, requests are served without cache and a single + `Warning` is logged. A cache outage never becomes an API outage. +- **Thread-safe.** The filter holds no per-request state (MVC shares attribute instances across + concurrent requests — v1 had a race here; v2 is stateless by construction and regression-tested + with 500 concurrent requests). + +## Install + +```bash +dotnet add package AspNet.Cache +``` + +Requires .NET 8.0+. + +## Quick start + +```csharp +var builder = WebApplication.CreateBuilder(args); +builder.Services.AddControllers(); +builder.Services.AddDistributedMemoryCache(); // or Redis, SQL Server, Mongo... + +var app = builder.Build(); +app.MapControllers(); +app.Run(); +``` + +```csharp +[ApiController] +[Route("api/[controller]")] +public sealed class WeatherController : ControllerBase +{ + // Cache for 12 hours, replay hits with 201 Created + [HttpGet] + [Cache(Folder = "Weather", ExpireAt = 12, TimeSpanType = TimeSpanType.FromHours, + SuccessStatus = HttpStatusCode.Created)] + public IReadOnlyList Get(int id) => Load(id); +} +``` + +### Attribute settings + +| Property | Default | Meaning | +|---|---|---| +| `Folder` | `""` | Key prefix (`Folder:` is prepended to every key) | +| `ExpireAt` | `10` | Expiration amount, in `TimeSpanType` units | +| `TimeSpanType` | `FromMinutes` | Unit: milliseconds, seconds, minutes, hours or days | +| `SuccessStatus` | `200 OK` | Status that marks a response cacheable, and the status replayed on hits | + +### Global options -```C# - [ApiController, Route("api/[controller]")] - public class DefaultController : ControllerBase - { - private readonly ILogger _logger; - public DefaultController(ILogger logger) - { - _logger = logger; - } +```csharp +builder.Services.Configure(options => +{ + options.MaxPayloadBytes = 32_000; // skip caching anything bigger + options.IgnoreArgument = name => // args excluded from the cache key + name.Contains("correlationid", StringComparison.OrdinalIgnoreCase); + options.PayloadSerializerOptions = mySerializerOptions; // defaults to your MVC JSON options +}); +``` - [HttpGet, Cache(Folder = "Test", SuccessStatus = System.Net.HttpStatusCode.Created, TimeSpanType = TimeSpanType.FromDays, ExpireAt = 12)] - public IEnumerable Get([Required, FromHeader(Name = "X-Correlation-Id")] string correlationId) - { - ... - } +### How the key is built - [HttpGet("get1"), Cache] - public IEnumerable Get1([Required, FromHeader(Name = "X-Correlation-Id")] string correlationId) - { - ... - } - } ``` +{Folder}:{request path with "/" → "-"}-{SHA-256 hex of the JSON of the action arguments} +Weather:-api-weather-E39743B91B98367F... +``` + +Arguments matching `IgnoreArgument` (correlation ids by default) don't affect the key. +SHA-256 (not a fast non-crypto hash) is deliberate: keys derive from untrusted input, and a forgeable +hash would allow cross-user cache collisions. + +### Notes & trade-offs + +- Cached responses are always served as `application/json` (content negotiation does not apply to hits). +- The response is cached only when its status matches `SuccessStatus` exactly. +- Bodyless responses (`StatusCodeResult`) are cached with a tiny sentinel and replayed as status-only. +- On a cache hit the action does not run — side effects inside the action won't happen. + +## Performance + +Measured on the v2 implementation (net8.0, x64, Release; BenchmarkDotNet, short job): + +| Path | v1 | v2 | +|---|---|---| +| Key generation | 1,784 B/op | **344 B/op** | +| Hit read via `IBufferDistributedCache` | n/a | **104 B/op** (pooled) | +| Hit read via legacy `IDistributedCache` | n/a | **144 B/op** | +| Buffered store (serialize + set) | n/a | **864 B/op** | +| Gen1 / Gen2 collections | — | **0** (all paths Gen0-only) | + +CI enforces allocation budgets on every PR (`build/check-allocation-budgets.ps1`) — allocated bytes +per operation are deterministic, so regressions fail the build. + +> **On "1 million requests/second".** At that scale the bottleneck is the cache provider round-trip +> and the network, and the target is reached by horizontal scale-out (N instances). This library's job +> is to add no GC pressure and no payload copy on the request path — which the budgets above guarantee. + +## Migrating from v1 + +| Change | Impact | +|---|---| +| Target framework `netstandard2.1` → `net8.0` | Apps must run .NET 8+ | +| Newtonsoft.Json → System.Text.Json | Serialization follows your MVC JSON options (camelCase by default) | +| Key format internals changed | Existing cache entries miss once after upgrade (cache warms itself) | +| `Cache-Control: max-age` | Now correct (`TotalSeconds`; v1 emitted the 0–59 component) | +| Response headers on hit | No longer cleared — CORS/security headers survive | +| Concurrency | Race condition fixed; safe under parallel load | + +## License + +[MIT](LICENSE) --- + +## Português (BR) + +[English](#aspnetcache) | **Português** + +Cache de resposta declarativo para actions ASP.NET Core MVC — um attribute, qualquer provider de +[`IDistributedCache`](https://learn.microsoft.com/aspnet/core/performance/caching/distributed). + +```csharp +[HttpGet] +[Cache(Folder = "Weather", ExpireAt = 5, TimeSpanType = TimeSpanType.FromMinutes)] +public IReadOnlyList Get(int id) => _service.Load(id); +``` + +A primeira chamada executa a action e grava a resposta JSON serializada. Chamadas seguintes com o +mesmo path + argumentos são servidas direto do cache — a action nem executa. + +## Por quê + +- **Agnóstico de provider.** Qualquer `IDistributedCache` funciona: Redis, SQL Server, memória, + MongoDB (providers da comunidade), NCache. Sem lock-in. +- **Hot path consciente de alocação.** Chaves geradas com spans (`stackalloc`/`ArrayPool`) e + `SHA256.HashData` estático (~5× menos bytes por operação que a v1, zero impacto em Gen2). Hits + escrevem os bytes UTF-8 armazenados direto no body — sem deserializar/re-serializar. +- **Fast path `IBufferDistributedCache`.** Em providers .NET 9+ que o implementam (ex.: Redis 9.x), + leituras e escritas usam buffers pooled — nenhum `byte[]` de payload por request. Providers antigos + caem automaticamente no caminho clássico. +- **Seguro para a LOH por default.** Respostas maiores que `MaxPayloadBytes` (default 84.000 bytes — + logo abaixo do limiar de 85 KB da Large Object Heap) não são cacheadas: a camada de cache nunca + fragmenta a LOH de um serviço de longa vida. +- **Fail-open.** Provider fora do ar → request segue sem cache com um único log `Warning`. Queda do + cache nunca vira queda da API. +- **Thread-safe.** O filtro não guarda estado por-request (o MVC compartilha a instância do attribute + entre requests concorrentes — a v1 tinha race condition aqui; a v2 é stateless por construção, com + teste de regressão de 500 requests paralelos). + +## Instalação + +```bash +dotnet add package AspNet.Cache +``` + +Requer .NET 8.0+. + +## Início rápido + +```csharp +var builder = WebApplication.CreateBuilder(args); +builder.Services.AddControllers(); +builder.Services.AddDistributedMemoryCache(); // ou Redis, SQL Server, Mongo... + +var app = builder.Build(); +app.MapControllers(); +app.Run(); +``` + +### Configurações do attribute + +| Propriedade | Default | Significado | +|---|---|---| +| `Folder` | `""` | Prefixo da chave | +| `ExpireAt` | `10` | Quantidade de expiração, na unidade de `TimeSpanType` | +| `TimeSpanType` | `FromMinutes` | Milissegundos, segundos, minutos, horas ou dias | +| `SuccessStatus` | `200 OK` | Status que torna a resposta cacheável, e que é devolvido nos hits | + +## Opções globais + +```csharp +builder.Services.Configure(options => +{ + options.MaxPayloadBytes = 32_000; + options.IgnoreArgument = name => + name.Contains("correlationid", StringComparison.OrdinalIgnoreCase); +}); +``` + +## Como a chave é montada + +``` +{Folder}:{path da request com "/" → "-"}-{hex SHA-256 do JSON dos argumentos da action} +Weather:-api-weather-E39743B91B98367F... +``` + +Argumentos que casam com `IgnoreArgument` (correlation ids por default) não afetam a chave. +SHA-256 (não um hash rápido não-criptográfico) é proposital: a chave deriva de input não confiável, e +um hash forjável permitiria colisão de cache entre usuários. + +## Observações + +- Hits são sempre `application/json` (content negotiation não se aplica). +- Só cacheia quando o status da resposta é exatamente `SuccessStatus`. +- Respostas sem corpo (`StatusCodeResult`) são cacheadas com um sentinela pequeno e devolvidas como + status puro. +- Em um hit a action não executa — efeitos colaterais dentro dela não acontecem. + +## Desempenho + +Medido na v2 (net8.0, x64, Release; BenchmarkDotNet, job short): + +| Caminho | v1 | v2 | +|---|---|---| +| Geração de chave | 1.784 B/op | **344 B/op** | +| Leitura no hit via `IBufferDistributedCache` | n/a | **104 B/op** (pooled) | +| Leitura no hit via `IDistributedCache` legado | n/a | **144 B/op** | +| Gravação buffered (serialize + set) | n/a | **864 B/op** | +| Coletas Gen1 / Gen2 | — | **0** (todos os caminhos Gen0-only) | + +O CI aplica os budgets de alocação em todo PR (`build/check-allocation-budgets.ps1`) — bytes por +operação são determinísticos, então regressão quebra o build. + +> **Sobre "1 milhão de requests/segundo".** Nessa escala o gargalo é o round-trip do provider de cache +> e a rede, e o alvo se atinge com scale-out horizontal (N instâncias). O papel desta biblioteca é não +> adicionar pressão de GC nem cópia de payload no caminho da request — o que os budgets acima garantem. + +## Migração v1 → v2 + +Requer .NET 8+; serialização passa a System.Text.Json (segue as opções JSON do seu MVC); o cache +esquenta de novo no upgrade (mudança interna do formato de chave); `max-age` corrigido +(`TotalSeconds`); headers preservados no hit; race condition corrigida. + +## Licença + +[MIT](LICENSE) From 4283c04fd4090dd5ab6458df6b1c810278dd7f2c Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:12:08 -0300 Subject: [PATCH 08/16] chore: stop tracking coverage report and ignore it coverage.opencover.xml is a build artifact; it was accidentally committed with the test rewrite. Remove from tracking and ignore coverage/*.opencover.xml. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .gitignore | 5 + test/AspNet.Cache.Test/coverage.opencover.xml | 884 ------------------ 2 files changed, 5 insertions(+), 884 deletions(-) delete mode 100644 test/AspNet.Cache.Test/coverage.opencover.xml diff --git a/.gitignore b/.gitignore index bb69e97..4fd0f78 100644 --- a/.gitignore +++ b/.gitignore @@ -266,3 +266,8 @@ __pycache__/ # BenchmarkDotNet BenchmarkDotNet.Artifacts/ +.claude +PLANO-MODERNIZACAO.md +# Coverage reports +coverage*.xml +*.opencover.xml diff --git a/test/AspNet.Cache.Test/coverage.opencover.xml b/test/AspNet.Cache.Test/coverage.opencover.xml deleted file mode 100644 index ef19f11..0000000 --- a/test/AspNet.Cache.Test/coverage.opencover.xml +++ /dev/null @@ -1,884 +0,0 @@ - - - - - - AspNet.Cache.dll - 2026-07-19T07:00:31 - AspNet.Cache - - - - - - - - - - - - - - AspNet.Cache.AspNetCacheOptions - - - - - System.Text.Json.JsonSerializerOptions AspNet.Cache.AspNetCacheOptions::get_KeySerializerOptions() - - - - - - - - - - - System.Text.Json.JsonSerializerOptions AspNet.Cache.AspNetCacheOptions::get_PayloadSerializerOptions() - - - - - - - - - - - System.Int32 AspNet.Cache.AspNetCacheOptions::get_MaxPayloadBytes() - - - - - - - - - - - System.Func`2<System.String,System.Boolean> AspNet.Cache.AspNetCacheOptions::get_IgnoreArgument() - - - - - - - - - - - System.Void AspNet.Cache.AspNetCacheOptions::.ctor() - - - - - - - - - - - System.Void AspNet.Cache.AspNetCacheOptions::.cctor() - - - - - - - - - - - - AspNet.Cache.CacheAttribute - - - - - System.String AspNet.Cache.CacheAttribute::get_Folder() - - - - - - - - - - - System.Int64 AspNet.Cache.CacheAttribute::get_ExpireAt() - - - - - - - - - - - AspNet.Cache.TimeSpanType AspNet.Cache.CacheAttribute::get_TimeSpanType() - - - - - - - - - - - System.Net.HttpStatusCode AspNet.Cache.CacheAttribute::get_SuccessStatus() - - - - - - - - - - - System.Boolean AspNet.Cache.CacheAttribute::MatchesSuccessStatus(System.Nullable`1<System.Int32>) - - - - - - - - - - - System.TimeSpan AspNet.Cache.CacheAttribute::GetExpiration() - - - - - - - - - - - - - - - - - - - - - - - - System.String AspNet.Cache.CacheAttribute::GetCacheControlHeaderValue() - - - - - - - - - - - - - - - Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions AspNet.Cache.CacheAttribute::GetEntryOptions() - - - - - - - - - - - - - - Microsoft.Extensions.Logging.ILogger AspNet.Cache.CacheAttribute::ResolveLogger(System.IServiceProvider) - - - - - - - - - - - - - - - AspNet.Cache.CacheAttribute/<OnActionExecutionAsync>d__18 - - - - - System.Void AspNet.Cache.CacheAttribute/<OnActionExecutionAsync>d__18::MoveNext() - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - AspNet.Cache.CacheAttribute/<StoreAsync>d__21 - - - - - System.Void AspNet.Cache.CacheAttribute/<StoreAsync>d__21::MoveNext() - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - AspNet.Cache.CacheAttribute/<TryServeBufferedAsync>d__19 - - - - - System.Void AspNet.Cache.CacheAttribute/<TryServeBufferedAsync>d__19::MoveNext() - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - AspNet.Cache.CacheAttribute/<TryServeLegacyAsync>d__20 - - - - - System.Void AspNet.Cache.CacheAttribute/<TryServeLegacyAsync>d__20::MoveNext() - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - AspNet.Cache.Internal.CachedJsonResult - - - - - System.Boolean AspNet.Cache.Internal.CachedJsonResult::IsEmptyMarker(System.Byte[]) - - - - - - - - - - - System.Boolean AspNet.Cache.Internal.CachedJsonResult::IsEmptyMarker(System.ReadOnlySpan`1<System.Byte>) - - - - - - - - - - - System.Void AspNet.Cache.Internal.CachedJsonResult::.ctor(System.Byte[],System.Int32) - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CachedJsonResult::.cctor() - - - - - - - - - - - - AspNet.Cache.Internal.CachedJsonResult/<ExecuteResultAsync>d__5 - - - - - System.Void AspNet.Cache.Internal.CachedJsonResult/<ExecuteResultAsync>d__5::MoveNext() - - - - - - - - - - - - - - - - - - AspNet.Cache.Internal.CacheKeyBuilder - - - - - System.String AspNet.Cache.Internal.CacheKeyBuilder::Build(System.String,System.String,System.Collections.Generic.IDictionary`2<System.String,System.Object>,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CacheKeyBuilder::HashArguments(System.Collections.Generic.IDictionary`2<System.String,System.Object>,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions,System.Span`1<System.Byte>) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CacheKeyBuilder::WriteArgument(System.Text.Json.Utf8JsonWriter,System.String,System.Object,System.Func`2<System.String,System.Boolean>,System.Text.Json.JsonSerializerOptions) - - - - - - - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CacheKeyBuilder::WriteUpperHex(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>) - - - - - - - - - - - - - - - - - - AspNet.Cache.Internal.CacheLog - - - - - System.Void AspNet.Cache.Internal.CacheLog::GetFailed(Microsoft.Extensions.Logging.ILogger,System.Exception) - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CacheLog::SetFailed(Microsoft.Extensions.Logging.ILogger,System.Exception) - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.CacheLog::.cctor() - - - - - - - - - - - - - - - AspNet.Cache.Internal.PooledArrayBufferWriter - - - - - System.Boolean AspNet.Cache.Internal.PooledArrayBufferWriter::get_Overflowed() - - - - - - - - - - - System.ReadOnlySpan`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenSpan() - - - - - - - - - - - System.ReadOnlyMemory`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenMemory() - - - - - - - - - - - System.Int32 AspNet.Cache.Internal.PooledArrayBufferWriter::get_WrittenCount() - - - - - - - - - - - System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::Advance(System.Int32) - - - - - - - - - - - - - - - - - - - System.Memory`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::GetMemory(System.Int32) - - - - - - - - - - - - System.Span`1<System.Byte> AspNet.Cache.Internal.PooledArrayBufferWriter::GetSpan(System.Int32) - - - - - - - - - - - - System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::Dispose() - - - - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::EnsureCapacity(System.Int32) - - - - - - - - - - - - - - - - - - - - - - - - - - System.Void AspNet.Cache.Internal.PooledArrayBufferWriter::.ctor(System.Int32,System.Int32) - - - - - - - - - - - - - - - AspNet.Cache.Internal.PooledCachedJsonResult - - - - - System.Void AspNet.Cache.Internal.PooledCachedJsonResult::.ctor(AspNet.Cache.Internal.PooledArrayBufferWriter,System.Int32) - - - - - - - - - - - - - - - AspNet.Cache.Internal.PooledCachedJsonResult/<ExecuteResultAsync>d__4 - - - - - System.Void AspNet.Cache.Internal.PooledCachedJsonResult/<ExecuteResultAsync>d__4::MoveNext() - - - - - - - - - - - - - - - - - - - - - AspNet.Cache.Internal.SerializerDefaults - - - - - System.Void AspNet.Cache.Internal.SerializerDefaults::.cctor() - - - - - - - - - - - - - \ No newline at end of file From fa775727beb5c4ccce37b1db00bffa33e6fc7b24 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:12:16 -0300 Subject: [PATCH 09/16] style: apply dotnet format (utf-8 BOM per .editorconfig) Adds the UTF-8 BOM the .editorconfig requires for C# files. No code changes. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- AspNet.Cache/AspNetCacheOptions.cs | 2 +- AspNet.Cache/CacheAttribute.cs | 2 +- AspNet.Cache/Internal/CacheKeyBuilder.cs | 2 +- AspNet.Cache/Internal/CacheLog.cs | 2 +- AspNet.Cache/Internal/CachedJsonResult.cs | 2 +- AspNet.Cache/Internal/PooledArrayBufferWriter.cs | 2 +- AspNet.Cache/Internal/PooledCachedJsonResult.cs | 2 +- AspNet.Cache/Internal/SerializerDefaults.cs | 2 +- AspNet.Cache/TimeSpanType.cs | 2 +- benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs | 2 +- benchmarks/AspNet.Cache.Benchmarks/Program.cs | 2 +- samples/AspNet.Cache.Sample/Program.cs | 2 +- samples/AspNet.Cache.Sample/SampleController.cs | 2 +- test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs | 2 +- test/AspNet.Cache.Test/CacheAttributeTests.cs | 2 +- test/AspNet.Cache.Test/CacheIntegrationTests.cs | 2 +- test/AspNet.Cache.Test/CacheKeyBuilderTests.cs | 2 +- test/AspNet.Cache.Test/FaultyBufferCache.cs | 2 +- test/AspNet.Cache.Test/FilterContextFactory.cs | 2 +- test/AspNet.Cache.Test/InMemoryBufferCache.cs | 2 +- test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs | 2 +- 21 files changed, 21 insertions(+), 21 deletions(-) diff --git a/AspNet.Cache/AspNetCacheOptions.cs b/AspNet.Cache/AspNetCacheOptions.cs index 126b25c..cbddc3a 100644 --- a/AspNet.Cache/AspNetCacheOptions.cs +++ b/AspNet.Cache/AspNetCacheOptions.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Text.Json; namespace AspNet.Cache; diff --git a/AspNet.Cache/CacheAttribute.cs b/AspNet.Cache/CacheAttribute.cs index dbf5cfa..1addcd8 100644 --- a/AspNet.Cache/CacheAttribute.cs +++ b/AspNet.Cache/CacheAttribute.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Buffers; using System.Globalization; using System.Net; diff --git a/AspNet.Cache/Internal/CacheKeyBuilder.cs b/AspNet.Cache/Internal/CacheKeyBuilder.cs index 76238dc..32bad98 100644 --- a/AspNet.Cache/Internal/CacheKeyBuilder.cs +++ b/AspNet.Cache/Internal/CacheKeyBuilder.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Buffers; using System.Collections.Generic; using System.Security.Cryptography; diff --git a/AspNet.Cache/Internal/CacheLog.cs b/AspNet.Cache/Internal/CacheLog.cs index 01f3380..5ac2665 100644 --- a/AspNet.Cache/Internal/CacheLog.cs +++ b/AspNet.Cache/Internal/CacheLog.cs @@ -1,4 +1,4 @@ -using System; +using System; using Microsoft.Extensions.Logging; namespace AspNet.Cache.Internal; diff --git a/AspNet.Cache/Internal/CachedJsonResult.cs b/AspNet.Cache/Internal/CachedJsonResult.cs index ccff79a..b965faa 100644 --- a/AspNet.Cache/Internal/CachedJsonResult.cs +++ b/AspNet.Cache/Internal/CachedJsonResult.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; using Microsoft.AspNetCore.Mvc; diff --git a/AspNet.Cache/Internal/PooledArrayBufferWriter.cs b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs index e140e66..a985b7c 100644 --- a/AspNet.Cache/Internal/PooledArrayBufferWriter.cs +++ b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Buffers; namespace AspNet.Cache.Internal; diff --git a/AspNet.Cache/Internal/PooledCachedJsonResult.cs b/AspNet.Cache/Internal/PooledCachedJsonResult.cs index 0f75a8e..74cfbc4 100644 --- a/AspNet.Cache/Internal/PooledCachedJsonResult.cs +++ b/AspNet.Cache/Internal/PooledCachedJsonResult.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; using Microsoft.AspNetCore.Mvc; diff --git a/AspNet.Cache/Internal/SerializerDefaults.cs b/AspNet.Cache/Internal/SerializerDefaults.cs index e61b6cb..d2bd68b 100644 --- a/AspNet.Cache/Internal/SerializerDefaults.cs +++ b/AspNet.Cache/Internal/SerializerDefaults.cs @@ -1,4 +1,4 @@ -using System.Text.Json; +using System.Text.Json; namespace AspNet.Cache.Internal; diff --git a/AspNet.Cache/TimeSpanType.cs b/AspNet.Cache/TimeSpanType.cs index b8058d1..636d1b5 100644 --- a/AspNet.Cache/TimeSpanType.cs +++ b/AspNet.Cache/TimeSpanType.cs @@ -1,4 +1,4 @@ -namespace AspNet.Cache; +namespace AspNet.Cache; /// Unit used to interpret . public enum TimeSpanType diff --git a/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs b/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs index cb96119..5dd046c 100644 --- a/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs +++ b/benchmarks/AspNet.Cache.Benchmarks/CacheBenchmarks.cs @@ -1,4 +1,4 @@ -using System.Buffers; +using System.Buffers; using System.Text.Json; using AspNet.Cache.Internal; using AspNet.Cache.Test; diff --git a/benchmarks/AspNet.Cache.Benchmarks/Program.cs b/benchmarks/AspNet.Cache.Benchmarks/Program.cs index c83691f..b49023d 100644 --- a/benchmarks/AspNet.Cache.Benchmarks/Program.cs +++ b/benchmarks/AspNet.Cache.Benchmarks/Program.cs @@ -1,3 +1,3 @@ -using BenchmarkDotNet.Running; +using BenchmarkDotNet.Running; BenchmarkSwitcher.FromAssembly(typeof(AspNet.Cache.Benchmarks.CacheBenchmarks).Assembly).Run(args); diff --git a/samples/AspNet.Cache.Sample/Program.cs b/samples/AspNet.Cache.Sample/Program.cs index c2712f6..7503d90 100644 --- a/samples/AspNet.Cache.Sample/Program.cs +++ b/samples/AspNet.Cache.Sample/Program.cs @@ -1,4 +1,4 @@ -var builder = WebApplication.CreateBuilder(args); +var builder = WebApplication.CreateBuilder(args); builder.Services.AddControllers(); builder.Services.AddDistributedMemoryCache(); builder.Logging.SetMinimumLevel(LogLevel.Warning); diff --git a/samples/AspNet.Cache.Sample/SampleController.cs b/samples/AspNet.Cache.Sample/SampleController.cs index a93f4a3..cbb2fd3 100644 --- a/samples/AspNet.Cache.Sample/SampleController.cs +++ b/samples/AspNet.Cache.Sample/SampleController.cs @@ -1,4 +1,4 @@ -using AspNet.Cache; +using AspNet.Cache; using Microsoft.AspNetCore.Mvc; namespace AspNet.Cache.Sample; diff --git a/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs b/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs index 8eaa0f2..2e4b252 100644 --- a/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs +++ b/test/AspNet.Cache.Test/CacheAttributeCoverageTests.cs @@ -1,4 +1,4 @@ -using System.Net; +using System.Net; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc.Filters; using Microsoft.Extensions.Caching.Distributed; diff --git a/test/AspNet.Cache.Test/CacheAttributeTests.cs b/test/AspNet.Cache.Test/CacheAttributeTests.cs index 21bab69..21ce72b 100644 --- a/test/AspNet.Cache.Test/CacheAttributeTests.cs +++ b/test/AspNet.Cache.Test/CacheAttributeTests.cs @@ -1,4 +1,4 @@ -using System.Net; +using System.Net; using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.DependencyInjection; diff --git a/test/AspNet.Cache.Test/CacheIntegrationTests.cs b/test/AspNet.Cache.Test/CacheIntegrationTests.cs index 4fc5044..28469ec 100644 --- a/test/AspNet.Cache.Test/CacheIntegrationTests.cs +++ b/test/AspNet.Cache.Test/CacheIntegrationTests.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.TestHost; diff --git a/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs b/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs index 740c50d..aca666f 100644 --- a/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs +++ b/test/AspNet.Cache.Test/CacheKeyBuilderTests.cs @@ -1,4 +1,4 @@ -using System.Text.Json; +using System.Text.Json; using AspNet.Cache.Internal; using Shouldly; using Xunit; diff --git a/test/AspNet.Cache.Test/FaultyBufferCache.cs b/test/AspNet.Cache.Test/FaultyBufferCache.cs index 1a72f29..60d3e90 100644 --- a/test/AspNet.Cache.Test/FaultyBufferCache.cs +++ b/test/AspNet.Cache.Test/FaultyBufferCache.cs @@ -1,4 +1,4 @@ -using System.Buffers; +using System.Buffers; using System.Collections.Concurrent; using Microsoft.Extensions.Caching.Distributed; diff --git a/test/AspNet.Cache.Test/FilterContextFactory.cs b/test/AspNet.Cache.Test/FilterContextFactory.cs index c82962a..b47a45f 100644 --- a/test/AspNet.Cache.Test/FilterContextFactory.cs +++ b/test/AspNet.Cache.Test/FilterContextFactory.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc.Abstractions; using Microsoft.AspNetCore.Mvc.Filters; diff --git a/test/AspNet.Cache.Test/InMemoryBufferCache.cs b/test/AspNet.Cache.Test/InMemoryBufferCache.cs index d8dc1bd..d4f519b 100644 --- a/test/AspNet.Cache.Test/InMemoryBufferCache.cs +++ b/test/AspNet.Cache.Test/InMemoryBufferCache.cs @@ -1,4 +1,4 @@ -using System.Buffers; +using System.Buffers; using System.Collections.Concurrent; using Microsoft.Extensions.Caching.Distributed; diff --git a/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs b/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs index 3d37625..c71f905 100644 --- a/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs +++ b/test/AspNet.Cache.Test/PooledArrayBufferWriterTests.cs @@ -1,4 +1,4 @@ -using AspNet.Cache.Internal; +using AspNet.Cache.Internal; using Shouldly; using Xunit; From 2ca0359b81881624857a779385f15e43c273e8c2 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 16:12:16 -0300 Subject: [PATCH 10/16] feat: multi-target net8.0, net9.0 and net10.0 Ships lib/net8.0, lib/net9.0 and lib/net10.0 in the package so consumers on each LTS/STS get a matching build. IBufferDistributedCache comes from the 9.0 package on net8.0 and from the shared framework on net9.0+. CI/release install the 10.0.x SDK; README documents the target set. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/ci.yml | 2 ++ .github/workflows/release.yml | 1 + AspNet.Cache/AspNet.Cache.csproj | 7 ++++++- README.md | 8 +++++--- 4 files changed, 14 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d438b8e..d7917c9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -25,6 +25,7 @@ jobs: dotnet-version: | 8.0.x 9.0.x + 10.0.x - name: Setup Java 17 (SonarScanner requirement) if: env.SONAR_TOKEN != '' @@ -80,6 +81,7 @@ jobs: dotnet-version: | 8.0.x 9.0.x + 10.0.x - name: Run benchmarks (short job) run: dotnet run -c Release --project benchmarks/AspNet.Cache.Benchmarks -- --filter "*CacheBenchmarks*" --job short --exporters json diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 5f3f833..9aae6e6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -21,6 +21,7 @@ jobs: dotnet-version: | 8.0.x 9.0.x + 10.0.x - name: Extract version from tag run: echo "VERSION=${GITHUB_REF_NAME#v}" >> "$GITHUB_ENV" diff --git a/AspNet.Cache/AspNet.Cache.csproj b/AspNet.Cache/AspNet.Cache.csproj index 9aa692b..563c0ec 100644 --- a/AspNet.Cache/AspNet.Cache.csproj +++ b/AspNet.Cache/AspNet.Cache.csproj @@ -1,7 +1,7 @@ - net8.0 + net8.0;net9.0;net10.0 latest enable enable @@ -30,6 +30,11 @@ + + + + diff --git a/README.md b/README.md index 275407d..ecb3fa4 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,8 @@ route + arguments are served straight from the cache — the action never execut dotnet add package AspNet.Cache ``` -Requires .NET 8.0+. +Multi-targets **.NET 8.0, 9.0 and 10.0**. On net9.0+ the `IBufferDistributedCache` fast path is used +automatically when the provider supports it. ## Quick start @@ -134,7 +135,7 @@ per operation are deterministic, so regressions fail the build. | Change | Impact | |---|---| -| Target framework `netstandard2.1` → `net8.0` | Apps must run .NET 8+ | +| Target framework `netstandard2.1` → `net8.0`/`net9.0`/`net10.0` | Apps must run .NET 8+ | | Newtonsoft.Json → System.Text.Json | Serialization follows your MVC JSON options (camelCase by default) | | Key format internals changed | Existing cache entries miss once after upgrade (cache warms itself) | | `Cache-Control: max-age` | Now correct (`TotalSeconds`; v1 emitted the 0–59 component) | @@ -188,7 +189,8 @@ mesmo path + argumentos são servidas direto do cache — a action nem executa. dotnet add package AspNet.Cache ``` -Requer .NET 8.0+. +Multi-target **.NET 8.0, 9.0 e 10.0**. No net9.0+ o fast path `IBufferDistributedCache` é usado +automaticamente quando o provider suporta. ## Início rápido From acc6b7b313b6f32a1e8c6225eb970468dd893a03 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 17:23:47 -0300 Subject: [PATCH 11/16] docs: add SonarCloud quality gate and coverage badges Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index ecb3fa4..62b8532 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,8 @@ # AspNet.Cache [![CI](https://github.com/slipalison/AspNet.Cache/actions/workflows/ci.yml/badge.svg)](https://github.com/slipalison/AspNet.Cache/actions/workflows/ci.yml) +[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=slipalison_AspNet.Cache&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=slipalison_AspNet.Cache) +[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=slipalison_AspNet.Cache&metric=coverage)](https://sonarcloud.io/summary/new_code?id=slipalison_AspNet.Cache) [![NuGet](https://img.shields.io/nuget/v/AspNet.Cache.svg)](https://www.nuget.org/packages/AspNet.Cache/) [![Downloads](https://img.shields.io/nuget/dt/AspNet.Cache.svg)](https://www.nuget.org/packages/AspNet.Cache/) From 0fab37870b44acf1d23e0e1230d112583ee03922 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 17:36:07 -0300 Subject: [PATCH 12/16] fix: resolve SonarQube findings (dispose, assignment, pinned actions, secret env) - CacheAttribute.TryServeBufferedAsync: dispose the pooled buffer once in a finally guarded by a handed-off flag (S3966 redundant dispose). - CacheKeyBuilder: hoist the rented-array assignment out of the span initializer (S1121 assignment in sub-expression), keeping stackalloc ref-safe. - Pin all GitHub Actions to full commit SHAs (S7637). - Pass NUGET_API_KEY via env instead of expanding the secret in the run block (S7636). Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/ci.yml | 10 +++++----- .github/workflows/release.yml | 8 +++++--- AspNet.Cache/CacheAttribute.cs | 15 +++++++-------- AspNet.Cache/Internal/CacheKeyBuilder.cs | 8 ++++---- 4 files changed, 21 insertions(+), 20 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d7917c9..f74a035 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,12 +15,12 @@ jobs: SONAR_PROJECT_KEY: ${{ vars.SONAR_PROJECT_KEY }} SONAR_ORGANIZATION: ${{ vars.SONAR_ORGANIZATION }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 with: fetch-depth: 0 - name: Setup .NET - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4 with: dotnet-version: | 8.0.x @@ -29,7 +29,7 @@ jobs: - name: Setup Java 17 (SonarScanner requirement) if: env.SONAR_TOKEN != '' - uses: actions/setup-java@v4 + uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4 with: distribution: temurin java-version: '17' @@ -73,10 +73,10 @@ jobs: allocation-gate: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 - name: Setup .NET - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4 with: dotnet-version: | 8.0.x diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 9aae6e6..5465aa3 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -11,12 +11,12 @@ jobs: release: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 with: fetch-depth: 0 - name: Setup .NET - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4 with: dotnet-version: | 8.0.x @@ -42,9 +42,11 @@ jobs: /p:ContinuousIntegrationBuild=true - name: Push to NuGet.org + env: + NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} run: > dotnet nuget push "out/*.nupkg" - --api-key "${{ secrets.NUGET_API_KEY }}" + --api-key "$NUGET_API_KEY" --source https://api.nuget.org/v3/index.json --skip-duplicate diff --git a/AspNet.Cache/CacheAttribute.cs b/AspNet.Cache/CacheAttribute.cs index 1addcd8..01505d1 100644 --- a/AspNet.Cache/CacheAttribute.cs +++ b/AspNet.Cache/CacheAttribute.cs @@ -81,34 +81,33 @@ public override async Task OnActionExecutionAsync(ActionExecutingContext context IServiceProvider services, CancellationToken cancellationToken) { var buffer = new PooledArrayBufferWriter(); + var handedOff = false; try { var found = await cache.TryGetAsync(key, buffer, cancellationToken).ConfigureAwait(false); if (!found || buffer.WrittenCount == 0) - { - buffer.Dispose(); return null; - } if (CachedJsonResult.IsEmptyMarker(buffer.WrittenSpan)) - { - buffer.Dispose(); return new StatusCodeResult((int)SuccessStatus); - } + handedOff = true; return new PooledCachedJsonResult(buffer, (int)SuccessStatus); } catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { - buffer.Dispose(); throw; } catch (Exception exception) { - buffer.Dispose(); CacheLog.GetFailed(ResolveLogger(services), exception); return null; } + finally + { + if (!handedOff) + buffer.Dispose(); + } } private async Task TryServeLegacyAsync(IDistributedCache cache, string key, diff --git a/AspNet.Cache/Internal/CacheKeyBuilder.cs b/AspNet.Cache/Internal/CacheKeyBuilder.cs index 32bad98..da1ab89 100644 --- a/AspNet.Cache/Internal/CacheKeyBuilder.cs +++ b/AspNet.Cache/Internal/CacheKeyBuilder.cs @@ -24,10 +24,10 @@ public static string Build(string folder, string? path, IDictionary destination = totalLength <= StackallocCharThreshold - ? stackalloc char[StackallocCharThreshold] - : rented = ArrayPool.Shared.Rent(totalLength); + char[]? rented = totalLength <= StackallocCharThreshold + ? null + : ArrayPool.Shared.Rent(totalLength); + Span destination = rented ?? stackalloc char[StackallocCharThreshold]; var position = 0; if (prefixLength != 0) From 7821b7e70eee49a5b5c47abe20c0c747b7f5fbb9 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 17:39:52 -0300 Subject: [PATCH 13/16] ci: let SonarQube analysis build complete without solution-wide warnaserror The library keeps TreatWarningsAsErrors via its csproj; not forcing it across the solution stops SonarAnalyzer smells in the Sonar-excluded sample/benchmark projects from failing the analysis build. Strict -warnaserror still runs in the allocation-gate job and locally. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/ci.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f74a035..39d0023 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -54,8 +54,11 @@ jobs: - name: Restore run: dotnet restore AspNet.Cache.sln + # The library enforces TreatWarningsAsErrors via its own csproj; not forcing it solution-wide + # here keeps SonarAnalyzer smells in the excluded sample/benchmark projects from breaking the + # analysis build. The strict -warnaserror gate runs in the allocation-gate job and locally. - name: Build - run: dotnet build AspNet.Cache.sln -c Release --no-restore -warnaserror + run: dotnet build AspNet.Cache.sln -c Release --no-restore /p:TreatWarningsAsErrors=false - name: Test with coverage run: > From 0e14c9878ba83c9b252ab4f188d4835cee790137 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 17:44:31 -0300 Subject: [PATCH 14/16] style: clear remaining SonarQube INFO smells - CacheKeyBuilder: use var for the rented array and destination span (IDE0007), consistent with the rest of the method. - PooledArrayBufferWriter: expose the write cursor as an auto-property (IDE0032). - Suppress CA1822 on the integration-test controller action with a justification (MVC action methods must be instance methods). Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- AspNet.Cache/Internal/CacheKeyBuilder.cs | 4 +-- .../Internal/PooledArrayBufferWriter.cs | 27 +++++++++---------- .../CacheIntegrationTests.cs | 2 ++ 3 files changed, 17 insertions(+), 16 deletions(-) diff --git a/AspNet.Cache/Internal/CacheKeyBuilder.cs b/AspNet.Cache/Internal/CacheKeyBuilder.cs index da1ab89..71210aa 100644 --- a/AspNet.Cache/Internal/CacheKeyBuilder.cs +++ b/AspNet.Cache/Internal/CacheKeyBuilder.cs @@ -24,10 +24,10 @@ public static string Build(string folder, string? path, IDictionary.Shared.Rent(totalLength); - Span destination = rented ?? stackalloc char[StackallocCharThreshold]; + var destination = rented ?? stackalloc char[StackallocCharThreshold]; var position = 0; if (prefixLength != 0) diff --git a/AspNet.Cache/Internal/PooledArrayBufferWriter.cs b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs index a985b7c..3fb3693 100644 --- a/AspNet.Cache/Internal/PooledArrayBufferWriter.cs +++ b/AspNet.Cache/Internal/PooledArrayBufferWriter.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Buffers; namespace AspNet.Cache.Internal; @@ -11,7 +11,6 @@ internal sealed class PooledArrayBufferWriter : IBufferWriter, IDisposable private const int DefaultInitialCapacity = 4096; private byte[] _buffer; - private int _written; private readonly int _softLimit; public PooledArrayBufferWriter(int softLimit = int.MaxValue, int initialCapacity = DefaultInitialCapacity) @@ -21,38 +20,38 @@ public PooledArrayBufferWriter(int softLimit = int.MaxValue, int initialCapacity } /// True when more than the configured soft limit has been written; the caller must discard the content. - public bool Overflowed => _written > _softLimit; + public bool Overflowed => WrittenCount > _softLimit; - public ReadOnlySpan WrittenSpan => _buffer.AsSpan(0, _written); + public ReadOnlySpan WrittenSpan => _buffer.AsSpan(0, WrittenCount); - public ReadOnlyMemory WrittenMemory => _buffer.AsMemory(0, _written); + public ReadOnlyMemory WrittenMemory => _buffer.AsMemory(0, WrittenCount); - public int WrittenCount => _written; + public int WrittenCount { get; private set; } public void Advance(int count) { - if (count < 0 || _written + count > _buffer.Length) + if (count < 0 || WrittenCount + count > _buffer.Length) throw new ArgumentOutOfRangeException(nameof(count)); - _written += count; + WrittenCount += count; } public Memory GetMemory(int sizeHint = 0) { EnsureCapacity(sizeHint); - return _buffer.AsMemory(_written); + return _buffer.AsMemory(WrittenCount); } public Span GetSpan(int sizeHint = 0) { EnsureCapacity(sizeHint); - return _buffer.AsSpan(_written); + return _buffer.AsSpan(WrittenCount); } public void Dispose() { var buffer = _buffer; _buffer = Array.Empty(); - _written = 0; + WrittenCount = 0; if (buffer.Length > 0) ArrayPool.Shared.Return(buffer); } @@ -61,12 +60,12 @@ private void EnsureCapacity(int sizeHint) { if (sizeHint < 1) sizeHint = 1; - if (_buffer.Length - _written >= sizeHint) + if (_buffer.Length - WrittenCount >= sizeHint) return; - var newSize = Math.Max(_buffer.Length * 2, _written + sizeHint); + var newSize = Math.Max(_buffer.Length * 2, WrittenCount + sizeHint); var next = ArrayPool.Shared.Rent(newSize); - _buffer.AsSpan(0, _written).CopyTo(next); + _buffer.AsSpan(0, WrittenCount).CopyTo(next); var previous = _buffer; _buffer = next; ArrayPool.Shared.Return(previous); diff --git a/test/AspNet.Cache.Test/CacheIntegrationTests.cs b/test/AspNet.Cache.Test/CacheIntegrationTests.cs index 28469ec..38e71c2 100644 --- a/test/AspNet.Cache.Test/CacheIntegrationTests.cs +++ b/test/AspNet.Cache.Test/CacheIntegrationTests.cs @@ -76,6 +76,8 @@ public sealed class CounterController : ControllerBase [HttpGet] [Cache(ExpireAt = 5, TimeSpanType = TimeSpanType.FromMinutes)] + [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static", + Justification = "MVC action methods must be instance methods.")] public CounterPayload Get(int id) { Interlocked.Increment(ref _executions); From c5a692327b1504e30f0e50d19b09995695c23f3a Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 18:08:28 -0300 Subject: [PATCH 15/16] ci: publish to NuGet via Trusted Publishing (OIDC) Replace the NUGET_API_KEY secret with NuGet Trusted Publishing: request an id-token, exchange it through NuGet/login for a short-lived key, then push. No long-lived API key to store or rotate. Action pinned to its commit SHA. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/release.yml | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 5465aa3..8e03ae0 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -5,6 +5,7 @@ on: tags: ['v*'] permissions: + id-token: write # NuGet Trusted Publishing (OIDC) — no API key secret needed contents: write jobs: @@ -41,9 +42,15 @@ jobs: /p:Version=${{ env.VERSION }} /p:ContinuousIntegrationBuild=true + - name: NuGet login (Trusted Publishing) + id: nuget-login + uses: NuGet/login@8d196754b4036150537f80ac539e15c2f1028841 # v1 + with: + user: slipalison + - name: Push to NuGet.org env: - NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} + NUGET_API_KEY: ${{ steps.nuget-login.outputs.NUGET_API_KEY }} run: > dotnet nuget push "out/*.nupkg" --api-key "$NUGET_API_KEY" From d4e2127880a5bb5be32f56ce4e9370a5d19d1992 Mon Sep 17 00:00:00 2001 From: Alison Amorim Date: Sun, 19 Jul 2026 18:11:36 -0300 Subject: [PATCH 16/16] ci: run release job in the production environment for Trusted Publishing The NuGet Trusted Publisher policy pins Environment=production, so the OIDC token must carry that claim. Declare the environment on the release job. Claude-Session: https://claude.ai/code/session_01V1QeCENrvWQ1u6zN1qzBAU --- .github/workflows/release.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 8e03ae0..aec382c 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -11,6 +11,7 @@ permissions: jobs: release: runs-on: ubuntu-latest + environment: production # matches the NuGet Trusted Publishing policy's Environment claim steps: - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4 with: