diff --git a/src/Caching/StackExchangeRedis/src/RedisCache.cs b/src/Caching/StackExchangeRedis/src/RedisCache.cs
index a3dee31a2392..749b5fc79d8c 100644
--- a/src/Caching/StackExchangeRedis/src/RedisCache.cs
+++ b/src/Caching/StackExchangeRedis/src/RedisCache.cs
@@ -24,52 +24,23 @@ public partial class RedisCache : IDistributedCache, IDisposable
 {
     // Note that the "force reconnect" pattern as described https://learn.microsoft.com/en-us/azure/azure-cache-for-redis/cache-best-practices-connection#using-forcereconnect-with-stackexchangeredis
     // can be enabled via the "Microsoft.AspNetCore.Caching.StackExchangeRedis.UseForceReconnect" app-context switch
-    //
-    // -- Explanation of why two kinds of SetScript are used --
-    // * Redis 2.0 had HSET key field value for setting individual hash fields,
-    // and HMSET key field value [field value ...] for setting multiple hash fields (against the same key).
-    // * Redis 4.0 added HSET key field value [field value ...] and deprecated HMSET.
-    //
-    // On Redis versions that don't have the newer HSET variant, we use SetScriptPreExtendedSetCommand
-    // which uses the (now deprecated) HMSET.
-
-    // KEYS[1] = = key
-    // ARGV[1] = absolute-expiration - ticks as long (-1 for none)
-    // ARGV[2] = sliding-expiration - ticks as long (-1 for none)
-    // ARGV[3] = relative-expiration (long, in seconds, -1 for none) - Min(absolute-expiration - Now, sliding-expiration)
-    // ARGV[4] = data - byte[]
-    // this order should not change LUA script depends on it
-    private const string SetScript = (@"
-                redis.call('HSET', KEYS[1], 'absexp', ARGV[1], 'sldexp', ARGV[2], 'data', ARGV[4])
-                if ARGV[3] ~= '-1' then
-                  redis.call('EXPIRE', KEYS[1], ARGV[3])
-                end
-                return 1");
-    private const string SetScriptPreExtendedSetCommand = (@"
-                redis.call('HMSET', KEYS[1], 'absexp', ARGV[1], 'sldexp', ARGV[2], 'data', ARGV[4])
-                if ARGV[3] ~= '-1' then
-                  redis.call('EXPIRE', KEYS[1], ARGV[3])
-                end
-                return 1");
 
     private const string AbsoluteExpirationKey = "absexp";
     private const string SlidingExpirationKey = "sldexp";
     private const string DataKey = "data";
 
     // combined keys - same hash keys fetched constantly; avoid allocating an array each time
-    private static readonly RedisValue[] _hashMembersAbsoluteExpirationSlidingExpirationData = new RedisValue[] { AbsoluteExpirationKey, SlidingExpirationKey, DataKey };
-    private static readonly RedisValue[] _hashMembersAbsoluteExpirationSlidingExpiration = new RedisValue[] { AbsoluteExpirationKey, SlidingExpirationKey };
+    private static readonly RedisValue[] _hashMembersAbsoluteExpirationSlidingExpirationData = [AbsoluteExpirationKey, SlidingExpirationKey, DataKey];
+    private static readonly RedisValue[] _hashMembersAbsoluteExpirationSlidingExpiration = [AbsoluteExpirationKey, SlidingExpirationKey];
 
     private static RedisValue[] GetHashFields(bool getData) => getData
         ? _hashMembersAbsoluteExpirationSlidingExpirationData
         : _hashMembersAbsoluteExpirationSlidingExpiration;
 
     private const long NotPresent = -1;
-    private static readonly Version ServerVersionWithExtendedSetCommand = new Version(4, 0, 0);
 
     private volatile IDatabase? _cache;
     private bool _disposed;
-    private string _setScript = SetScript;
 
     private readonly RedisCacheOptions _options;
     private readonly RedisKey _instancePrefix;
@@ -169,14 +140,24 @@ public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
 
         try
         {
-            cache.ScriptEvaluate(_setScript, new RedisKey[] { _instancePrefix.Append(key) },
-                new RedisValue[]
-                {
-                        absoluteExpiration?.Ticks ?? NotPresent,
-                        options.SlidingExpiration?.Ticks ?? NotPresent,
-                        GetExpirationInSeconds(creationTime, absoluteExpiration, options) ?? NotPresent,
-                        value
-                });
+            var prefixedKey = _instancePrefix.Append(key);
+            var ttl = GetExpirationInSeconds(creationTime, absoluteExpiration, options);
+            var fields = GetHashFields(value, absoluteExpiration, options.SlidingExpiration);
+
+            if (ttl is null)
+            {
+                cache.HashSet(prefixedKey, fields);
+            }
+            else
+            {
+                // use the batch API to pipeline the two commands and wait synchronously;
+                // SE.Redis reuses the async API shape for this scenario
+                var batch = cache.CreateBatch();
+                var setFields = batch.HashSetAsync(prefixedKey, fields);
+                var setTtl = batch.KeyExpireAsync(prefixedKey, TimeSpan.FromSeconds(ttl.GetValueOrDefault()));
+                batch.Execute(); // synchronous wait-for-all; the two tasks should be either complete or *literally about to* (race conditions)
+                cache.WaitAll(setFields, setTtl); // note this applies usual SE.Redis timeouts etc
+            }
         }
         catch (Exception ex)
         {
@@ -203,14 +184,21 @@ public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOption
 
         try
         {
-            await cache.ScriptEvaluateAsync(_setScript, new RedisKey[] { _instancePrefix.Append(key) },
-                new RedisValue[]
-                {
-                absoluteExpiration?.Ticks ?? NotPresent,
-                options.SlidingExpiration?.Ticks ?? NotPresent,
-                GetExpirationInSeconds(creationTime, absoluteExpiration, options) ?? NotPresent,
-                value
-                }).ConfigureAwait(false);
+            var prefixedKey = _instancePrefix.Append(key);
+            var ttl = GetExpirationInSeconds(creationTime, absoluteExpiration, options);
+            var fields = GetHashFields(value, absoluteExpiration, options.SlidingExpiration);
+
+            if (ttl is null)
+            {
+                await cache.HashSetAsync(prefixedKey, fields).ConfigureAwait(false);
+            }
+            else
+            {
+                await Task.WhenAll(
+                    cache.HashSetAsync(prefixedKey, fields),
+                    cache.KeyExpireAsync(prefixedKey, TimeSpan.FromSeconds(ttl.GetValueOrDefault()))
+                    ).ConfigureAwait(false);
+            }
         }
         catch (Exception ex)
         {
@@ -219,6 +207,13 @@ public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOption
         }
     }
 
+    private static HashEntry[] GetHashFields(RedisValue value, DateTimeOffset? absoluteExpiration, TimeSpan? slidingExpiration)
+        => [
+            new HashEntry(AbsoluteExpirationKey, absoluteExpiration?.Ticks ?? NotPresent),
+            new HashEntry(SlidingExpirationKey, slidingExpiration?.Ticks ?? NotPresent),
+            new HashEntry(DataKey, value)
+        ];
+
     /// <inheritdoc />
     public void Refresh(string key)
     {
@@ -323,36 +318,10 @@ private async ValueTask<IDatabase> ConnectSlowAsync(CancellationToken token)
     private void PrepareConnection(IConnectionMultiplexer connection)
     {
         WriteTimeTicks(ref _lastConnectTicks, DateTimeOffset.UtcNow);
-        ValidateServerFeatures(connection);
         TryRegisterProfiler(connection);
         TryAddSuffix(connection);
     }
 
-    private void ValidateServerFeatures(IConnectionMultiplexer connection)
-    {
-        _ = connection ?? throw new InvalidOperationException($"{nameof(connection)} cannot be null.");
-
-        try
-        {
-            foreach (var endPoint in connection.GetEndPoints())
-            {
-                if (connection.GetServer(endPoint).Version < ServerVersionWithExtendedSetCommand)
-                {
-                    _setScript = SetScriptPreExtendedSetCommand;
-                    return;
-                }
-            }
-        }
-        catch (NotSupportedException ex)
-        {
-            Log.CouldNotDetermineServerVersion(_logger, ex);
-
-            // The GetServer call may not be supported with some configurations, in which
-            // case let's also fall back to using the older command.
-            _setScript = SetScriptPreExtendedSetCommand;
-        }
-    }
-
     private void TryRegisterProfiler(IConnectionMultiplexer connection)
     {
         _ = connection ?? throw new InvalidOperationException($"{nameof(connection)} cannot be null.");
@@ -372,7 +341,7 @@ private void TryAddSuffix(IConnectionMultiplexer connection)
         }
         catch (Exception ex)
         {
-            Log.UnableToAddLibraryNameSuffix(_logger, ex);;
+            Log.UnableToAddLibraryNameSuffix(_logger, ex); ;
         }
     }
 
@@ -557,6 +526,9 @@ private async Task RefreshAsync(IDatabase cache, string key, DateTimeOffset? abs
         }
     }
 
+    // it is not an oversight that this returns seconds rather than TimeSpan (which SE.Redis can accept directly); by
+    // leaving this as an integer, we use TTL rather than PTTL, which has better compatibility between servers
+    // (it also takes a handful fewer bytes, but that isn't a motivating factor)
     private static long? GetExpirationInSeconds(DateTimeOffset creationTime, DateTimeOffset? absoluteExpiration, DistributedCacheEntryOptions options)
     {
         if (absoluteExpiration.HasValue && options.SlidingExpiration.HasValue)
diff --git a/src/Caching/StackExchangeRedis/test/TimeExpirationAsyncTests.cs b/src/Caching/StackExchangeRedis/test/TimeExpirationAsyncTests.cs
new file mode 100644
index 000000000000..83d958bdb156
--- /dev/null
+++ b/src/Caching/StackExchangeRedis/test/TimeExpirationAsyncTests.cs
@@ -0,0 +1,277 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+using Xunit;
+
+namespace Microsoft.Extensions.Caching.StackExchangeRedis;
+
+public class TimeExpirationAsyncTests
+{
+    private const string SkipReason = "TODO: Disabled due to CI failure. " +
+        "These tests require Redis server to be started on the machine. Make sure to change the value of" +
+        "\"RedisTestConfig.RedisPort\" accordingly.";
+
+    // async twin to ExceptionAssert.ThrowsArgumentOutOfRange
+    static async Task ThrowsArgumentOutOfRangeAsync(Func<Task> test, string paramName, string message, object actualValue)
+    {
+        var ex = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(test);
+        if (paramName is not null)
+        {
+            Assert.Equal(paramName, ex.ParamName);
+        }
+        if (message is not null)
+        {
+            Assert.StartsWith(message, ex.Message); // can have "\r\nParameter name:" etc
+        }
+        if (actualValue is not null)
+        {
+            Assert.Equal(actualValue, ex.ActualValue);
+        }
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task AbsoluteExpirationInThePastThrows()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        var expected = DateTimeOffset.Now - TimeSpan.FromMinutes(1);
+        await ThrowsArgumentOutOfRangeAsync(
+            async () =>
+            {
+                await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(expected));
+            },
+            nameof(DistributedCacheEntryOptions.AbsoluteExpiration),
+            "The absolute expiration value must be in the future.",
+            expected);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task AbsoluteExpirationExpires()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(1)));
+
+        byte[] result = await cache.GetAsync(key);
+        Assert.Equal(value, result);
+
+        for (int i = 0; i < 4 && (result != null); i++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(0.5));
+            result = await cache.GetAsync(key);
+        }
+
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task AbsoluteSubSecondExpirationExpiresImmediately()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(0.25)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task NegativeRelativeExpirationThrows()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await ThrowsArgumentOutOfRangeAsync(async () =>
+        {
+            await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(-1)));
+        },
+        nameof(DistributedCacheEntryOptions.AbsoluteExpirationRelativeToNow),
+        "The relative expiration value must be positive.",
+        TimeSpan.FromMinutes(-1));
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task ZeroRelativeExpirationThrows()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await ThrowsArgumentOutOfRangeAsync(async () =>
+            {
+                await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.Zero));
+            },
+            nameof(DistributedCacheEntryOptions.AbsoluteExpirationRelativeToNow),
+            "The relative expiration value must be positive.",
+            TimeSpan.Zero);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task RelativeExpirationExpires()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(1)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Equal(value, result);
+
+        for (int i = 0; i < 4 && (result != null); i++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(0.5));
+            result = await cache.GetAsync(key);
+        }
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task RelativeSubSecondExpirationExpiresImmediately()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(0.25)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task NegativeSlidingExpirationThrows()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await ThrowsArgumentOutOfRangeAsync(async () =>
+        {
+            await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(-1)));
+        }, nameof(DistributedCacheEntryOptions.SlidingExpiration), "The sliding expiration value must be positive.", TimeSpan.FromMinutes(-1));
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task ZeroSlidingExpirationThrows()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await ThrowsArgumentOutOfRangeAsync(async () =>
+        {
+            await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.Zero));
+        },
+        nameof(DistributedCacheEntryOptions.SlidingExpiration),
+        "The sliding expiration value must be positive.",
+        TimeSpan.Zero);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task SlidingExpirationExpiresIfNotAccessed()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(1)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Equal(value, result);
+
+        await Task.Delay(TimeSpan.FromSeconds(3.5));
+
+        result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task SlidingSubSecondExpirationExpiresImmediately()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(0.25)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task SlidingExpirationRenewedByAccess()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(1)));
+
+        var result = await cache.GetAsync(key);
+        Assert.Equal(value, result);
+
+        for (int i = 0; i < 5; i++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(0.5));
+
+            result = await cache.GetAsync(key);
+            Assert.Equal(value, result);
+        }
+
+        await Task.Delay(TimeSpan.FromSeconds(3));
+        result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task SlidingExpirationRenewedByAccessUntilAbsoluteExpiration()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = await GetNameAndReset(cache);
+        var value = new byte[1];
+
+        await cache.SetAsync(key, value, new DistributedCacheEntryOptions()
+            .SetSlidingExpiration(TimeSpan.FromSeconds(1))
+            .SetAbsoluteExpiration(TimeSpan.FromSeconds(3)));
+
+        var setTime = DateTime.Now;
+        var result = await cache.GetAsync(key);
+        Assert.Equal(value, result);
+
+        for (int i = 0; i < 5; i++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(0.5));
+
+            result = await cache.GetAsync(key);
+            Assert.NotNull(result);
+            Assert.Equal(value, result);
+        }
+
+        while ((DateTime.Now - setTime).TotalSeconds < 4)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(0.5));
+        }
+
+        result = await cache.GetAsync(key);
+        Assert.Null(result);
+    }
+
+    static async Task<string> GetNameAndReset(IDistributedCache cache, [CallerMemberName] string caller = "")
+    {
+        await cache.RemoveAsync(caller);
+        return caller;
+    }
+}
diff --git a/src/Caching/StackExchangeRedis/test/TimeExpirationTests.cs b/src/Caching/StackExchangeRedis/test/TimeExpirationTests.cs
index 325ab1dd9107..9426dbb08227 100644
--- a/src/Caching/StackExchangeRedis/test/TimeExpirationTests.cs
+++ b/src/Caching/StackExchangeRedis/test/TimeExpirationTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using Microsoft.AspNetCore.InternalTesting;
 using Microsoft.Extensions.Caching.Distributed;
