Add 1-pass of Rider quick fixes across *Async.cs classes

mythz · mythz · commit e4074483d562 · 2020-09-03T22:28:03.000+08:00
diff --git a/src/ServiceStack.Redis/Generic/RedisClientSet.Generic.Async.cs b/src/ServiceStack.Redis/Generic/RedisClientSet.Generic.Async.cs
@@ -57,7 +57,7 @@ async IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationTok
                 List<T> pageResults;
                 do
                 {
-                    pageResults = await AsyncClient.GetSortedEntryValuesAsync(this, skip, skip + PageLimit - 1).ConfigureAwait(false);
+                    pageResults = await AsyncClient.GetSortedEntryValuesAsync(this, skip, skip + PageLimit - 1, token).ConfigureAwait(false);
                     foreach (var result in pageResults)
                     {
                         yield return result;
diff --git a/src/ServiceStack.Redis/Generic/RedisClientSortedSet.Generic.Async.cs b/src/ServiceStack.Redis/Generic/RedisClientSortedSet.Generic.Async.cs
@@ -25,16 +25,16 @@ internal partial class RedisClientSortedSet<T>
         IRedisSortedSetAsync<T> AsAsync() => this;
 
         ValueTask IRedisSortedSetAsync<T>.AddAsync(T item, double score, CancellationToken token)
-            => AsyncClient.AddItemToSortedSetAsync(this, item, score);
+            => AsyncClient.AddItemToSortedSetAsync(this, item, score, token);
 
         ValueTask<int> IRedisSortedSetAsync<T>.CountAsync(CancellationToken token)
             => AsyncClient.GetSortedSetCountAsync(this, token).AsInt32();
 
         ValueTask<List<T>> IRedisSortedSetAsync<T>.GetAllAsync(CancellationToken token)
-            => AsyncClient.GetAllItemsFromSortedSetAsync(this);
+            => AsyncClient.GetAllItemsFromSortedSetAsync(this, token);
 
         ValueTask<List<T>> IRedisSortedSetAsync<T>.GetAllDescendingAsync(CancellationToken token)
-            => AsyncClient.GetAllItemsFromSortedSetDescAsync(this);
+            => AsyncClient.GetAllItemsFromSortedSetDescAsync(this, token);
 
         async IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken token)
         {
diff --git a/src/ServiceStack.Redis/Generic/RedisTypedClient.Async.cs b/src/ServiceStack.Redis/Generic/RedisTypedClient.Async.cs
@@ -200,20 +200,20 @@ static void AssertNotNull(object obj, string name = "key")
         async ValueTask IRedisTypedClientAsync<T>.SetValueAsync(string key, T entity, TimeSpan expireIn, CancellationToken token)
         {
             AssertNotNull(key);
-            await AsyncClient.SetAsync(key, SerializeValue(entity)).ConfigureAwait(false);
+            await AsyncClient.SetAsync(key, SerializeValue(entity), token).ConfigureAwait(false);
             await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);
         }
 
         async ValueTask<bool> IRedisTypedClientAsync<T>.SetValueIfNotExistsAsync(string key, T entity, CancellationToken token)
         {
-            var success = await AsyncNative.SetNXAsync(key, SerializeValue(entity)).IsSuccessAsync().ConfigureAwait(false);
+            var success = await AsyncNative.SetNXAsync(key, SerializeValue(entity), token).IsSuccessAsync().ConfigureAwait(false);
             if (success) await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);
             return success;
         }
 
         async ValueTask<bool> IRedisTypedClientAsync<T>.SetValueIfExistsAsync(string key, T entity, CancellationToken token)
         {
-            var success = await AsyncNative.SetAsync(key, SerializeValue(entity), exists: true).ConfigureAwait(false);
+            var success = await AsyncNative.SetAsync(key, SerializeValue(entity), exists: true, token: token).ConfigureAwait(false);
             if (success) await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);
             return success;
         }
