Enhance code readability

src/NRedisStack/Bloom/BloomAux.cs

@@ -1,74 +1,64 @@
 using NRedisStack.Bloom.Literals;
 using StackExchange.Redis;
 
-namespace NRedisStack
+namespace NRedisStack;
+
+public static class BloomAux
 {
-    public static class BloomAux
+    public static List<object> BuildInsertArgs(RedisKey key, IEnumerable<RedisValue> items, int? capacity,
+        double? error, int? expansion, bool nocreate, bool nonscaling)
     {
-        public static List<object> BuildInsertArgs(RedisKey key, RedisValue[] items, int? capacity,
-                                     double? error, int? expansion, bool nocreate, bool nonscaling)
-        {
-            var args = new List<object> { key };
-            args.AddCapacity(capacity);
-            args.AddError(error);
-            args.AddExpansion(expansion);
-            args.AddNoCreate(nocreate);
-            args.AddNoScaling(nonscaling);
-            args.AddItems(items);
+        var args = new List<object> { key };
+        args.AddCapacity(capacity);
+        args.AddError(error);
+        args.AddExpansion(expansion);
+        args.AddNoCreate(nocreate);
+        args.AddNoScaling(nonscaling);
+        args.AddItems(items);
 
-            return args;
-        }
+        return args;
+    }
 
-        private static void AddItems(this List<object> args, RedisValue[] items)
-        {
-            args.Add(BloomArgs.ITEMS);
-            foreach (var item in items)
-            {
-                args.Add(item);
-            }
-        }
+    private static void AddItems(this List<object> args, IEnumerable<RedisValue> items)
+    {
+        args.Add(BloomArgs.ITEMS);
+        args.AddRange(items.Cast<object>());
+    }
 
-        private static void AddNoScaling(this List<object> args, bool nonscaling)
+    private static void AddNoScaling(this ICollection<object> args, bool nonScaling)
+    {
+        if (nonScaling)
         {
-            if (nonscaling)
-            {
-                args.Add(BloomArgs.NONSCALING);
-            }
+            args.Add(BloomArgs.NONSCALING);
         }
+    }
 
-        private static void AddNoCreate(this List<object> args, bool nocreate)
+    private static void AddNoCreate(this ICollection<object> args, bool nocreate)
+    {
+        if (nocreate)
         {
-            if (nocreate)
-            {
-                args.Add(BloomArgs.NOCREATE);
-            }
+            args.Add(BloomArgs.NOCREATE);
         }
+    }
 
-        private static void AddExpansion(this List<object> args, int? expansion)
-        {
-            if (expansion != null)
-            {
-                args.Add(BloomArgs.EXPANSION);
-                args.Add(expansion);
-            }
-        }
+    private static void AddExpansion(this ICollection<object> args, int? expansion)
+    {
+        if (expansion == null) return;
+        args.Add(BloomArgs.EXPANSION);
+        args.Add(expansion);
+    }
 
-        private static void AddError(this List<object> args, double? error)
-        {
-            if (error != null)
-            {
-                args.Add(BloomArgs.ERROR);
-                args.Add(error);
-            }
-        }
+    private static void AddError(this ICollection<object> args, double? error)
+    {
+        if (error == null) return;
+        args.Add(BloomArgs.ERROR);
+        args.Add(error);
+    }
 
-        private static void AddCapacity(this List<object> args, int? capacity)
-        {
-            if (capacity != null)
-            {
-                args.Add(BloomArgs.CAPACITY);
-                args.Add(capacity);
-            }
-        }
+    private static void AddCapacity(this ICollection<object> args, int? capacity)
+    {
+        if (capacity == null) return;
+        args.Add(BloomArgs.CAPACITY);
+        args.Add(capacity);
     }
-}
+}

src/NRedisStack/Bloom/BloomCommandBuilder.cs

@@ -1,100 +1,90 @@
 using NRedisStack.RedisStackCommands;
 using StackExchange.Redis;
 using NRedisStack.Bloom.Literals;