@@ -20,7 +21,7 @@ public class TimeExpirationTests
     public void AbsoluteExpirationInThePastThrows()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         var expected = DateTimeOffset.Now - TimeSpan.FromMinutes(1);
@@ -38,7 +39,7 @@ public void AbsoluteExpirationInThePastThrows()
     public void AbsoluteExpirationExpires()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(1)));
@@ -56,10 +57,10 @@ public void AbsoluteExpirationExpires()
     }
 
     [Fact(Skip = SkipReason)]
-    public void AbsoluteSubSecondExpirationExpiresImmidately()
+    public void AbsoluteSubSecondExpirationExpiresImmediately()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(0.25)));
@@ -72,7 +73,7 @@ public void AbsoluteSubSecondExpirationExpiresImmidately()
     public void NegativeRelativeExpirationThrows()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         ExceptionAssert.ThrowsArgumentOutOfRange(() =>
@@ -88,7 +89,7 @@ public void NegativeRelativeExpirationThrows()
     public void ZeroRelativeExpirationThrows()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         ExceptionAssert.ThrowsArgumentOutOfRange(
@@ -105,7 +106,7 @@ public void ZeroRelativeExpirationThrows()
     public void RelativeExpirationExpires()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(1)));
@@ -125,7 +126,7 @@ public void RelativeExpirationExpires()
     public void RelativeSubSecondExpirationExpiresImmediately()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromSeconds(0.25)));