@@ -365,7 +365,7 @@ ValueTask<long> IRedisTypedClientAsync<T>.GetSetCountAsync(IRedisSetAsync<T> set
             => AsyncNative.SCardAsync(set.Id, token);
 
         ValueTask<bool> IRedisTypedClientAsync<T>.SetContainsItemAsync(IRedisSetAsync<T> set, T item, CancellationToken token)
-            => AsyncNative.SIsMemberAsync(set.Id, SerializeValue(item)).IsSuccessAsync();
+            => AsyncNative.SIsMemberAsync(set.Id, SerializeValue(item), token).IsSuccessAsync();
 
         async ValueTask<HashSet<T>> IRedisTypedClientAsync<T>.GetIntersectFromSetsAsync(IRedisSetAsync<T>[] sets, CancellationToken token)
         {
diff --git a/src/ServiceStack.Redis/RedisClient.Async.cs b/src/ServiceStack.Redis/RedisClient.Async.cs
@@ -252,15 +252,15 @@ ValueTask<List<string>> IRedisClientAsync.GetValuesAsync(List<string> keys, Canc
             if (keys == null) throw new ArgumentNullException(nameof(keys));
             if (keys.Count == 0) return new List<string>().AsValueTaskResult();
 
-            return NativeAsync.MGetAsync(keys.ToArray(), token).Await(val => ParseGetValuesResult(val));
+            return NativeAsync.MGetAsync(keys.ToArray(), token).Await(ParseGetValuesResult);
         }
 
         ValueTask<List<T>> IRedisClientAsync.GetValuesAsync<T>(List<string> keys, CancellationToken token)
         {
             if (keys == null) throw new ArgumentNullException(nameof(keys));
             if (keys.Count == 0) return new List<T>().AsValueTaskResult();
 
-            return NativeAsync.MGetAsync(keys.ToArray(), token).Await(value => ParseGetValuesResult<T>(value));
+            return NativeAsync.MGetAsync(keys.ToArray(), token).Await(ParseGetValuesResult<T>);
         }
 
         ValueTask<Dictionary<string, string>> IRedisClientAsync.GetValuesMapAsync(List<string> keys, CancellationToken token)
@@ -407,19 +407,21 @@ Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, DateTime expiresAt
             AssertNotInTransaction();
             return ExecAsync(async r =>
             {
-                await r.SetAsync(key, value).ConfigureAwait(false);
-                await r.ExpireEntryAtAsync(key, ConvertToServerDate(expiresAt)).ConfigureAwait(false);
+                await r.SetAsync(key, value, token).ConfigureAwait(false);
+                await r.ExpireEntryAtAsync(key, ConvertToServerDate(expiresAt), token).ConfigureAwait(false);
             }).AwaitAsTrueTask();
         }
         Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)
         {
             if (AssertServerVersionNumber() >= 2600)
             {
-                return ExecAsync(r => ((IRedisNativeClientAsync)r).SetAsync(key, ToBytes(value), 0, expiryMilliseconds: (long)expiresIn.TotalMilliseconds)).AwaitAsTrueTask();
+                return ExecAsync(r => ((IRedisNativeClientAsync)r)
+                    .SetAsync(key, ToBytes(value), 0, expiryMilliseconds: (long)expiresIn.TotalMilliseconds, token)).AwaitAsTrueTask();
             }
             else
             {
-                return ExecAsync(r => ((IRedisNativeClientAsync)r).SetExAsync(key, (int)expiresIn.TotalSeconds, ToBytes(value))).AwaitAsTrueTask();
+                return ExecAsync(r => ((IRedisNativeClientAsync)r)
+                    .SetExAsync(key, (int)expiresIn.TotalSeconds, ToBytes(value), token)).AwaitAsTrueTask();
             }
         }
 
