[cache] fix #38796 - fix inconsistent handling of empty byte[]

src/Caching/StackExchangeRedis/src/RedisCache.cs

@@ -400,7 +400,7 @@ private void TryRegisterProfiler(IConnectionMultiplexer connection)
             Refresh(cache, key, absExpr, sldExpr);
         }
 
-        if (results.Length >= 3 && results[2].HasValue)
+        if (results.Length >= 3 && !results[2].IsNull)
         {
             return results[2];
         }
@@ -436,7 +436,7 @@ private void TryRegisterProfiler(IConnectionMultiplexer connection)
             await RefreshAsync(cache, key, absExpr, sldExpr, token).ConfigureAwait(false);
         }
 
-        if (results.Length >= 3 && results[2].HasValue)
+        if (results.Length >= 3 && !results[2].IsNull)
         {
             return results[2];
         }

src/Caching/StackExchangeRedis/test/RedisCacheSetAndRemoveTests.cs

@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Caching.Distributed;
 using Xunit;
 
@@ -95,4 +98,82 @@ public void SetNullValueThrows()
 
         Assert.Throws<ArgumentNullException>(() => cache.Set(key, value));
     }
+
+    [Fact(Skip = SkipReason)]
+    public void SetGetEmptyNonNullBuffer()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = Me();
+        cache.Remove(key); // known state
+        Assert.Null(cache.Get(key)); // expect null
+
+        cache.Set(key, Array.Empty<byte>());
+        var arr = cache.Get(key);
+        Assert.NotNull(arr);
+        Assert.Empty(arr);
+    }
+
+    [Fact(Skip = SkipReason)]
+    public async Task SetGetEmptyNonNullBufferAsync()
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = Me();
+        await cache.RemoveAsync(key); // known state
+        Assert.Null(await cache.GetAsync(key)); // expect null
+
+        await cache.SetAsync(key, Array.Empty<byte>());
+        var arr = await cache.GetAsync(key);
+        Assert.NotNull(arr);
+        Assert.Empty(arr);
+    }
+
+    [Theory(Skip = SkipReason)]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData("abc")]
+    public void SetGetNonNullString(string payload)
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = Me();
+        cache.Remove(key); // known state
+        Assert.Null(cache.Get(key)); // expect null
+        cache.SetString(key, payload);
+
+        // check raw bytes
+        var raw = cache.Get(key);
+        Assert.Equal(Hex(payload), Hex(raw));
+
+        // check via string API
+        var value = cache.GetString(key);
+        Assert.NotNull(value);
+        Assert.Equal(payload, value);
+    }
+
+    [Theory(Skip = SkipReason)]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData("abc")]
+    [InlineData("abc def ghi jkl mno pqr stu vwx yz!")]
+    public async Task SetGetNonNullStringAsync(string payload)
+    {
+        var cache = RedisTestConfig.CreateCacheInstance(GetType().Name);
+        var key = Me();
+        await cache.RemoveAsync(key); // known state
+        Assert.Null(await cache.GetAsync(key)); // expect null
+        await cache.SetStringAsync(key, payload);
+
+        // check raw bytes
+        var raw = await cache.GetAsync(key);
+        Assert.Equal(Hex(payload), Hex(raw));
+
+        // check via string API
+        var value = await cache.GetStringAsync(key);
+        Assert.NotNull(value);
+        Assert.Equal(payload, value);
+    }
+
+    static string Hex(byte[] value) => BitConverter.ToString(value);
+    static string Hex(string value) => Hex(Encoding.UTF8.GetBytes(value));
+
+    private static string Me([CallerMemberName] string caller = "") => caller;
 }