@@ -138,7 +139,7 @@ public void RelativeSubSecondExpirationExpiresImmediately()
     public void NegativeSlidingExpirationThrows()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         ExceptionAssert.ThrowsArgumentOutOfRange(() =>
@@ -151,7 +152,7 @@ public void NegativeSlidingExpirationThrows()
     public void ZeroSlidingExpirationThrows()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         ExceptionAssert.ThrowsArgumentOutOfRange(
@@ -168,7 +169,7 @@ public void ZeroSlidingExpirationThrows()
     public void SlidingExpirationExpiresIfNotAccessed()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(1)));
@@ -176,7 +177,7 @@ public void SlidingExpirationExpiresIfNotAccessed()
         var result = cache.Get(key);
         Assert.Equal(value, result);
 
-        Thread.Sleep(TimeSpan.FromSeconds(3));
+        Thread.Sleep(TimeSpan.FromSeconds(3.5));
 
         result = cache.Get(key);
         Assert.Null(result);
@@ -186,7 +187,7 @@ public void SlidingExpirationExpiresIfNotAccessed()
     public void SlidingSubSecondExpirationExpiresImmediately()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(0.25)));
@@ -199,7 +200,7 @@ public void SlidingSubSecondExpirationExpiresImmediately()
     public void SlidingExpirationRenewedByAccess()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(1)));