@@ -640,7 +642,7 @@ async Task IEntityStoreAsync.DeleteByIdsAsync<T>(ICollection ids, CancellationTo
         {
             if (ids == null || ids.Count == 0) return;
 
-            var idsList = ids.Cast<object>();
+            var idsList = ids.Cast<object>().ToList();
             var urnKeys = idsList.Map(UrnKey<T>);
             await AsAsync().RemoveEntryAsync(urnKeys.ToArray(), token).ConfigureAwait(false);
             await this.RemoveTypeIdsAsync<T>(idsList.Map(x => x.ToString()).ToArray(), token).ConfigureAwait(false);
diff --git a/src/ServiceStack.Redis/RedisClientList.Async.cs b/src/ServiceStack.Redis/RedisClientList.Async.cs
@@ -40,7 +40,7 @@ ValueTask<int> IRedisListAsync.CountAsync(CancellationToken token)
             => AsyncClient.GetListCountAsync(listId, token).AsInt32();
 
         ValueTask<string> IRedisListAsync.DequeueAsync(CancellationToken token)
-            => AsyncClient.DequeueItemFromListAsync(listId);
+            => AsyncClient.DequeueItemFromListAsync(listId, token);
 
         ValueTask IRedisListAsync.EnqueueAsync(string value, CancellationToken token)
             => AsyncClient.EnqueueItemOnListAsync(listId, value, token);
@@ -138,7 +138,7 @@ async ValueTask<bool> IRedisListAsync.ContainsAsync(string value, CancellationTo
         }
 
         ValueTask IRedisListAsync.ClearAsync(CancellationToken token)
-            => AsyncClient.RemoveAllFromListAsync(listId);
+            => AsyncClient.RemoveAllFromListAsync(listId, token);
 
         async ValueTask<int> IRedisListAsync.IndexOfAsync(string value, CancellationToken token)
         {
@@ -153,9 +153,9 @@ async ValueTask<int> IRedisListAsync.IndexOfAsync(string value, CancellationToke
         }
 
         ValueTask<string> IRedisListAsync.ElementAtAsync(int index, CancellationToken token)
-            => AsyncClient.GetItemFromListAsync(listId, index);
+            => AsyncClient.GetItemFromListAsync(listId, index, token);
 
         ValueTask IRedisListAsync.SetValueAsync(int index, string value, CancellationToken token)
-            => AsyncClient.SetItemInListAsync(listId, index, value);
+            => AsyncClient.SetItemInListAsync(listId, index, value, token);
     }
 }
diff --git a/src/ServiceStack.Redis/RedisClientManagerCacheClient.Async.cs b/src/ServiceStack.Redis/RedisClientManagerCacheClient.Async.cs
@@ -30,19 +30,19 @@ async Task<T> ICacheClientAsync.GetAsync<T>(string key, CancellationToken token)
         async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.SetAsync<T>(key, value, token).ConfigureAwait(false);
+            return await client.SetAsync(key, value, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.SetAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);
+            return await client.SetAsync(key, value, expiresAt, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.SetAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);
+            return await client.SetAsync(key, value, expiresIn, token).ConfigureAwait(false);
         }
 
         async Task ICacheClientAsync.FlushAllAsync(CancellationToken token)
