Migrate distributed cache provider implementations to Polly v7.0.0.

Author: reisenberger

src/Polly.Caching.Distributed.NetStandard11.Specs/Polly.Caching.Distributed.NetStandard11.Specs.csproj

@@ -18,9 +18,10 @@
     <PackageReference Include="FluentAssertions" Version="4.19.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
     <PackageReference Include="Moq" Version="4.7.145" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-    <PackageReference Include="Polly" Version="6.0.1" />
+    <PackageReference Include="Polly" Version="7.0.0" />
 
   </ItemGroup>
   <ItemGroup>

src/Polly.Caching.Distributed.NetStandard11/Polly.Caching.Distributed.NetStandard11.csproj

@@ -31,7 +31,8 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="1.1.2" />
-    <PackageReference Include="Polly" Version="6.0.1" />
+    <PackageReference Include="Polly" Version="7.0.0" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
   <Import Project="..\Polly.Caching.Distributed.Shared\Polly.Caching.Distributed.Shared.projitems" Label="Shared" />
 </Project>

src/Polly.Caching.Distributed.NetStandard20.Specs/Polly.Caching.Distributed.NetStandard20.Specs.csproj

@@ -19,10 +19,10 @@
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="2.0.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
     <PackageReference Include="Moq" Version="4.7.145" />
-    <PackageReference Include="Polly.Caching.Serialization.Json" Version="2.0.0" />
+    <PackageReference Include="Polly.Caching.Serialization.Json" Version="3.0.0" />
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-    <PackageReference Include="Polly" Version="6.0.1" />
+    <PackageReference Include="Polly" Version="7.0.0" />
 
   </ItemGroup>
   <ItemGroup>

src/Polly.Caching.Distributed.NetStandard20/Polly.Caching.Distributed.NetStandard20.csproj

@@ -31,7 +31,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="2.0.2" />
-    <PackageReference Include="Polly" Version="6.0.1" />
+    <PackageReference Include="Polly" Version="7.0.0" />
   </ItemGroup>
   <Import Project="..\Polly.Caching.Distributed.Shared\Polly.Caching.Distributed.Shared.projitems" Label="Shared" />
 </Project>

src/Polly.Caching.Distributed.Shared/NetStandardIDistributedCacheByteArrayProvider.cs

@@ -9,8 +9,6 @@ namespace Polly.Caching.Distributed
     /// </summary>
     public class NetStandardIDistributedCacheByteArrayProvider : NetStandardIDistributedCacheProvider<byte[]>
     {
-        private readonly byte[] Empty = new byte[0];
-
         /// <summary>
         /// Initializes a new instance of the <see cref="NetStandardIDistributedCacheByteArrayProvider"/> class.
         /// </summary>
@@ -23,13 +21,16 @@ public NetStandardIDistributedCacheByteArrayProvider(Microsoft.Extensions.Cachin
         /// Gets a value from cache.
         /// </summary>
         /// <param name="key">The cache key.</param>
-        /// <returns>The value from cache; or null, if none was found.</returns>
-        public override byte[] Get(String key)
+        /// <returns>
+        /// A tuple whose first element is a bool indicating whether the key was found in the cache,
+        /// and whose second element is the value from the cache.
+        /// </returns>
+        public override (bool, byte[]) TryGet(string key)
         {
-            byte[] returned = _cache.Get(key);
-            return returned == null || returned.Length == 0 ? null : returned; // Because Polly CachePolicy expects providers to return "no value held" as null.
+            byte[] fromCache = _cache.Get(key);
+            return (fromCache != null, fromCache);
         }
-        
+
         /// <summary>
         /// Puts the specified value in the cache.
         /// </summary>
@@ -38,26 +39,33 @@ public override byte[] Get(String key)
         /// <param name="ttl">The time-to-live for the cache entry.</param>
         public override void Put(string key, byte[] value, Ttl ttl)
         {
-            _cache.Set(key, value ?? Empty, ttl.ToDistributedCacheEntryOptions());
+            _cache.Set(key, value, ttl.ToDistributedCacheEntryOptions());
         }
 
         /// <summary>
-        /// Gets a value from the memory cache as part of an asynchronous execution.  <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
+        /// Gets a value from the memory cache as part of an asynchronous execution.
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="cancellationToken">The cancellation token.  </param>
-        /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context. <para><remarks>For <see cref="NetStandardIDistributedCacheByteArrayProvider"/>, this parameter is irrelevant and is ignored, as the Microsoft.Extensions.Caching.Distributed.IDistributedCache interface does not support it.</remarks></para></param>
-        /// <returns>A <see cref="Task{TResult}" /> promising as Result the value from cache; or null, if none was found.</returns>
-        public override async Task<byte[]> GetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
+        /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context. <para><remarks>For <see cref="NetStandardIDistributedCacheProvider{TCache}"/>, this parameter is irrelevant and is ignored, as the Microsoft.Extensions.Caching.Distributed.IDistributedCache interface does not support it.</remarks></para></param>
+        /// <returns>
+        /// A <see cref="Task{TResult}" /> promising as Result a tuple whose first element is a value indicating whether
+        /// the key was found in the cache, and whose second element is the value from the cache.
+        /// </returns>
+        public override async Task<(bool, byte[])> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            byte[] returned = await _cache.GetAsync(key);
-            return returned == null || returned.Length == 0 ? null : returned; // Because Polly CachePolicy expects providers to return "no value held" as null.
+
+            byte[] fromCache = await _cache.GetAsync(key
+#if NETSTANDARD2_0
+                , cancellationToken
+#endif
+            );
+            return (fromCache != null, fromCache);
         }
 
         /// <summary>
         /// Puts the specified value in the cache as part of an asynchronous execution.
-        /// <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="value">The value to put into the cache.</param>
@@ -69,7 +77,11 @@ public override Task PutAsync(string key, byte[] value, Ttl ttl, CancellationTok
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            return _cache.SetAsync(key, value ?? Empty, ttl.ToDistributedCacheEntryOptions());
+            return _cache.SetAsync(key, value, ttl.ToDistributedCacheEntryOptions()
+#if NETSTANDARD2_0
+                , cancellationToken
+#endif
+            );
         }
 
 

src/Polly.Caching.Distributed.Shared/NetStandardIDistributedCacheProvider.cs

@@ -30,17 +30,23 @@ protected NetStandardIDistributedCacheProvider(
         /// Gets a value from cache.
         /// </summary>
         /// <param name="key">The cache key.</param>
-        /// <returns>The value from cache; or null, if none was found.</returns>
-        public abstract TCache Get(string key);
+        /// <returns>
+        /// A tuple whose first element is a value indicating whether the key was found in the cache,
+        /// and whose second element is the value from the cache (default(TResult) if not found).
+        /// </returns>
+        public abstract (bool, TCache) TryGet(string key);
 
         /// <summary>
-        /// Gets a value from the memory cache as part of an asynchronous execution.  <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
+        /// Gets a value from the memory cache as part of an asynchronous execution.
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="cancellationToken">The cancellation token.  </param>
         /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context. <para><remarks>For <see cref="NetStandardIDistributedCacheProvider{TCache}"/>, this parameter is irrelevant and is ignored, as the Microsoft.Extensions.Caching.Distributed.IDistributedCache interface does not support it.</remarks></para></param>
-        /// <returns>A <see cref="Task{TResult}" /> promising as Result the value from cache; or null, if none was found.</returns>
-        public abstract Task<TCache> GetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext);
+        /// <returns>
+        /// A <see cref="Task{TResult}" /> promising as Result a tuple whose first element is a value indicating whether
+        /// the key was found in the cache, and whose second element is the value from the cache (default(TResult) if not found).
+        /// </returns>
+        public abstract Task<(bool, TCache)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext);
 
         /// <summary>
         /// Puts the specified value in the cache.
