diff --git a/src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs b/src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs
index 75005e6..faab41f 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs
@@ -16,12 +16,12 @@ public partial interface IRedisDatabase
     /// <summary>
     ///     Gets the instance of <see cref="IDatabase" /> used be ICacheClient implementation
     /// </summary>
-    IDatabase Database { get; }
+    public IDatabase Database { get; }
 
     /// <summary>
     ///     Gets the instance of <see cref="ISerializer" />
     /// </summary>
-    ISerializer Serializer { get; }
+    public ISerializer Serializer { get; }
 
     /// <summary>
     ///     Verify that the specified cache key exists
@@ -29,7 +29,7 @@ public partial interface IRedisDatabase
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>True if the key is present into Redis. Othwerwise False</returns>
-    Task<bool> ExistsAsync(string key, CommandFlags flag = CommandFlags.None);
+    public Task<bool> ExistsAsync(string key, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Removes the specified key from Redis Database
@@ -37,7 +37,7 @@ public partial interface IRedisDatabase
     /// <param name="key">The cache key.</param>
     /// <returns>True if the key has removed. Othwerwise False</returns>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<bool> RemoveAsync(string key, CommandFlags flag = CommandFlags.None);
+    public Task<bool> RemoveAsync(string key, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Removes all specified keys from Redis Database
@@ -45,7 +45,7 @@ public partial interface IRedisDatabase
     /// <param name="keys">The cache keys.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>The numnber of items removed.</returns>
-    Task<long> RemoveAllAsync(string[] keys, CommandFlags flag = CommandFlags.None);
+    public Task<long> RemoveAllAsync(string[] keys, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Get the object with the specified key from Redis database
@@ -54,7 +54,7 @@ public partial interface IRedisDatabase
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>Null if not present, otherwise the instance of T.</returns>
-    Task<T?> GetAsync<T>(string key, CommandFlags flag = CommandFlags.None);
+    public Task<T?> GetAsync<T>(string key, CommandFlags flag = CommandFlags.None);
 
     /// <summary>Get the object with the specified key from Redis database and update the expiry time</summary>
     /// <typeparam name="T">The type of the expected object.</typeparam>
@@ -62,7 +62,7 @@ public partial interface IRedisDatabase
     /// <param name="expiresAt">Expiration time.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>Null if not present, otherwise the instance of T.</returns>
-    Task<T?> GetAsync<T>(string key, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
+    public Task<T?> GetAsync<T>(string key, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Get the object with the specified key from Redis database and update the expiry time
@@ -74,7 +74,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     Null if not present, otherwise the instance of T.
     /// </returns>
-    Task<T?> GetAsync<T>(string key, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
+    public Task<T?> GetAsync<T>(string key, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Adds the specified instance to the Redis database.
@@ -86,7 +86,7 @@ public partial interface IRedisDatabase
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <param name="tags">Tags</param>
     /// <returns>True if the object has been added. Otherwise false</returns>
-    Task<bool> AddAsync<T>(string key, T value, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
+    public Task<bool> AddAsync<T>(string key, T value, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
 
     /// <summary>
     ///     Replaces the object with specified key into Redis database.
@@ -99,7 +99,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     True if the object has been added. Otherwise false
     /// </returns>
-    Task<bool> ReplaceAsync<T>(string key, T value, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> ReplaceAsync<T>(string key, T value, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Adds the specified instance to the Redis database.
@@ -114,7 +114,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     True if the object has been added. Otherwise false
     /// </returns>
-    Task<bool> AddAsync<T>(string key, T value, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
+    public Task<bool> AddAsync<T>(string key, T value, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
 
     /// <summary>
     ///     Replaces the object with specified key into Redis database.
@@ -128,7 +128,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     True if the object has been added. Otherwise false
     /// </returns>
-    Task<bool> ReplaceAsync<T>(string key, T value, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> ReplaceAsync<T>(string key, T value, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Adds the specified instance to the Redis database.
@@ -143,7 +143,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     True if the object has been added. Otherwise false
     /// </returns>
-    Task<bool> AddAsync<T>(string key, T value, TimeSpan expiresIn, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
+    public Task<bool> AddAsync<T>(string key, T value, TimeSpan expiresIn, When when = When.Always, CommandFlags flag = CommandFlags.None, HashSet<string>? tags = null);
 
     /// <summary>
     ///     Replaces the object with specified key into Redis database.
@@ -157,7 +157,7 @@ public partial interface IRedisDatabase
     /// <returns>
     ///     True if the object has been added. Otherwise false
     /// </returns>
-    Task<bool> ReplaceAsync<T>(string key, T value, TimeSpan expiresIn, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> ReplaceAsync<T>(string key, T value, TimeSpan expiresIn, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Get the objects with the specified keys from Redis database with a single roundtrip
@@ -169,7 +169,7 @@ public partial interface IRedisDatabase
     ///     Empty list if there are no results, otherwise the instance of T.
     ///     If a cache key is not present on Redis the specified object into the returned Dictionary will be null
     /// </returns>
-    Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, CommandFlags flag = CommandFlags.None);
+    public Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Get the objects with the specified keys from Redis database with one roundtrip
@@ -182,7 +182,7 @@ public partial interface IRedisDatabase
     ///     Empty list if there are no results, otherwise the instance of T.
     ///     If a cache key is not present on Redis the specified object into the returned Dictionary will be null
     /// </returns>
-    Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
+    public Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Get the objects with the specified keys from Redis database with one roundtrip
@@ -195,7 +195,7 @@ public partial interface IRedisDatabase
     ///     Empty list if there are no results, otherwise the instance of T.
     ///     If a cache key is not present on Redis the specified object into the returned Dictionary will be null
     /// </returns>
-    Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
+    public Task<IDictionary<string, T?>> GetAllAsync<T>(HashSet<string> keys, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Add the objects with the specified keys to Redis database with a single roundtrip
@@ -205,7 +205,7 @@ public partial interface IRedisDatabase
     /// <param name="expiresAt">Expiration time.</param>
     /// <param name="when">The condition (Always is the default value).</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Add the objects with the specified keys to Redis database with a single roundtrip
@@ -214,7 +214,7 @@ public partial interface IRedisDatabase
     /// <param name="items">The items.</param>
     /// <param name="when">The condition (Always is the default value).</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Add the objects with the specified keys to Redis database with a single roundtrip
@@ -224,7 +224,7 @@ public partial interface IRedisDatabase
     /// <param name="expiresAt">Time until expiration.</param>
     /// <param name="when">The condition (Always is the default value).</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, TimeSpan expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
+    public Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, TimeSpan expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Run SADD command http://redis.io/commands/sadd
@@ -233,7 +233,7 @@ public partial interface IRedisDatabase
     /// <param name="key">The cache key.</param>
     /// <param name="item">Name of the member.</param>
     /// <param name="flag">Behaviour markers associated with a given command.</param>
-    Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
+    public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
        ;
 
     /// <summary>
@@ -242,7 +242,7 @@ Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.N
     /// <typeparam name="T">The type of the expected object.</typeparam>
     /// <param name="key">The key of the set</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<T?> SetPopAsync<T>(string key, CommandFlags flag = CommandFlags.None)
+    public Task<T?> SetPopAsync<T>(string key, CommandFlags flag = CommandFlags.None)
        ;
 
     /// <summary>
@@ -252,7 +252,7 @@ Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.N
     /// <param name="key">The key of the set</param>
     /// <param name="count">The number of elements to return</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<IEnumerable<T?>> SetPopAsync<T>(string key, long count, CommandFlags flag = CommandFlags.None)
+    public Task<IEnumerable<T?>> SetPopAsync<T>(string key, long count, CommandFlags flag = CommandFlags.None)
        ;
 
     /// <summary>
@@ -262,7 +262,7 @@ Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.N
     /// <param name="key">The cache key.</param>
     /// <param name="item">The item to store into redis.</param>
     /// <param name="flag">Behaviour markers associated with a given command.</param>
-    Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
+    public Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
        ;
 
     /// <summary>
@@ -272,7 +272,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <param name="items">Name of the member.</param>
-    Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
+    public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
 
     /// <summary>
     ///     Run SADD command http://redis.io/commands/sadd
@@ -281,7 +281,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <param name="items">Name of the member.</param>
-    Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items);
+    public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items);
 
     /// <summary>
     ///     Run SREM command http://redis.io/commands/srem"
@@ -290,7 +290,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The cache key.</param>
     /// <param name="item">The object to store into redis</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<bool> SetRemoveAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None);
+    public Task<bool> SetRemoveAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Run SREM command http://redis.io/commands/srem
@@ -299,7 +299,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <param name="items">The items to store into Redis.</param>
-    Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
+    public Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
 
     /// <summary>
     ///     Run SREM command http://redis.io/commands/srem
@@ -308,14 +308,14 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The cache key.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <param name="items">The items to store into Redis.</param>
-    Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items);
+    public Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items);
 
     /// <summary>
     ///     Run SMEMBERS command see http://redis.io/commands/SMEMBERS
     /// </summary>
     /// <param name="memberName">Name of the member.</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
-    Task<string[]> SetMemberAsync(string memberName, CommandFlags flag = CommandFlags.None);
+    public Task<string[]> SetMemberAsync(string memberName, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Run SMEMBERS command see http://redis.io/commands/SMEMBERS
@@ -325,7 +325,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="key">The key</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>An array of objects in the set</returns>
-    Task<T[]> SetMembersAsync<T>(string key, CommandFlags flag = CommandFlags.None);
+    public Task<T[]> SetMembersAsync<T>(string key, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Searches the keys from Redis database
@@ -340,29 +340,29 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     ///     if you want to return all keys that end with "myCacheKey" uses "*myCacheKey"
     /// </example>
     /// <returns>A list of cache keys retrieved from Redis database</returns>
-    Task<IEnumerable<string>> SearchKeysAsync(string pattern);
+    public Task<IEnumerable<string>> SearchKeysAsync(string pattern);
 
     /// <summary>
     ///     Flushes the database asynchronous.
     /// </summary>
-    Task FlushDbAsync();
+    public Task FlushDbAsync();
 
     /// <summary>
     ///     Save the DB in background asynchronous.
     /// </summary>
-    Task SaveAsync(SaveType saveType, CommandFlags flag = CommandFlags.None);
+    public Task SaveAsync(SaveType saveType, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Gets the information about redis.
     ///     More info see http://redis.io/commands/INFO
     /// </summary>
-    Task<Dictionary<string, string>> GetInfoAsync();
+    public Task<Dictionary<string, string>> GetInfoAsync();
 
     /// <summary>
     ///     Gets the information about redis with category.
     ///     More info see http://redis.io/commands/INFO
     /// </summary>
-    Task<InfoDetail[]> GetInfoCategorizedAsync();
+    public Task<InfoDetail[]> GetInfoCategorizedAsync();
 
     /// <summary>
     ///     Updates the expiry time of a redis cache object
@@ -371,7 +371,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="expiresAt">The new expiry time of the object</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>True if the object is updated, false if the object does not exist</returns>
-    Task<bool> UpdateExpiryAsync(string key, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
+    public Task<bool> UpdateExpiryAsync(string key, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Updates the expiry time of a redis cache object
@@ -380,7 +380,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="expiresIn">Time until the object will expire</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>True if the object is updated, false if the object does not exist</returns>
-    Task<bool> UpdateExpiryAsync(string key, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
+    public Task<bool> UpdateExpiryAsync(string key, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Updates the expiry time of a redis cache object
@@ -389,7 +389,7 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="expiresAt">The new expiry time of the object</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>An array of type bool, where true if the object is updated and false if the object does not exist at the same index as the input keys</returns>
-    Task<IDictionary<string, bool>> UpdateExpiryAllAsync(HashSet<string> keys, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
+    public Task<IDictionary<string, bool>> UpdateExpiryAllAsync(HashSet<string> keys, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None);
 
     /// <summary>
     ///     Updates the expiry time of a redis cache object
@@ -398,5 +398,5 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="expiresIn">Time until the object will expire</param>
     /// <param name="flag">Behaviour markers associated with a given command</param>
     /// <returns>An IDictionary object that contains the origional key and the result of the operation</returns>
-    Task<IDictionary<string, bool>> UpdateExpiryAllAsync(HashSet<string> keys, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
+    public Task<IDictionary<string, bool>> UpdateExpiryAllAsync(HashSet<string> keys, TimeSpan expiresIn, CommandFlags flag = CommandFlags.None);
 }
diff --git a/src/core/StackExchange.Redis.Extensions.Core/Helpers/ExceptionThrowHelper.cs b/src/core/StackExchange.Redis.Extensions.Core/Helpers/ExceptionThrowHelper.cs
index b7d72a6..39af461 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Helpers/ExceptionThrowHelper.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Helpers/ExceptionThrowHelper.cs
@@ -6,12 +6,6 @@
 namespace StackExchange.Redis.Extensions.Core.Helpers;
 internal static class ExceptionThrowHelper
 {
-    public static void ThrowIfSpanEmpty<T>(ReadOnlySpan<T> argument, string paramName)
-    {
-        if (argument.IsEmpty)
-            throw new ArgumentException("The argument cannot be empty.", paramName);
-    }
-
     public static void ThrowIfExistsNullElement<T>(ReadOnlySpan<T> argument, string paramName)
     {
         if (argument.Any(x => x is null))
diff --git a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.Hash.cs b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.Hash.cs
index 4a09354..6f6f901 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.Hash.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.Hash.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Ugo Lattanzi.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
@@ -49,7 +48,7 @@ public Task<bool> HashExistsAsync(string hashKey, string key, CommandFlags flag
     public async Task<IDictionary<string, T?>> HashGetAsync<T>(string hashKey, string[] keys, CommandFlags flag = CommandFlags.None)
     {
 #if NET6_0_OR_GREATER
-        var concurrent = new ConcurrentDictionary<string, T?>();
+        var concurrent = new System.Collections.Concurrent.ConcurrentDictionary<string, T?>();
 
         await Parallel.ForEachAsync(keys, async (key, _) =>
         {
@@ -92,7 +91,7 @@ await Parallel.ForEachAsync(keys, async (key, _) =>
 
         var dictionary = new Dictionary<string, T?>();
 
-        var redisValues = ((RedisValue[]?)data);
+        var redisValues = (RedisValue[]?)data;
 
         ref var searchSpaceRedisValue = ref MemoryMarshal.GetReference(redisValues.AsSpan());
 
@@ -103,12 +102,12 @@ await Parallel.ForEachAsync(keys, async (key, _) =>
         {
             ref var key = ref Unsafe.Add(ref searchSpaceRedisValue, i);
 
-            if (key.HasValue == false)
+            if (!key.HasValue)
                 continue;
 
             var redisValue = redisValues[i + 1];
 
-            if (redisValue.HasValue == false)
+            if (!redisValue.HasValue)
                 continue;
 
 #pragma warning disable CS8604 // Possible null reference argument.
diff --git a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.List.cs b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.List.cs
index d9a72a5..24f39fe 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.List.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.List.cs
@@ -12,11 +12,16 @@ public partial class RedisDatabase
     /// <inheritdoc/>
     public Task<long> ListAddToLeftAsync<T>(string key, T item, When when = When.Always, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(item);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (item == null)
             throw new ArgumentNullException(nameof(item), "item cannot be null.");
+#endif
 
         var serializedItem = Serializer.Serialize(item);
 
@@ -26,11 +31,16 @@ public Task<long> ListAddToLeftAsync<T>(string key, T item, When when = When.Alw
     /// <inheritdoc/>
     public Task<long> ListAddToLeftAsync<T>(string key, T[] items, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(items);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (items == null)
             throw new ArgumentNullException(nameof(items), "item cannot be null.");
+#endif
 
         var serializedItems = items.ToFastArray(item => (RedisValue)Serializer.Serialize(item));
 
@@ -40,8 +50,12 @@ public Task<long> ListAddToLeftAsync<T>(string key, T[] items, CommandFlags flag
     /// <inheritdoc/>
     public async Task<T?> ListGetFromRightAsync<T>(string key, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
+#endif
 
         var item = await Database.ListRightPopAsync(key, flag).ConfigureAwait(false);
 
diff --git a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.PubSub.cs b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.PubSub.cs
index 2b0c691..4a76afe 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.PubSub.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.PubSub.cs
@@ -20,8 +20,12 @@ public Task<long> PublishAsync<T>(RedisChannel channel, T message, CommandFlags
     /// <inheritdoc/>
     public Task SubscribeAsync<T>(RedisChannel channel, Func<T?, Task> handler, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(handler);
+#else
         if (handler == null)
             throw new ArgumentNullException(nameof(handler));
+#endif
 
         var sub = connectionPoolManager.GetConnection().GetSubscriber();
 
@@ -34,8 +38,12 @@ void Handler(RedisChannel redisChannel, RedisValue value) =>
     /// <inheritdoc/>
     public Task UnsubscribeAsync<T>(RedisChannel channel, Func<T?, Task> handler, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentNullException.ThrowIfNull(handler);
+#else
         if (handler == null)
             throw new ArgumentNullException(nameof(handler));
+#endif
 
         var sub = connectionPoolManager.GetConnection().GetSubscriber();
         return sub.UnsubscribeAsync(channel, (_, value) => handler(Serializer.Deserialize<T>(value)), flag);
diff --git a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs
index 8ad79c8..f80f690 100644
--- a/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs
+++ b/src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs
@@ -265,11 +265,16 @@ public async Task<bool> AddAllAsync<T>(Tuple<string, T>[] items, TimeSpan expire
     /// <inheritdoc/>
     public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(item);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (item == null)
             throw new ArgumentNullException(nameof(item), "item cannot be null.");
+#endif
 
         var serializedObject = Serializer.Serialize(item);
 
@@ -279,8 +284,12 @@ public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = Command
     /// <inheritdoc/>
     public async Task<T?> SetPopAsync<T>(string key, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
+#endif
 
         var item = await Database.SetPopAsync(key, flag).ConfigureAwait(false);
 
@@ -292,8 +301,12 @@ public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = Command
     /// <inheritdoc/>
     public async Task<IEnumerable<T?>> SetPopAsync<T>(string key, long count, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
+#endif
 
         var items = await Database.SetPopAsync(key, count, flag).ConfigureAwait(false);
 
@@ -303,11 +316,16 @@ public Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = Command
     /// <inheritdoc/>
     public Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(item);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (item == null)
             throw new ArgumentNullException(nameof(item), "item cannot be null.");
+#endif
 
         var serializedObject = Serializer.Serialize(item);
 
@@ -317,11 +335,16 @@ public Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = Co
     /// <inheritdoc/>
     public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[]? items)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(items);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (items == null)
             throw new ArgumentNullException(nameof(items), "items cannot be null.");
+#endif
 
         ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
 
@@ -357,11 +380,16 @@ public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags
     /// <inheritdoc/>
     public Task<bool> SetRemoveAsync<T>(string key, T item, CommandFlags flag = CommandFlags.None)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(item);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (item == null)
             throw new ArgumentNullException(nameof(item), "item cannot be null.");
+#endif
 
         var serializedObject = Serializer.Serialize(item);
 
@@ -371,11 +399,16 @@ public Task<bool> SetRemoveAsync<T>(string key, T item, CommandFlags flag = Comm
     /// <inheritdoc/>
     public Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items)
     {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+        ArgumentNullException.ThrowIfNull(items);
+#else
         if (string.IsNullOrEmpty(key))
             throw new ArgumentException("key cannot be empty.", nameof(key));
 
         if (items == null)
             throw new ArgumentNullException(nameof(items), "items cannot be null.");
+#endif
 
         ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
 
@@ -526,6 +559,6 @@ private static InfoDetail[] ParseCategorizedInfo(string info)
 
         info.AsSpan().EnumerateLines(ref data, ref category);
 
-        return data.ToArray();
+        return [.. data];
     }
 }