Fix: Resolve all build warnings

samples/Api/Api.csproj

@@ -8,7 +8,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNet.WebApi" Version="5.3.0" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.10" />

src/AzureCosmos/AzureCosmosCache.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using Microsoft.Azure.Cosmos;
 using ActionCache.Common;
@@ -40,6 +41,7 @@ public AzureCosmosActionCache(Container cache, ActionCacheContext<NullCacheLock>
     /// </summary>
     /// <param name="key">The key of the cache entry.</param>
     /// <returns>The cached value or null if not found.</returns> 
+#pragma warning disable CS8609
     public override async Task<TValue> GetAsync<TValue>(string key)
     {
         try
@@ -76,13 +78,14 @@ await Cache.ReplaceItemAsync(
             return default!;
         }
     }
+#pragma warning restore CS8609
 
     /// <summary>
     /// Asynchronously sets a value in the cache.
     /// </summary>
     /// <param name="key">The cache key to set the value for.</param>
     /// <param name="value">The value to set in the cache.</param>
-    public override Task SetAsync<TValue>(string key, TValue value)
+    public override Task SetAsync<TValue>(string key, [AllowNull] TValue value)
     {
         var (absoluteExpiration, slidingExpiration, ttl) = EntryOptions;
 

src/Common/EndpointFilters/Extensions/Internal/EndpointFilterInvocationContextExtensions.cs

@@ -29,12 +29,13 @@ internal static bool TryGetKey(this EndpointFilterInvocationContext context, out
         {
             var parameters = endpoint.RequestDelegate?.Method.GetParameters() ?? [];
             var actionArguments = parameters?
-                .Zip(context.Arguments, (parameter, argument) => (parameter.Name, argument))?
-                .ToDictionary();
+                .Zip(context.Arguments, (parameter, argument) => (parameter.Name, argument))
+                .Where(pair => pair.Name is not null)
+                .ToDictionary(pair => pair.Name!, pair => pair.argument);
 
             key = new ActionCacheKeyBuilder()
                 .WithRouteValues(context.HttpContext.GetRouteData().Values)
-                .WithActionArguments(actionArguments)
+                .WithActionArguments(actionArguments ?? [])
                 .Build();
 
             if (string.IsNullOrWhiteSpace(key))

src/Common/EndpointFilters/Extensions/RouteHandlerBuilderExtensions.cs

@@ -73,7 +73,7 @@ private class EndpointFilterInvocationContextSource
         /// <param name="context">The filter invocation context.</param>
         /// <param name="attribute">When this method returns, contains the attribute if found; otherwise, <c>null</c>.</param>
         /// <returns><c>true</c> if the attribute was found; otherwise, <c>false</c>.</returns>
-        internal bool TryGetValue<T>(EndpointFilterInvocationContext context, out T? attribute) where T : Attribute
+        internal bool TryGetValue<T>(EndpointFilterInvocationContext context, [NotNullWhen(true)] out T? attribute) where T : Attribute
         {
             var endpoint = context.HttpContext.GetEndpoint();
             if (endpoint is null)

src/Common/Keys/ActionCacheKeyBuilder.cs

@@ -38,7 +38,7 @@ public ActionCacheKeyBuilder WithRouteValues(RouteValueDictionary routeValues)
     /// </summary>
     /// <param name="actionArguments">Arguments for the action.</param>
     /// <returns>Returns itself for chaining.</returns>
-    public ActionCacheKeyBuilder WithActionArguments(IDictionary<string, object?> actionArguments)
+    public ActionCacheKeyBuilder WithActionArguments(IDictionary<string, object?>? actionArguments)
     {
         if (actionArguments is null) return this;
         KeyComponents.ActionArguments = actionArguments.ToDictionary();

src/Common/Serialization/Converters/ActionArgumentsConverter.cs

@@ -34,7 +34,7 @@ JsonSerializer serializer
         foreach (var property in obj.Properties())
         {
             var value = ConvertToken(property.Value, serializer);
-            result.Add(property.Name, value);
+            result.Add(property.Name, value!);
         }
 
         return result;

src/Memory/MemoryActionCache.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using ActionCache.Common.Caching;
 using ActionCache.Common.Concurrency.Locks;
 using ActionCache.Memory.Extensions.Internal;
@@ -55,15 +56,17 @@ private MemoryCacheEntryOptions CreateEntryOptions() =>
     /// </summary>
     /// <param name="key">The key of the cache entry.</param>
     /// <returns>The cached value or null if not found.</returns> 
+#pragma warning disable CS8609, CS8619
     public override Task<TValue> GetAsync<TValue>(string key) =>
         Task.FromResult(Cache.Get<TValue>(Namespace.Create(key)));
+#pragma warning restore CS8609, CS8619
 
     /// <summary>
     /// Asynchronously sets a value in the cache.
     /// </summary>
     /// <param name="key">The cache key to set the value for.</param>
     /// <param name="value">The value to set in the cache.</param>
-    public override Task SetAsync<TValue>(string key, TValue value)
+    public override Task SetAsync<TValue>(string key, [AllowNull] TValue value)
     {
         var entryOptions = CreateEntryOptions();
         Cache.Set(Namespace.Create(key), value, entryOptions);

src/Redis/RedisActionCache.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using ActionCache.Common;
 using ActionCache.Common.Caching;
 using ActionCache.Common.Concurrency.Locks;
@@ -75,7 +76,7 @@ public override async Task RemoveAsync()
     /// </summary>
     /// <param name="key">The key of the item to set in the cache.</param>
     /// <param name="value">The value of the item to set in the cache.</param>
-    public override async Task SetAsync<TValue>(string key, TValue value)
+    public override async Task SetAsync<TValue>(string key, [AllowNull] TValue value)
     {
         RedisValue redisValue = CacheJsonSerializer.Serialize(value);
 
@@ -111,6 +112,7 @@ await Cache.HashSetAsync(Namespace.Create(key),
     /// </summary>
     /// <param name="key">The key of the item to retrieve from the cache.</param>
     /// <returns>The cached item if found, otherwise default.</returns>
+#pragma warning disable CS8609
     public override async Task<TValue> GetAsync<TValue>(string key)
     {
         var namespaceKey = Namespace.Create(key);
@@ -127,7 +129,7 @@ public override async Task<TValue> GetAsync<TValue>(string key)
             await Cache.SortedSetRemoveAsync((string)Namespace, key);
             return default!;
         }
-        
+
         if (ActionCacheEntryOptions.HasSlidingExpiration(hashEntries.GetSlidingExpiration()))
         {
             await Cache.KeyExpireAsync(namespaceKey, TimeSpan.FromMilliseconds(hashEntries.GetSlidingExpiration()), CommandFlags.FireAndForget);
@@ -143,6 +145,7 @@ public override async Task<TValue> GetAsync<TValue>(string key)
             return CacheJsonSerializer.Deserialize<TValue>(jsonValue)!;
         }
     }
+#pragma warning restore CS8609
 
     /// <inheritdoc/>
     public override async Task<IEnumerable<string>> GetKeysAsync()

src/SqlServer/SqlServerActionCache.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using ActionCache.Common.Caching;
 using ActionCache.SqlServer.Concurrency.Locks;
 using ActionCache.Common.Serialization;
@@ -45,6 +46,7 @@ private DistributedCacheEntryOptions CreateEntryOptions() =>
     /// <typeparam name="TValue">The type of the cached value.</typeparam>
     /// <param name="key">The key of the cache entry.</param>
     /// <returns>The cached value or the default value of the type if not found.</returns>
+#pragma warning disable CS8609
     public override async Task<TValue> GetAsync<TValue>(string key)
     {
         var json = await Cache.GetStringAsync(Namespace.Create(key));
@@ -57,14 +59,15 @@ public override async Task<TValue> GetAsync<TValue>(string key)
             return CacheJsonSerializer.Deserialize<TValue>(json)!;
         }
     }
+#pragma warning restore CS8609
 
     /// <summary>
     /// Asynchronously sets a value in the cache.
     /// </summary>
     /// <typeparam name="TValue">The type of the value to set in the cache.</typeparam>
     /// <param name="key">The cache key to set the value for.</param>
     /// <param name="value">The value to set in the cache.</param>
-    public override async Task SetAsync<TValue>(string key, TValue value)
+    public override async Task SetAsync<TValue>(string key, [AllowNull] TValue value)
     {
         var entryOptions = CreateEntryOptions();
         await Cache.SetStringAsync(Namespace.Create(key), CacheJsonSerializer.Serialize(value), entryOptions);

test/Integration/ActionCache/Test_ActionCache_CacheStatus_Add.cs

@@ -1,36 +1,33 @@
+using System.Reflection;
 using ActionCache;
 using ActionCache.Common.Enums;
 using ActionCache.Common.Extensions;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
 
 [TestFixture]
 public class Test_ActionCache_CacheStatus_Add
 {
-    TestServer Server;
+    WebApplication App;
     HttpClient Client;
 
     [SetUp]
-    public void Setup()
+    public async Task Setup()
     {
-        var builder = new WebHostBuilder()
-            .ConfigureServices(services => 
-            {
-                services.AddMvc();
-                services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
-            })
-            .Configure(app =>
-            {
-                app.UseHttpsRedirection();
-                app.UseRouting();
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseTestServer();
+        builder.Services.AddMvc()
+            .AddApplicationPart(Assembly.GetExecutingAssembly());
+        builder.Services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
 
-                app.UseEndpoints(options => options.MapControllers());
-            });
+        App = builder.Build();
+        App.UseHttpsRedirection();
+        App.UseRouting();
+        App.UseEndpoints(options => options.MapControllers());
 
-        Server = new TestServer(builder);
-        Client = Server.CreateClient();
+        await App.StartAsync();
+        Client = App.GetTestServer().CreateClient();
     }
 
     [Test]
@@ -64,8 +61,9 @@
     [TearDown]
     public async Task TearDown()
     {
-        var cacheFactory = Server.Services.GetRequiredService<IActionCacheFactory>();
+        var cacheFactory = App.Services.GetRequiredService<IActionCacheFactory>();
         var cache = cacheFactory.Create("Users");
         await cache!.RemoveAsync();
+        await App.StopAsync();
     }
 }

test/Integration/ActionCache/Test_ActionCache_CacheStatus_Evict.cs

@@ -1,36 +1,33 @@
+using System.Reflection;
 using ActionCache;
 using ActionCache.Common.Enums;
 using ActionCache.Common.Extensions;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
 
 [TestFixture]
 public class Test_ActionCache_Eviction
 {
-    TestServer Server;
+    WebApplication App;
     HttpClient Client;
 
     [SetUp]
-    public void Setup()
+    public async Task Setup()
     {
-        var builder = new WebHostBuilder()
-            .ConfigureServices(services => 
-            {
-                services.AddMvc();
-                services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
-            })
-            .Configure(app =>
-            {
-                app.UseHttpsRedirection();
-                app.UseRouting();
-
-                app.UseEndpoints(options => options.MapControllers());
-            });
-
-        Server = new TestServer(builder);
-        Client = Server.CreateClient();
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseTestServer();
+        builder.Services.AddMvc()
+            .AddApplicationPart(Assembly.GetExecutingAssembly());
+        builder.Services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
+
+        App = builder.Build();
+        App.UseHttpsRedirection();
+        App.UseRouting();
+        App.UseEndpoints(options => options.MapControllers());
+
+        await App.StartAsync();
+        Client = App.GetTestServer().CreateClient();
     }
 
     [Test]
@@ -57,8 +54,9 @@
     [TearDown]
     public async Task TearDown()
     {
-        var cacheFactory = Server.Services.GetRequiredService<IActionCacheFactory>();
+        var cacheFactory = App.Services.GetRequiredService<IActionCacheFactory>();
         var cache = cacheFactory.Create("Users");
         await cache!.RemoveAsync();
+        await App.StopAsync();
     }
 }

test/Integration/ActionCache/Test_ActionCache_CacheStatus_Hit.cs

@@ -1,36 +1,33 @@
+using System.Reflection;
 using ActionCache;
 using ActionCache.Common.Enums;
 using ActionCache.Common.Extensions;
 using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
 
 [TestFixture]
 public class Test_ActionCache_CacheStatus_Hit
 {
-    TestServer Server;
+    WebApplication App;
     HttpClient Client;
 
     [SetUp]
-    public void Setup()
+    public async Task Setup()
     {
-        var builder = new WebHostBuilder()
-            .ConfigureServices(services => 
-            {
-                services.AddMvc();
-                services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
-            })
-            .Configure(app =>
-            {
-                app.UseHttpsRedirection();
-                app.UseRouting();
-
-                app.UseEndpoints(options => options.MapControllers());
-            });
-
-        Server = new TestServer(builder);
-        Client = Server.CreateClient();
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseTestServer();
+        builder.Services.AddMvc()
+            .AddApplicationPart(Assembly.GetExecutingAssembly());
+        builder.Services.AddActionCache(options => options.UseRedisCache("127.0.0.1:6379"));
+
+        App = builder.Build();
+        App.UseHttpsRedirection();
+        App.UseRouting();
+        App.UseEndpoints(options => options.MapControllers());
+
+        await App.StartAsync();
+        Client = App.GetTestServer().CreateClient();
     }
 
     [Test]
@@ -50,8 +47,9 @@
     [TearDown]
     public async Task TearDown()
     {
-        var cacheFactory = Server.Services.GetRequiredService<IActionCacheFactory>();
+        var cacheFactory = App.Services.GetRequiredService<IActionCacheFactory>();
         var cache = cacheFactory.Create("Users");
         await cache!.RemoveAsync();
+        await App.StopAsync();
     }
 }