Add params ReadOnlySpan overloads (#606)

* Add `params ReadOnlySpan` overloads

* Split a special overload `ToFastArray` for array

Author: LeaFrock

src/core/StackExchange.Redis.Extensions.Core/Abstractions/IRedisDatabase.cs

@@ -274,6 +274,15 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="items">Name of the member.</param>
     Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
 
+    /// <summary>
+    ///     Run SADD command http://redis.io/commands/sadd
+    /// </summary>
+    /// <typeparam name="T">The type of the expected object.</typeparam>
+    /// <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);
+
     /// <summary>
     ///     Run SREM command http://redis.io/commands/srem"
     /// </summary>
@@ -292,6 +301,15 @@ Task<bool> SetContainsAsync<T>(string key, T item, CommandFlags flag = CommandFl
     /// <param name="items">The items to store into Redis.</param>
     Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params T[] items);
 
+    /// <summary>
+    ///     Run SREM command http://redis.io/commands/srem
+    /// </summary>
+    /// <typeparam name="T">The type of the expected object.</typeparam>
+    /// <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);
+
     /// <summary>
     ///     Run SMEMBERS command see http://redis.io/commands/SMEMBERS
     /// </summary>

src/core/StackExchange.Redis.Extensions.Core/Extensions/SpanExtensions.cs

@@ -47,4 +47,28 @@ public static void EnumerateLines(this ReadOnlySpan<char> span, ref List<InfoDet
             }
         }
     }
+
+    public static bool Any<T>(this ReadOnlySpan<T> span, Predicate<T> condition)
+    {
+        for (var i = 0; i < span.Length; i++)
+        {
+            if (condition(span[i]))
+                return true;
+        }
+
+        return false;
+    }
+
+    public static TResult[] ToFastArray<TSource, TResult>(this ReadOnlySpan<TSource> span, Func<TSource, TResult> action)
+    {
+        if (span.IsEmpty)
+            return [];
+
+        var result = new TResult[span.Length];
+
+        for (var i = 0; i < span.Length; i++)
+            result[i] = action.Invoke(span[i]);
+
+        return result;
+    }
 }

src/core/StackExchange.Redis.Extensions.Core/Helpers/ExceptionThrowHelper.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+using StackExchange.Redis.Extensions.Core.Extensions;
+
+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))
+            ThrowNullElementException(paramName);
+    }
+
+    [DoesNotReturn]
+    private static void ThrowNullElementException(string? paramName)
+    {
+        throw new ArgumentException("items cannot contains any null item.", paramName);
+    }
+}

src/core/StackExchange.Redis.Extensions.Core/Helpers/RedisKeyHelper.cs

@@ -31,46 +31,33 @@ public static void FastIteration<TSource>(this ICollection<TSource>? request, Ac
         }
     }
 
-    public static TResult[] ToFastArray<TSource, TResult>(this ICollection<TSource>? request, Func<TSource, TResult> action)
+    public static TResult[] ToFastArray<TSource, TResult>(this TSource[]? source, Func<TSource, TResult> action)
     {
-        if (request == null)
+        if (source is not { Length: > 0 })
             return [];
 
-        var result = new TResult[request.Count];
+        var result = new TResult[source.Length];
+        for (var i = 0; i < source.Length; i++)
+            result[i] = action.Invoke(source[i]);
 
-        if (request is TSource[] sourceArray)
-        {
-            ref var searchSpace = ref MemoryMarshal.GetReference(sourceArray.AsSpan());
-
-            for (var i = 0; i < sourceArray.Length; i++)
-            {
-                ref var r = ref Unsafe.Add(ref searchSpace, i);
-
-                result[i] = action.Invoke(r);
-            }
-        }
-        /*
-
-         This could be helpful when we drop old frameworks
+        return result;
+    }
 
-        else if (request is List<TSource> sourceList)
-        {
-            var span = CollectionsMarshal.AsSpan(sourceList);
-            ref var searchSpace = ref MemoryMarshal.GetReference(span);
+    public static TResult[] ToFastArray<TSource, TResult>(this ICollection<TSource>? source, Func<TSource, TResult> action)
+    {
+        if (source is null)
+            return [];
 
-            for (var i = 0; i < span.Length; i++)
-            {
-                ref var r = ref Unsafe.Add(ref searchSpace, i);
+        var srcCnt = source.Count;
+        if (srcCnt == 0)
+            return [];
 
-                result[i] =  action.Invoke(r);
-            }
-        }
-        */
-        else
+        var result = new TResult[srcCnt];
+        var i = 0;
+        foreach (var item in source)
         {
-            var i = 0;
-            foreach (var r in request)
-                result[i++] = action.Invoke(r);
+            result[i] = action.Invoke(item);
+            i++;
         }
 
         return result;

src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs

@@ -323,8 +323,27 @@ public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags
         if (items == null)
             throw new ArgumentNullException(nameof(items), "items cannot be null.");
 
-        if (items.Any(item => item == null))
-            throw new ArgumentException("items cannot contains any null item.", nameof(items));
+        ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
+
+        var values = items.ToFastArray(item => (RedisValue)Serializer.Serialize(item));
+
+        return Database
+            .SetAddAsync(
+                key,
+                values,
+                flag);
+    }
+
+    /// <inheritdoc/>
+    public Task<long> SetAddAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items)
+    {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+#else
+        if (string.IsNullOrEmpty(key))
+            throw new ArgumentException("key cannot be empty.", nameof(key));
+#endif
+        ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
 
         var values = items.ToFastArray(item => (RedisValue)Serializer.Serialize(item));
 
@@ -358,8 +377,23 @@ public Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFl
         if (items == null)
             throw new ArgumentNullException(nameof(items), "items cannot be null.");
 
-        if (items.Any(item => item == null))
-            throw new ArgumentException("items cannot contains any null item.", nameof(items));
+        ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
+
+        var values = items.ToFastArray(item => (RedisValue)Serializer.Serialize(item));
+
+        return Database.SetRemoveAsync(key, values, flag);
+    }
+
+    /// <inheritdoc/>
+    public Task<long> SetRemoveAllAsync<T>(string key, CommandFlags flag = CommandFlags.None, params ReadOnlySpan<T> items)
+    {
+#if NET8_0_OR_GREATER
+        ArgumentException.ThrowIfNullOrEmpty(key);
+#else
+        if (string.IsNullOrEmpty(key))
+            throw new ArgumentException("key cannot be empty.", nameof(key));
+#endif
+        ExceptionThrowHelper.ThrowIfExistsNullElement(items, nameof(items));
 
         var values = items.ToFastArray(item => (RedisValue)Serializer.Serialize(item));