fix: use backing ibufferdistributedcache

Author: null-d3v

labs/MessagingRedisCache/Program.cs

@@ -1,9 +1,7 @@
 using Microsoft.Extensions.Caching.Hybrid;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 
 var services = new ServiceCollection();
-services.AddLogging(builder => builder.AddConsole().AddFilter(null, LogLevel.Trace));
 services.AddHybridCache();
 services.AddMessagingRedisCache(options =>
 {
@@ -34,5 +32,3 @@ await hybridCache
         cancellationToken =>
             ValueTask.FromResult<string?>(null))
     .ConfigureAwait(false);
-
-var test = "";

src/L1L2RedisCache/L1L2RedisCache.cs

@@ -12,13 +12,15 @@ namespace L1L2RedisCache;
 /// A distributed cache implementation using both memory and Redis.
 /// </summary>
 public class L1L2RedisCache(
+    IBufferDistributedCache bufferDistributedCache,
     IMemoryCache l1Cache,
     IMessagePublisher messagePublisher,
     IMessageSubscriber messageSubscriber,
     IMessagingConfigurationVerifier messagingConfigurationVerifier,
     IOptions<MessagingRedisCacheOptions> messagingRedisCacheOptionsAccessor,
     ILogger<L1L2RedisCache>? logger = null) :
     MessagingRedisCache.MessagingRedisCache(
+        bufferDistributedCache,
         messagePublisher,
         messageSubscriber,
         messagingConfigurationVerifier,

src/MessagingRedisCache/Configuration/ServiceCollectionExtensions.cs

@@ -1,5 +1,6 @@
 using MessagingRedisCache;
 using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.StackExchangeRedis;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
 using StackExchange.Redis;
@@ -46,6 +47,15 @@ public static IMessagingRedisCacheBuilder AddMessagingRedisCache(
                     }
                 }
             });
+        services.AddSingleton<IBufferDistributedCache, RedisCache>(
+            serviceProvider =>
+                new RedisCache(
+                    serviceProvider
+                        .GetRequiredService<IOptions<MessagingRedisCacheOptions>>()));
+        services.AddSingleton(
+            serviceProvider => new Func<IDistributedCache>(
+                () => new RedisCache(
+                    serviceProvider.GetRequiredService<IOptions<MessagingRedisCacheOptions>>())));
         services.TryAddSingleton<IDistributedCache, MessagingRedisCache.MessagingRedisCache>();
         services.TryAddSingleton<IMessagingConfigurationVerifier, MessagingConfigurationVerifier>();
 

src/MessagingRedisCache/MessagingRedisCache.cs

@@ -1,31 +1,34 @@
-using System.Buffers;
-using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Caching.StackExchangeRedis;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
 using StackExchange.Redis;
+using System.Buffers;
 
 namespace MessagingRedisCache;
 
 /// <summary>
 /// A Redis distributed cache implementation that uses pub/sub.
 /// </summary>
 public class MessagingRedisCache :
-    RedisCache,
-    IBufferDistributedCache
+    IBufferDistributedCache,
+    IDisposable
 {
     /// <summary>
     /// Initializes a new instance of MessagingRedisCache.
     /// </summary>
     public MessagingRedisCache(
+        IBufferDistributedCache bufferDistributedCache,
         IMessagePublisher messagePublisher,
         IMessageSubscriber messageSubscriber,
         IMessagingConfigurationVerifier messagingConfigurationVerifier,
         IOptions<MessagingRedisCacheOptions> messagingRedisCacheOptionsAccessor,
-        ILogger<MessagingRedisCache>? logger = null) :
-        base(messagingRedisCacheOptionsAccessor)
+        ILogger<MessagingRedisCache>? logger = null)
     {
+        BufferDistributedCache = bufferDistributedCache ??
+            throw new ArgumentNullException(
+                nameof(bufferDistributedCache));
         Logger = logger ??
             NullLogger<MessagingRedisCache>.Instance;
         MessagePublisher = messagePublisher ??
@@ -56,6 +59,11 @@ public MessagingRedisCache(
             SubscribeCancellationTokenSource.Token);
     }
 
+    /// <summary>
+    /// The backing <c>IBufferDistributedCache</c>, implemented by <see cref="RedisCache"/>.
+    /// </summary>
+    public IBufferDistributedCache BufferDistributedCache { get; }
+
     /// <summary>
     /// The <c>StackExchange.Redis.IDatabase</c> for the <see cref="RedisCache"/>.
     /// </summary>
