Initial Commit

Author: Taiizor

src/CacheFlow/Core/BufferCacheProvider.cs

@@ -1,7 +1,7 @@
-using System.Buffers;
 using CacheFlow.Abstractions;
 using CacheFlow.Internal.Buffers;
 using Microsoft.Extensions.Logging;
+using System.Buffers;
 
 namespace CacheFlow.Core
 {
@@ -25,7 +25,9 @@ public async ValueTask<bool> TryGetBufferAsync(string key, IBufferWriter<byte> w
             {
                 byte[]? buffer = await _innerProvider.GetAsync<byte[]>(key, token);
                 if (buffer == null)
+                {
                     return false;
+                }
 
                 Span<byte> span = writer.GetSpan(buffer.Length);
                 buffer.CopyTo(span);
@@ -45,7 +47,7 @@ public async ValueTask SetBufferAsync(string key, ReadOnlySequence<byte> value,
         {
             try
             {
-                using RecyclableArrayBufferWriter<byte> writer = new RecyclableArrayBufferWriter<byte>((int)value.Length);
+                using RecyclableArrayBufferWriter<byte> writer = new((int)value.Length);
                 foreach (ReadOnlyMemory<byte> segment in value)
                 {
                     Span<byte> span = writer.GetSpan(segment.Length);
@@ -97,20 +99,30 @@ public ValueTask SetBufferAsync(string key, ReadOnlyMemory<byte> value,
         }
 
         // ICacheProvider implementation
-        public ValueTask<T?> GetAsync<T>(string key, CancellationToken token = default) =>
-            _innerProvider.GetAsync<T>(key, token);
+        public ValueTask<T?> GetAsync<T>(string key, CancellationToken token = default)
+        {
+            return _innerProvider.GetAsync<T>(key, token);
+        }
 
         public ValueTask SetAsync<T>(string key, T value, DateTimeOffset? absoluteExpiration = null,
-            TimeSpan? slidingExpiration = null, CancellationToken token = default) =>
-            _innerProvider.SetAsync(key, value, absoluteExpiration, slidingExpiration, token);
+            TimeSpan? slidingExpiration = null, CancellationToken token = default)
+        {
+            return _innerProvider.SetAsync(key, value, absoluteExpiration, slidingExpiration, token);
+        }
 
-        public ValueTask RemoveAsync(string key, CancellationToken token = default) =>
-            _innerProvider.RemoveAsync(key, token);
+        public ValueTask RemoveAsync(string key, CancellationToken token = default)
+        {
+            return _innerProvider.RemoveAsync(key, token);
+        }
 
-        public ValueTask<bool> ExistsAsync(string key, CancellationToken token = default) =>
-            _innerProvider.ExistsAsync(key, token);
+        public ValueTask<bool> ExistsAsync(string key, CancellationToken token = default)
+        {
+            return _innerProvider.ExistsAsync(key, token);
+        }
 
-        public ValueTask RefreshAsync(string key, CancellationToken token = default) =>
-            _innerProvider.RefreshAsync(key, token);
+        public ValueTask RefreshAsync(string key, CancellationToken token = default)
+        {
+            return _innerProvider.RefreshAsync(key, token);
+        }
     }
 }

src/CacheFlow/Extensions/BufferCacheExtensions.cs

@@ -47,10 +47,14 @@ public static IServiceCollection AddBufferCache(this IServiceCollection services
         public static IBufferCacheProvider WithBufferSupport(this ICacheProvider provider, ILogger<BufferCacheProvider> logger)
         {
             if (provider == null)
+            {
                 throw new ArgumentNullException(nameof(provider));
+            }
 
             if (logger == null)
+            {
                 throw new ArgumentNullException(nameof(logger));
+            }
 
             return new BufferCacheProvider(provider, logger);
         }

src/CacheFlow/Internal/Buffers/BufferChunk.cs

@@ -49,7 +49,7 @@ public BufferChunk(int minimumLength)
         /// The returned Memory instance represents a view over the rented array,
         /// limited to the requested minimum length from the constructor.
         /// </remarks>
-        public Memory<T> Array => new Memory<T>(_rentedArray, 0, Length);
+        public Memory<T> Array => new(_rentedArray, 0, Length);
 
         /// <summary>
         /// Gets the length of the usable portion of the buffer.