-namespace NRedisStack
-{
+namespace NRedisStack;
 
-    public static class BloomCommandBuilder
+public static class BloomCommandBuilder
+{
+    public static SerializedCommand Add(RedisKey key, RedisValue item)
     {
-        public static SerializedCommand Add(RedisKey key, RedisValue item)
-        {
-            return new SerializedCommand(BF.ADD, key, item);
-        }
-
-        public static SerializedCommand Card(RedisKey key)
-        {
-            return new SerializedCommand(BF.CARD, key);
-        }
+        return new SerializedCommand(BF.ADD, key, item);
+    }
 
-        public static SerializedCommand Exists(RedisKey key, RedisValue item)
-        {
-            return new SerializedCommand(BF.EXISTS, key, item);
-        }
+    public static SerializedCommand Card(RedisKey key)
+    {
+        return new SerializedCommand(BF.CARD, key);
+    }
 
-        public static SerializedCommand Info(RedisKey key)
-        {
-            return new SerializedCommand(BF.INFO, key);
-        }
+    public static SerializedCommand Exists(RedisKey key, RedisValue item)
+    {
+        return new SerializedCommand(BF.EXISTS, key, item);
+    }
 
-        public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? capacity = null,
-                                               double? error = null, int? expansion = null,
-                                               bool nocreate = false, bool nonscaling = false)
-        {
-            if (items.Length < 1)
-                throw new ArgumentOutOfRangeException(nameof(items));
+    public static SerializedCommand Info(RedisKey key)
+    {
+        return new SerializedCommand(BF.INFO, key);
+    }
 
-            var args = BloomAux.BuildInsertArgs(key, items, capacity, error, expansion, nocreate, nonscaling);
+    public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? capacity = null,
+        double? error = null, int? expansion = null,
+        bool nocreate = false, bool nonscaling = false)
+    {
+        if (items.Length < 1)
+            throw new ArgumentOutOfRangeException(nameof(items));
 
-            return new SerializedCommand(BF.INSERT, args);
-        }
+        var args = BloomAux.BuildInsertArgs(key, items, capacity, error, expansion, nocreate, nonscaling);
 
-        public static SerializedCommand LoadChunk(RedisKey key, long iterator, Byte[] data)
-        {
-            return new SerializedCommand(BF.LOADCHUNK, key, iterator, data);
-        }
+        return new SerializedCommand(BF.INSERT, args);
+    }
 
-        public static SerializedCommand MAdd(RedisKey key, params RedisValue[] items)
-        {
-            if (items.Length < 1)
-                throw new ArgumentOutOfRangeException(nameof(items));
+    public static SerializedCommand LoadChunk(RedisKey key, long iterator, Byte[] data)
+    {
+        return new SerializedCommand(BF.LOADCHUNK, key, iterator, data);
+    }
 
-            List<object> args = new List<object> { key };
+    public static SerializedCommand MAdd(RedisKey key, params RedisValue[] items)
+    {
+        if (items.Length < 1)
+            throw new ArgumentOutOfRangeException(nameof(items));
 
-            foreach (var item in items)
-            {
-                args.Add(item);
-            }
+        List<object> args = [key];
+        args.AddRange(items.Cast<object>());
 
-            return new SerializedCommand(BF.MADD, args);
-        }
+        return new SerializedCommand(BF.MADD, args);
+    }
 
-        public static SerializedCommand MExists(RedisKey key, RedisValue[] items)
-        {
-            if (items.Length < 1)
-                throw new ArgumentOutOfRangeException(nameof(items));
+    public static SerializedCommand MExists(RedisKey key, RedisValue[] items)
+    {
+        if (items.Length < 1)
+            throw new ArgumentOutOfRangeException(nameof(items));
 
-            List<object> args = new List<object> { key };
+        List<object> args = [key];
+        args.AddRange(items.Cast<object>());
 
-            foreach (var item in items)
-            {
-                args.Add(item);
-            }
+        return new SerializedCommand(BF.MEXISTS, args);
 
-            return new SerializedCommand(BF.MEXISTS, args);
+    }
 
-        }
+    public static SerializedCommand Reserve(RedisKey key, double errorRate, long capacity,
+        int? expansion = null, bool nonscaling = false)
+    {
+        List<object> args = new List<object> { key, errorRate, capacity };
 
-        public static SerializedCommand Reserve(RedisKey key, double errorRate, long capacity,
-                                                int? expansion = null, bool nonscaling = false)
+        if (expansion != null)
         {
-            List<object> args = new List<object> { key, errorRate, capacity };
-
-            if (expansion != null)
-            {
-                args.Add(expansion);
-            }
-
-            if (nonscaling)
-            {
-                args.Add(BloomArgs.NONSCALING);
-            }
-
-            return new SerializedCommand(BF.RESERVE, args);
+            args.Add(expansion);
         }
 
-        public static SerializedCommand ScanDump(RedisKey key, long iterator)
+        if (nonscaling)
         {
-            return new SerializedCommand(BF.SCANDUMP, key, iterator);
+            args.Add(BloomArgs.NONSCALING);
         }
+
+        return new SerializedCommand(BF.RESERVE, args);
+    }
+
+    public static SerializedCommand ScanDump(RedisKey key, long iterator)
+    {
+        return new SerializedCommand(BF.SCANDUMP, key, iterator);
     }
 }