@@ -60,7 +60,7 @@ async Task<IDictionary<string, T>> ICacheClientAsync.GetAllAsync<T>(IEnumerable<
         async Task ICacheClientAsync.SetAllAsync<T>(IDictionary<string, T> values, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            await client.SetAllAsync<T>(values, token).ConfigureAwait(false);
+            await client.SetAllAsync(values, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.RemoveAsync(string key, CancellationToken token)
@@ -129,37 +129,37 @@ async Task<long> ICacheClientAsync.DecrementAsync(string key, uint amount, Cance
         async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.AddAsync<T>(key, value, token).ConfigureAwait(false);
+            return await client.AddAsync(key, value, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.ReplaceAsync<T>(key, value, token).ConfigureAwait(false);
+            return await client.ReplaceAsync(key, value, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.AddAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);
+            return await client.AddAsync(key, value, expiresAt, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.ReplaceAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);
+            return await client.ReplaceAsync(key, value, expiresAt, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.AddAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);
+            return await client.AddAsync(key, value, expiresIn, token).ConfigureAwait(false);
         }
 
         async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)
         {
             await using var client = await GetClientAsync(token).ConfigureAwait(false);
-            return await client.ReplaceAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);
+            return await client.ReplaceAsync(key, value, expiresIn, token).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/ServiceStack.Redis/RedisClientSet.Async.cs b/src/ServiceStack.Redis/RedisClientSet.Async.cs
@@ -46,7 +46,7 @@ ValueTask<HashSet<string>> IRedisSetAsync.GetAllAsync(CancellationToken token)
             => AsyncClient.GetAllItemsFromSetAsync(setId, token);
 
         IAsyncEnumerator<string> IAsyncEnumerable<string>.GetAsyncEnumerator(CancellationToken token)
-            => AsyncClient.ScanAllSetItemsAsync(setId).GetAsyncEnumerator(token); // uses SSCAN
+            => AsyncClient.ScanAllSetItemsAsync(setId, token: token).GetAsyncEnumerator(token); // uses SSCAN
 
         ValueTask<string> IRedisSetAsync.GetRandomEntryAsync(CancellationToken token)
             => AsyncClient.GetRandomItemFromSetAsync(setId, token);
diff --git a/src/ServiceStack.Redis/RedisNativeClient.Async.cs b/src/ServiceStack.Redis/RedisNativeClient.Async.cs
@@ -48,7 +48,7 @@ ValueTask<bool> IRedisNativeClientAsync.SetAsync(string key, byte[] value, bool
             value ??= TypeConstants.EmptyByteArray;
 
             if (value.Length > OneGb)
-                throw new ArgumentException("value exceeds 1G", "value");
+                throw new ArgumentException("value exceeds 1G", nameof(value));
 
             var entryExists = exists ? Commands.Xx : Commands.Nx;
             byte[][] args;
@@ -73,7 +73,7 @@ ValueTask IRedisNativeClientAsync.SetAsync(string key, byte[] value, long expiry
             value ??= TypeConstants.EmptyByteArray;
 
             if (value.Length > OneGb)
-                throw new ArgumentException("value exceeds 1G", "value");
+                throw new ArgumentException("value exceeds 1G", nameof(value));
 
             byte[][] args;
             if (expiryMilliseconds != 0)
@@ -162,16 +162,16 @@ internal ValueTask<long> HSetAsync(byte[] hashId, byte[] key, byte[] value, Canc
         ValueTask<string> IRedisNativeClientAsync.RandomKeyAsync(CancellationToken token)
             => SendExpectDataAsync(token, Commands.RandomKey).FromUtf8BytesAsync();
 
-        ValueTask IRedisNativeClientAsync.RenameAsync(string oldKeyname, string newKeyname, CancellationToken token)
+        ValueTask IRedisNativeClientAsync.RenameAsync(string oldKeyName, string newKeyName, CancellationToken token)
         {
-            CheckRenameKeys(oldKeyname, newKeyname);
-            return SendExpectSuccessAsync(token, Commands.Rename, oldKeyname.ToUtf8Bytes(), newKeyname.ToUtf8Bytes());
+            CheckRenameKeys(oldKeyName, newKeyName);
+            return SendExpectSuccessAsync(token, Commands.Rename, oldKeyName.ToUtf8Bytes(), newKeyName.ToUtf8Bytes());
         }
 
-        ValueTask<bool> IRedisNativeClientAsync.RenameNxAsync(string oldKeyname, string newKeyname, CancellationToken token)
+        ValueTask<bool> IRedisNativeClientAsync.RenameNxAsync(string oldKeyName, string newKeyName, CancellationToken token)
         {
-            CheckRenameKeys(oldKeyname, newKeyname);
-            return SendExpectLongAsync(token, Commands.RenameNx, oldKeyname.ToUtf8Bytes(), newKeyname.ToUtf8Bytes()).IsSuccessAsync();
+            CheckRenameKeys(oldKeyName, newKeyName);
+            return SendExpectLongAsync(token, Commands.RenameNx, oldKeyName.ToUtf8Bytes(), newKeyName.ToUtf8Bytes()).IsSuccessAsync();
         }
 
         ValueTask IRedisNativeClientAsync.MSetAsync(byte[][] keys, byte[][] values, CancellationToken token)
@@ -308,7 +308,7 @@ ValueTask IRedisNativeClientAsync.SetExAsync(string key, int expireInSeconds, by
             value ??= TypeConstants.EmptyByteArray;
 
             if (value.Length > OneGb)
-                throw new ArgumentException("value exceeds 1G", "value");
+                throw new ArgumentException("value exceeds 1G", nameof(value));
 
             return SendExpectSuccessAsync(token, Commands.SetEx, key.ToUtf8Bytes(), expireInSeconds.ToUtf8Bytes(), value);
         }
@@ -455,7 +455,7 @@ protected ValueTask<RedisData> RawCommandAsync(CancellationToken token, params o
         }
 
         ValueTask<Dictionary<string, string>> IRedisNativeClientAsync.InfoAsync(CancellationToken token)
-            => SendExpectStringAsync(token, Commands.Info).Await(info => ParseInfoResult(info));
+            => SendExpectStringAsync(token, Commands.Info).Await(ParseInfoResult);
 
         ValueTask<byte[][]> IRedisNativeClientAsync.ZRangeByLexAsync(string setId, string min, string max, int? skip, int? take, CancellationToken token)
             => SendExpectMultiDataAsync(token, GetZRangeByLexArgs(setId, min, max, skip, take));
diff --git a/src/ServiceStack.Redis/RedisNativeClient_Utils.Async.cs b/src/ServiceStack.Redis/RedisNativeClient_Utils.Async.cs
@@ -250,7 +250,7 @@ private async ValueTask<T> SendReceiveAsync<T>(byte[][] cmdWithBinaryArgs,
                     }
 
                     Interlocked.Increment(ref RedisState.TotalRetryCount);
-                    await Task.Delay(GetBackOffMultiplier(++i)).ConfigureAwait(false);
+                    await Task.Delay(GetBackOffMultiplier(++i), token).ConfigureAwait(false);
                 }
             }
         }
diff --git a/src/ServiceStack.Redis/ServiceStack.Redis.csproj b/src/ServiceStack.Redis/ServiceStack.Redis.csproj
@@ -42,8 +42,5 @@
     <!-- note: not needed from netstandard2.1 or netcoreapp3.0 onwards -->
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="1.1.0" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="AsyncInterfaces\ServiceStack.Interfaces\Caching\" />
-  </ItemGroup>
   
 </Project>
diff --git a/src/ServiceStack.Redis/ValueTask_Utils.Async.cs b/src/ServiceStack.Redis/ValueTask_Utils.Async.cs

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ async IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationTok`
`57`	`57`	`List<T> pageResults;`
`58`	`58`	`do`
`59`	`59`	`{`
`60`		`- pageResults = await AsyncClient.GetSortedEntryValuesAsync(this, skip, skip + PageLimit - 1).ConfigureAwait(false);`
	`60`	`+ pageResults = await AsyncClient.GetSortedEntryValuesAsync(this, skip, skip + PageLimit - 1, token).ConfigureAwait(false);`
`61`	`61`	`foreach (var result in pageResults)`
`62`	`62`	`{`
`63`	`63`	`yield return result;`
Original file line number	Diff line number	Diff line change
`@@ -200,20 +200,20 @@ static void AssertNotNull(object obj, string name = "key")`
`200`	`200`	`async ValueTask IRedisTypedClientAsync<T>.SetValueAsync(string key, T entity, TimeSpan expireIn, CancellationToken token)`
`201`	`201`	`{`
`202`	`202`	`AssertNotNull(key);`
`203`		`- await AsyncClient.SetAsync(key, SerializeValue(entity)).ConfigureAwait(false);`
	`203`	`+ await AsyncClient.SetAsync(key, SerializeValue(entity), token).ConfigureAwait(false);`
`204`	`204`	`await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`async ValueTask<bool> IRedisTypedClientAsync<T>.SetValueIfNotExistsAsync(string key, T entity, CancellationToken token)`
`208`	`208`	`{`
`209`		`- var success = await AsyncNative.SetNXAsync(key, SerializeValue(entity)).IsSuccessAsync().ConfigureAwait(false);`
	`209`	`+ var success = await AsyncNative.SetNXAsync(key, SerializeValue(entity), token).IsSuccessAsync().ConfigureAwait(false);`
`210`	`210`	`if (success) await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);`
`211`	`211`	`return success;`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`async ValueTask<bool> IRedisTypedClientAsync<T>.SetValueIfExistsAsync(string key, T entity, CancellationToken token)`
`215`	`215`	`{`
`216`		`- var success = await AsyncNative.SetAsync(key, SerializeValue(entity), exists: true).ConfigureAwait(false);`
	`216`	`+ var success = await AsyncNative.SetAsync(key, SerializeValue(entity), exists: true, token: token).ConfigureAwait(false);`
`217`	`217`	`if (success) await client.RegisterTypeIdAsync(entity, token).ConfigureAwait(false);`
`218`	`218`	`return success;`
`219`	`219`	`}`
`@@ -365,7 +365,7 @@ ValueTask<long> IRedisTypedClientAsync<T>.GetSetCountAsync(IRedisSetAsync<T> set`
`365`	`365`	`=> AsyncNative.SCardAsync(set.Id, token);`
`366`	`366`
`367`	`367`	`ValueTask<bool> IRedisTypedClientAsync<T>.SetContainsItemAsync(IRedisSetAsync<T> set, T item, CancellationToken token)`
`368`		`- => AsyncNative.SIsMemberAsync(set.Id, SerializeValue(item)).IsSuccessAsync();`
	`368`	`+ => AsyncNative.SIsMemberAsync(set.Id, SerializeValue(item), token).IsSuccessAsync();`
`369`	`369`
`370`	`370`	`async ValueTask<HashSet<T>> IRedisTypedClientAsync<T>.GetIntersectFromSetsAsync(IRedisSetAsync<T>[] sets, CancellationToken token)`
`371`	`371`	`{`
Original file line number	Diff line number	Diff line change
`@@ -252,15 +252,15 @@ ValueTask<List<string>> IRedisClientAsync.GetValuesAsync(List<string> keys, Canc`
`252`	`252`	`if (keys == null) throw new ArgumentNullException(nameof(keys));`
`253`	`253`	`if (keys.Count == 0) return new List<string>().AsValueTaskResult();`
`254`	`254`
`255`		`- return NativeAsync.MGetAsync(keys.ToArray(), token).Await(val => ParseGetValuesResult(val));`
	`255`	`+ return NativeAsync.MGetAsync(keys.ToArray(), token).Await(ParseGetValuesResult);`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`ValueTask<List<T>> IRedisClientAsync.GetValuesAsync<T>(List<string> keys, CancellationToken token)`
`259`	`259`	`{`
`260`	`260`	`if (keys == null) throw new ArgumentNullException(nameof(keys));`
`261`	`261`	`if (keys.Count == 0) return new List<T>().AsValueTaskResult();`
`262`	`262`
`263`		`- return NativeAsync.MGetAsync(keys.ToArray(), token).Await(value => ParseGetValuesResult<T>(value));`
	`263`	`+ return NativeAsync.MGetAsync(keys.ToArray(), token).Await(ParseGetValuesResult<T>);`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`ValueTask<Dictionary<string, string>> IRedisClientAsync.GetValuesMapAsync(List<string> keys, CancellationToken token)`
`@@ -407,19 +407,21 @@ Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, DateTime expiresAt`
`407`	`407`	`AssertNotInTransaction();`
`408`	`408`	`return ExecAsync(async r =>`
`409`	`409`	`{`
`410`		`- await r.SetAsync(key, value).ConfigureAwait(false);`
`411`		`- await r.ExpireEntryAtAsync(key, ConvertToServerDate(expiresAt)).ConfigureAwait(false);`
	`410`	`+ await r.SetAsync(key, value, token).ConfigureAwait(false);`
	`411`	`+ await r.ExpireEntryAtAsync(key, ConvertToServerDate(expiresAt), token).ConfigureAwait(false);`
`412`	`412`	`}).AwaitAsTrueTask();`
`413`	`413`	`}`
`414`	`414`	`Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)`
`415`	`415`	`{`
`416`	`416`	`if (AssertServerVersionNumber() >= 2600)`
`417`	`417`	`{`
`418`		`- return ExecAsync(r => ((IRedisNativeClientAsync)r).SetAsync(key, ToBytes(value), 0, expiryMilliseconds: (long)expiresIn.TotalMilliseconds)).AwaitAsTrueTask();`
	`418`	`+ return ExecAsync(r => ((IRedisNativeClientAsync)r)`
	`419`	`+ .SetAsync(key, ToBytes(value), 0, expiryMilliseconds: (long)expiresIn.TotalMilliseconds, token)).AwaitAsTrueTask();`
`419`	`420`	`}`
`420`	`421`	`else`
`421`	`422`	`{`
`422`		`- return ExecAsync(r => ((IRedisNativeClientAsync)r).SetExAsync(key, (int)expiresIn.TotalSeconds, ToBytes(value))).AwaitAsTrueTask();`
	`423`	`+ return ExecAsync(r => ((IRedisNativeClientAsync)r)`
	`424`	`+ .SetExAsync(key, (int)expiresIn.TotalSeconds, ToBytes(value), token)).AwaitAsTrueTask();`
`423`	`425`	`}`
`424`	`426`	`}`
`425`	`427`
`@@ -640,7 +642,7 @@ async Task IEntityStoreAsync.DeleteByIdsAsync<T>(ICollection ids, CancellationTo`
`640`	`642`	`{`
`641`	`643`	`if (ids == null \|\| ids.Count == 0) return;`
`642`	`644`
`643`		`- var idsList = ids.Cast<object>();`
	`645`	`+ var idsList = ids.Cast<object>().ToList();`
`644`	`646`	`var urnKeys = idsList.Map(UrnKey<T>);`
`645`	`647`	`await AsAsync().RemoveEntryAsync(urnKeys.ToArray(), token).ConfigureAwait(false);`
`646`	`648`	`await this.RemoveTypeIdsAsync<T>(idsList.Map(x => x.ToString()).ToArray(), token).ConfigureAwait(false);`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ ValueTask<int> IRedisListAsync.CountAsync(CancellationToken token)`
`40`	`40`	`=> AsyncClient.GetListCountAsync(listId, token).AsInt32();`
`41`	`41`
`42`	`42`	`ValueTask<string> IRedisListAsync.DequeueAsync(CancellationToken token)`
`43`		`- => AsyncClient.DequeueItemFromListAsync(listId);`
	`43`	`+ => AsyncClient.DequeueItemFromListAsync(listId, token);`
`44`	`44`
`45`	`45`	`ValueTask IRedisListAsync.EnqueueAsync(string value, CancellationToken token)`
`46`	`46`	`=> AsyncClient.EnqueueItemOnListAsync(listId, value, token);`
`@@ -138,7 +138,7 @@ async ValueTask<bool> IRedisListAsync.ContainsAsync(string value, CancellationTo`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`ValueTask IRedisListAsync.ClearAsync(CancellationToken token)`
`141`		`- => AsyncClient.RemoveAllFromListAsync(listId);`
	`141`	`+ => AsyncClient.RemoveAllFromListAsync(listId, token);`
`142`	`142`
`143`	`143`	`async ValueTask<int> IRedisListAsync.IndexOfAsync(string value, CancellationToken token)`
`144`	`144`	`{`
`@@ -153,9 +153,9 @@ async ValueTask<int> IRedisListAsync.IndexOfAsync(string value, CancellationToke`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`ValueTask<string> IRedisListAsync.ElementAtAsync(int index, CancellationToken token)`
`156`		`- => AsyncClient.GetItemFromListAsync(listId, index);`
	`156`	`+ => AsyncClient.GetItemFromListAsync(listId, index, token);`
`157`	`157`
`158`	`158`	`ValueTask IRedisListAsync.SetValueAsync(int index, string value, CancellationToken token)`
`159`		`- => AsyncClient.SetItemInListAsync(listId, index, value);`
	`159`	`+ => AsyncClient.SetItemInListAsync(listId, index, value, token);`
`160`	`160`	`}`
`161`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,19 +30,19 @@ async Task<T> ICacheClientAsync.GetAsync<T>(string key, CancellationToken token)`
`30`	`30`	`async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, CancellationToken token)`
`31`	`31`	`{`
`32`	`32`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`33`		`- return await client.SetAsync<T>(key, value, token).ConfigureAwait(false);`
	`33`	`+ return await client.SetAsync(key, value, token).ConfigureAwait(false);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)`
`37`	`37`	`{`
`38`	`38`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`39`		`- return await client.SetAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);`
	`39`	`+ return await client.SetAsync(key, value, expiresAt, token).ConfigureAwait(false);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`async Task<bool> ICacheClientAsync.SetAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)`
`43`	`43`	`{`
`44`	`44`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`45`		`- return await client.SetAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);`
	`45`	`+ return await client.SetAsync(key, value, expiresIn, token).ConfigureAwait(false);`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`async Task ICacheClientAsync.FlushAllAsync(CancellationToken token)`
`@@ -60,7 +60,7 @@ async Task<IDictionary<string, T>> ICacheClientAsync.GetAllAsync<T>(IEnumerable<`
`60`	`60`	`async Task ICacheClientAsync.SetAllAsync<T>(IDictionary<string, T> values, CancellationToken token)`
`61`	`61`	`{`
`62`	`62`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`63`		`- await client.SetAllAsync<T>(values, token).ConfigureAwait(false);`
	`63`	`+ await client.SetAllAsync(values, token).ConfigureAwait(false);`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`async Task<bool> ICacheClientAsync.RemoveAsync(string key, CancellationToken token)`
`@@ -129,37 +129,37 @@ async Task<long> ICacheClientAsync.DecrementAsync(string key, uint amount, Cance`
`129`	`129`	`async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, CancellationToken token)`
`130`	`130`	`{`
`131`	`131`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`132`		`- return await client.AddAsync<T>(key, value, token).ConfigureAwait(false);`
	`132`	`+ return await client.AddAsync(key, value, token).ConfigureAwait(false);`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, CancellationToken token)`
`136`	`136`	`{`
`137`	`137`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`138`		`- return await client.ReplaceAsync<T>(key, value, token).ConfigureAwait(false);`
	`138`	`+ return await client.ReplaceAsync(key, value, token).ConfigureAwait(false);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)`
`142`	`142`	`{`
`143`	`143`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`144`		`- return await client.AddAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);`
	`144`	`+ return await client.AddAsync(key, value, expiresAt, token).ConfigureAwait(false);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, DateTime expiresAt, CancellationToken token)`
`148`	`148`	`{`
`149`	`149`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`150`		`- return await client.ReplaceAsync<T>(key, value, expiresAt, token).ConfigureAwait(false);`
	`150`	`+ return await client.ReplaceAsync(key, value, expiresAt, token).ConfigureAwait(false);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`async Task<bool> ICacheClientAsync.AddAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)`
`154`	`154`	`{`
`155`	`155`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`156`		`- return await client.AddAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);`
	`156`	`+ return await client.AddAsync(key, value, expiresIn, token).ConfigureAwait(false);`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`async Task<bool> ICacheClientAsync.ReplaceAsync<T>(string key, T value, TimeSpan expiresIn, CancellationToken token)`
`160`	`160`	`{`
`161`	`161`	`await using var client = await GetClientAsync(token).ConfigureAwait(false);`
`162`		`- return await client.ReplaceAsync<T>(key, value, expiresIn, token).ConfigureAwait(false);`
	`162`	`+ return await client.ReplaceAsync(key, value, expiresIn, token).ConfigureAwait(false);`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ private async ValueTask<T> SendReceiveAsync<T>(byte[][] cmdWithBinaryArgs,`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`Interlocked.Increment(ref RedisState.TotalRetryCount);`
`253`		`- await Task.Delay(GetBackOffMultiplier(++i)).ConfigureAwait(false);`
	`253`	`+ await Task.Delay(GetBackOffMultiplier(++i), token).ConfigureAwait(false);`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`	`}`