@@ -90,29 +98,69 @@ public MessagingRedisCache(
     private CancellationTokenSource SubscribeCancellationTokenSource { get; set; }
 
     /// <inheritdoc />
-    public new void Dispose()
+    public void Dispose()
     {
-        base.Dispose();
         Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <inheritdoc />
+    public byte[]? Get(string key)
+    {
+        return BufferDistributedCache
+            .Get(key);
+    }
+
+    /// <inheritdoc />
+    public async Task<byte[]?> GetAsync(
+        string key,
+        CancellationToken token = default)
+    {
+        return await BufferDistributedCache
+            .GetAsync(
+                key,
+                token)
+            .ConfigureAwait(false);
     }
 
     /// <inheritdoc />
-    public new void Remove(string key)
+    public void Refresh(string key)
     {
-        base.Remove(key);
+        BufferDistributedCache
+            .Refresh(key);
+    }
+
+    /// <inheritdoc />
+    public async Task RefreshAsync(
+        string key,
+        CancellationToken token = default)
+    {
+        await BufferDistributedCache
+            .RefreshAsync(
+                key,
+                token)
+            .ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public void Remove(string key)
+    {
+        BufferDistributedCache
+            .Remove(key);
         MessagePublisher.Publish(
             Database.Value.Multiplexer,
             key);
     }
 
     /// <inheritdoc />
-    public new async Task RemoveAsync(
+    public async Task RemoveAsync(
         string key,
         CancellationToken token = default)
     {
-        await base.RemoveAsync(
-            key,
-            token)
+        await BufferDistributedCache
+            .RemoveAsync(
+                key,
+                token)
             .ConfigureAwait(false);
         await MessagePublisher
             .PublishAsync(
@@ -123,12 +171,12 @@ await MessagePublisher
     }
 
     /// <inheritdoc />
-    public new void Set(
+    public void Set(
         string key,
         byte[] value,
         DistributedCacheEntryOptions options)
     {
-        base.Set(
+        BufferDistributedCache.Set(
             key,
             value,
             options);
@@ -143,24 +191,28 @@ public void Set(
         ReadOnlySequence<byte> value,
         DistributedCacheEntryOptions options)
     {
-        ((IBufferDistributedCache)this).Set(key, value, options);
+        BufferDistributedCache.Set(
+            key,
+            value,
+            options);
         MessagePublisher.Publish(
             Database.Value.Multiplexer,
             key);
     }
 
     /// <inheritdoc />
-    public new async Task SetAsync(
+    public async Task SetAsync(
         string key,
         byte[] value,
         DistributedCacheEntryOptions options,
         CancellationToken token = default)
     {
-        await base.SetAsync(
-            key,
-            value,
-            options,
-            token)
+        await BufferDistributedCache
+            .SetAsync(
+                key,
+                value,
+                options,
+                token)
             .ConfigureAwait(false);
         await MessagePublisher
             .PublishAsync(
@@ -170,7 +222,51 @@ await MessagePublisher
             .ConfigureAwait(false);
     }
 
-    private void Dispose(bool isDisposing)
+    public async ValueTask SetAsync(
+        string key,
+        ReadOnlySequence<byte> value,
+        DistributedCacheEntryOptions options,
+        CancellationToken token = default)
+    {
+        await BufferDistributedCache
+            .SetAsync(
+                key,
+                value,
+                options,
+                token)
+            .ConfigureAwait(false);
+        await MessagePublisher
+            .PublishAsync(
+                Database.Value.Multiplexer,
+                key,
+                token)
+            .ConfigureAwait(false);
+    }
+
+    public bool TryGet(
+        string key,
+        IBufferWriter<byte> destination)
+    {
+        return BufferDistributedCache
+            .TryGet(
+                key,
+                destination);
+    }
+
+    public async ValueTask<bool> TryGetAsync(
+        string key,
+        IBufferWriter<byte> destination,
+        CancellationToken token = default)
+    {
+        return await BufferDistributedCache
+            .TryGetAsync(
+                key,
+                destination,
+                token)
+            .ConfigureAwait(false);
+    }
+
+    protected virtual void Dispose(bool isDisposing)
     {
         if (IsDisposed)
         {

tests/MessagingRedisCache/Unit/MessagingRedisCacheTests.cs

@@ -19,7 +19,6 @@ public MessagingRedisCacheTests()
 
         var database = Substitute
             .For<IDatabase>();
-
         ConnectionMultiplexer = Substitute
             .For<IConnectionMultiplexer>();
         ConnectionMultiplexer
@@ -57,7 +56,10 @@ public MessagingRedisCacheTests()
                 Arg.Any<IDatabase>(),
                 Arg.Any<CancellationToken>());
 
+        var bufferDistributedCache = Substitute
+            .For<IBufferDistributedCache>();
         MessagingRedisCache = new MessagingRedisCache(
+            bufferDistributedCache,
             MessagePublisher,
             MessageSubscriber,
             messagingConfigurationVerifier,