@@ -224,13 +225,14 @@ public void SlidingExpirationRenewedByAccess()
     public void SlidingExpirationRenewedByAccessUntilAbsoluteExpiration()
     {
         var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
-        var key = "myKey";
+        var key = GetNameAndReset(cache);
         var value = new byte[1];
 
         cache.Set(key, value, new DistributedCacheEntryOptions()
             .SetSlidingExpiration(TimeSpan.FromSeconds(1))
             .SetAbsoluteExpiration(TimeSpan.FromSeconds(3)));
 
+        var setTime = DateTime.Now;
         var result = cache.Get(key);
         Assert.Equal(value, result);
 
@@ -239,12 +241,22 @@ public void SlidingExpirationRenewedByAccessUntilAbsoluteExpiration()
             Thread.Sleep(TimeSpan.FromSeconds(0.5));
 
             result = cache.Get(key);
+            Assert.NotNull(result);
             Assert.Equal(value, result);
         }
 
-        Thread.Sleep(TimeSpan.FromSeconds(.6));
+        while ((DateTime.Now - setTime).TotalSeconds < 4)
+        {
+            Thread.Sleep(TimeSpan.FromSeconds(0.5));
+        }
 
         result = cache.Get(key);
         Assert.Null(result);
     }
+
+    static string GetNameAndReset(IDistributedCache cache, [CallerMemberName] string caller = "")
+    {
+        cache.Remove(caller);
+        return caller;
+    }
 }