@@ -52,7 +58,6 @@ protected NetStandardIDistributedCacheProvider(
 
         /// <summary>
         /// Puts the specified value in the cache as part of an asynchronous execution.
-        /// <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="value">The value to put into the cache.</param>

src/Polly.Caching.Distributed.Shared/NetStandardIDistributedCacheStringProvider.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Caching.Distributed;
 
@@ -17,16 +16,19 @@ public class NetStandardIDistributedCacheStringProvider : NetStandardIDistribute
         public NetStandardIDistributedCacheStringProvider(Microsoft.Extensions.Caching.Distributed.IDistributedCache iDistributedCache) : base(iDistributedCache)
         {
         }
-
+        
         /// <summary>
         /// Gets a value from cache.
         /// </summary>
         /// <param name="key">The cache key.</param>
-        /// <returns>The value from cache; or null, if none was found.</returns>
-        public override string Get(String key)
+        /// <returns>
+        /// A tuple whose first element is a bool indicating whether the key was found in the cache,
+        /// and whose second element is the value from the cache.
+        /// </returns>
+        public override (bool, string) TryGet(string key)
         {
-            string returned = _cache.GetString(key);
-            return returned == null || returned.Length == 0 ? null : returned;
+            string fromCache = _cache.GetString(key);
+            return (fromCache != null, fromCache);
         }
 
         /// <summary>
@@ -41,23 +43,29 @@ public override void Put(string key, string value, Ttl ttl)
         }
 
         /// <summary>
-        /// Gets a value from the memory cache as part of an asynchronous execution.  <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
+        /// Gets a value from the memory cache as part of an asynchronous execution.
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="cancellationToken">The cancellation token.  </param>
         /// <param name="continueOnCapturedContext">Whether async calls should continue on a captured synchronization context. <para><remarks>For <see cref="NetStandardIDistributedCacheProvider{TCache}"/>, this parameter is irrelevant and is ignored, as the Microsoft.Extensions.Caching.Distributed.IDistributedCache interface does not support it.</remarks></para></param>
-        /// <returns>A <see cref="Task{TResult}" /> promising as Result the value from cache; or null, if none was found.</returns>
-        public override async Task<string> GetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
+        /// <returns>
+        /// A <see cref="Task{TResult}" /> promising as Result a tuple whose first element is a value indicating whether
+        /// the key was found in the cache, and whose second element is the value from the cache.
+        /// </returns>
+        public override async Task<(bool, string)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            string returned = await _cache.GetStringAsync(key);
-            return returned == null || returned.Length == 0 ? null : returned; 
+            string fromCache = await _cache.GetStringAsync(key
+#if NETSTANDARD2_0
+                , cancellationToken
+#endif
+                );
+            return (fromCache != null, fromCache);
         }
 
         /// <summary>
         /// Puts the specified value in the cache as part of an asynchronous execution.
-        /// <para><remarks>The implementation is synchronous as there is no advantage to an asynchronous implementation for an in-memory cache.</remarks></para>
         /// </summary>
         /// <param name="key">The cache key.</param>
         /// <param name="value">The value to put into the cache.</param>
@@ -69,7 +77,11 @@ public override Task PutAsync(string key, string value, Ttl ttl, CancellationTok
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            return _cache.SetStringAsync(key, value, ttl.ToDistributedCacheEntryOptions());
+            return _cache.SetStringAsync(key, value, ttl.ToDistributedCacheEntryOptions()
+#if NETSTANDARD2_0
+                , cancellationToken
+#endif
+                );
         }
 
     }