C#: Sorted Set Public Preview Commands (#4467)

Signed-off-by: Edward Liang <edward.liang@improving.com>

Author: edlng

.gitignore

@@ -75,3 +75,6 @@ cpp/src/connection_request.pb.cc
 **/.claude/settings.local.json
 copilot-instructions.md
 **/.yarn
+
+# AI agent related files
+.kiro/

csharp/sources/Valkey.Glide/BaseClient.SortedSetCommands.cs

@@ -30,4 +30,48 @@ public async Task<bool> SortedSetRemoveAsync(ValkeyKey key, ValkeyValue member,
 
     public async Task<long> SortedSetRemoveAsync(ValkeyKey key, ValkeyValue[] members, CommandFlags flags = CommandFlags.None)
         => await Command(Request.SortedSetRemoveAsync(key, members, flags));
+
+    public async Task<long> SortedSetLengthAsync(ValkeyKey key, double min = double.NegativeInfinity, double max = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None)
+    {
+        // If both min and max are infinity (default values), use ZCARD
+        if (double.IsNegativeInfinity(min) && double.IsPositiveInfinity(max))
+        {
+            return await SortedSetCardAsync(key, flags);
+        }
+
+        // Otherwise use ZCOUNT with the specified range
+        return await SortedSetCountAsync(key, min, max, exclude, flags);
+    }
+
+    public async Task<long> SortedSetCardAsync(ValkeyKey key, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetCardAsync(key, flags));
+
+    public async Task<long> SortedSetCountAsync(ValkeyKey key, double min = double.NegativeInfinity, double max = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetCountAsync(key, min, max, exclude, flags));
+
+    public async Task<ValkeyValue[]> SortedSetRangeByRankAsync(ValkeyKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetRangeByRankAsync(key, start, stop, order, flags));
+
+    public async Task<SortedSetEntry[]> SortedSetRangeByRankWithScoresAsync(ValkeyKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetRangeByRankWithScoresAsync(key, start, stop, order, flags));
+
+    public async Task<ValkeyValue[]> SortedSetRangeByScoreAsync(ValkeyKey key, double start = double.NegativeInfinity, double stop = double.PositiveInfinity, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetRangeByScoreAsync(key, start, stop, exclude, order, skip, take, flags));
+
+    public async Task<SortedSetEntry[]> SortedSetRangeByScoreWithScoresAsync(ValkeyKey key, double start = double.NegativeInfinity, double stop = double.PositiveInfinity, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetRangeByScoreWithScoresAsync(key, start, stop, exclude, order, skip, take, flags));
+
+    public async Task<ValkeyValue[]> SortedSetRangeByValueAsync(ValkeyKey key, ValkeyValue min, ValkeyValue max, Exclude exclude, long skip, long take, CommandFlags flags = CommandFlags.None)
+        => await SortedSetRangeByValueAsync(key, min, max, exclude, Order.Ascending, skip, take, flags);
+
+    public async Task<ValkeyValue[]> SortedSetRangeByValueAsync(
+        ValkeyKey key,
+        ValkeyValue min = default,
+        ValkeyValue max = default,
+        Exclude exclude = Exclude.None,
+        Order order = Order.Ascending,
+        long skip = 0,
+        long take = -1,
+        CommandFlags flags = CommandFlags.None)
+        => await Command(Request.SortedSetRangeByValueAsync(key, min, max, exclude, order, skip, take, flags));
 }

csharp/sources/Valkey.Glide/Commands/Constants/Constants.cs

@@ -13,4 +13,29 @@ public static class Constants
     public const string AbsttlKeyword = "ABSTTL";
     public const string IdletimeKeyword = "IDLETIME";
     public const string FreqKeyword = "FREQ";
+    public const string WithScoresKeyword = "WITHSCORES";
+    public const string ReverseKeyword = "REV";
+    public const string ByLexKeyword = "BYLEX";
+    public const string ByScoreKeyword = "BYSCORE";
+
+    /// <summary>
+    /// The highest bound in the sorted set for lexicographical operations.
+    /// </summary>
+    public const string PositiveInfinity = "+";
+
+    /// <summary>
+    /// The lowest bound in the sorted set for lexicographical operations.
+    /// </summary>
+    public const string NegativeInfinity = "-";
+
+    /// <summary>
+    /// The highest bound in the sorted set for score operations.
+    /// </summary>
+    public const string PositiveInfinityScore = "+inf";
+
+    /// <summary>
+    /// The lowest bound in the sorted set for score operations.
+    /// </summary>
+    public const string NegativeInfinityScore = "-inf";
+
 }

csharp/sources/Valkey.Glide/Commands/ISortedSetCommands.cs

@@ -106,4 +106,260 @@ public interface ISortedSetCommands
     /// </example>
     /// </remarks>
     Task<long> SortedSetRemoveAsync(ValkeyKey key, ValkeyValue[] members, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the sorted set cardinality (number of elements) of the sorted set stored at key.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zcard"/>
+    /// <seealso href="https://valkey.io/commands/zcount"/>
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="min">The min score to filter by (defaults to negative infinity).</param>
+    /// <param name="max">The max score to filter by (defaults to positive infinity).</param>
+    /// <param name="exclude">Whether to exclude <paramref name="min"/> and <paramref name="max"/> from the range check (defaults to both inclusive).</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>The cardinality (number of elements) of the sorted set, or 0 if key does not exist.</returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// // Get total cardinality
+    /// long totalCount = await client.SortedSetLengthAsync(key);
+    /// 
+    /// // Count elements in score range
+    /// long rangeCount = await client.SortedSetLengthAsync(key, 1.0, 10.0);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<long> SortedSetLengthAsync(ValkeyKey key, double min = double.NegativeInfinity, double max = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the cardinality (number of elements) of the sorted set stored at key.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zcard"/>
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	The number of elements in the sorted set.
+    ///	If key does not exist, it is treated as an empty sorted set, and this command returns 0.
+    ///	If key holds a value that is not a sorted set, an error is returned.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// long result = await client.SortedSetCardAsync(key);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<long> SortedSetCardAsync(ValkeyKey key, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the number of members in the sorted set stored at key with scores between min and max score.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zcount"/>
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="min">The minimum score to count from (defaults to negative infinity).</param>
+    /// <param name="max">The maximum score to count up to (defaults to positive infinity).</param>
+    /// <param name="exclude">Whether to exclude min and max from the range check (defaults to both inclusive).</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>The number of members in the specified score range.</returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// long result = await client.SortedSetCountAsync(key, 1.0, 10.0);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<long> SortedSetCountAsync(ValkeyKey key, double min = double.NegativeInfinity, double max = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements in the sorted set stored at key by their index (rank).
+    /// By default the elements are considered to be ordered from the lowest to the highest score.
+    /// Both start and stop are zero-based indexes, where 0 is the first element, 1 is the next element and so on.<br/>
+    /// To get the elements with their scores, <see cref="SortedSetRangeByRankWithScoresAsync" />.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="start">The start index to get.</param>
+    /// <param name="stop">The stop index to get.</param>
+    /// <param name="order">The order to sort by (defaults to ascending).</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// ValkeyValue[] result = await client.SortedSetRangeByRankAsync(key, 0, 10);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<ValkeyValue[]> SortedSetRangeByRankAsync(ValkeyKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements with their scores in the sorted set stored at key by their index (rank).
+    /// By default the elements are considered to be ordered from the lowest to the highest score.
+    /// Both start and stop are zero-based indexes, where 0 is the first element, 1 is the next element and so on.<br/>
+    /// To get the elements without their scores, <see cref="SortedSetRangeByRankAsync" />.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <seealso href="https://redis.io/commands/zrevrange"/>.
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="start">The start index to get.</param>
+    /// <param name="stop">The stop index to get.</param>
+    /// <param name="order">The order to sort by (defaults to ascending).</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements and their scores within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// SortedSetEntry[] result = await client.SortedSetRangeByRankWithScoresAsync(key, 0, 10);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<SortedSetEntry[]> SortedSetRangeByRankWithScoresAsync(ValkeyKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements in the sorted set stored at key by their score.
+    /// By default the elements are considered to be ordered from the lowest to the highest score.
+    /// Start and stop are used to specify the min and max range for score values.
+    /// To get the elements with their scores, <see cref="SortedSetRangeByScoreWithScoresAsync" />.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <seealso href="https://redis.io/commands/zrevrange"/>.
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="start">The minimum score to filter by.</param>
+    /// <param name="stop">The maximum score to filter by.</param>
+    /// <param name="exclude">Which of start and stop to exclude (defaults to both inclusive).</param>
+    /// <param name="order">The order to sort by (defaults to ascending).</param>
+    /// <param name="skip">How many items to skip.</param>
+    /// <param name="take">How many items to take.</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// ValkeyValue[] result = await client.SortedSetRangeByScoreAsync(key, 1.0, 10.0);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<ValkeyValue[]> SortedSetRangeByScoreAsync(
+        ValkeyKey key,
+        double start = double.NegativeInfinity,
+        double stop = double.PositiveInfinity,
+        Exclude exclude = Exclude.None,
+        Order order = Order.Ascending,
+        long skip = 0,
+        long take = -1,
+        CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements in the sorted set stored at key with their scores by their score.
+    /// By default the elements are considered to be ordered from the lowest to the highest score.
+    /// Start and stop are used to specify the min and max range for score values 
+    /// To get the elements without their scores, <see cref="SortedSetRangeByScoreAsync" />.
+    /// </summary>.
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <seealso href="https://redis.io/commands/zrevrange"/>.
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="start">The minimum score to filter by.</param>
+    /// <param name="stop">The maximum score to filter by.</param>
+    /// <param name="exclude">Which of start and stop to exclude (defaults to both inclusive).</param>
+    /// <param name="order">The order to sort by (defaults to ascending).</param>
+    /// <param name="skip">How many items to skip.</param>
+    /// <param name="take">How many items to take.</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements and their scores within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// SortedSetEntry[] result = await client.SortedSetRangeByScoreWithScoresAsync(key, 1.0, 10.0);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<SortedSetEntry[]> SortedSetRangeByScoreWithScoresAsync(
+        ValkeyKey key,
+        double start = double.NegativeInfinity,
+        double stop = double.PositiveInfinity,
+        Exclude exclude = Exclude.None,
+        Order order = Order.Ascending,
+        long skip = 0,
+        long take = -1,
+        CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements in the sorted set stored at key by their lexicographical order.
+    /// This command returns all the elements in the sorted set at key with a value between min and max.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <seealso href="https://redis.io/commands/zrevrange"/>.
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="min">The min value to filter by.</param>
+    /// <param name="max">The max value to filter by.</param>
+    /// <param name="exclude">Which of min and max to exclude.</param>
+    /// <param name="skip">How many items to skip.</param>
+    /// <param name="take">How many items to take.</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// ValkeyValue[] result = await client.SortedSetRangeByValueAsync(key, "a", "z", Exclude.None, 0, -1);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<ValkeyValue[]> SortedSetRangeByValueAsync(
+        ValkeyKey key,
+        ValkeyValue min,
+        ValkeyValue max,
+        Exclude exclude,
+        long skip,
+        long take = -1,
+        CommandFlags flags = CommandFlags.None);
+
+    /// <summary>
+    /// Returns the specified range of elements in the sorted set stored at key by their lexicographical order.
+    /// This command returns all the elements in the sorted set at key with a value between min and max.
+    /// </summary>
+    /// <seealso href="https://valkey.io/commands/zrange"/>
+    /// <seealso href="https://redis.io/commands/zrevrange"/>.
+    /// <param name="key">The key of the sorted set.</param>
+    /// <param name="min">The min value to filter by.</param>
+    /// <param name="max">The max value to filter by.</param>
+    /// <param name="exclude">Which of min and max to exclude (defaults to both inclusive).</param>
+    /// <param name="order">The order to sort by (defaults to ascending).</param>
+    /// <param name="skip">How many items to skip.</param>
+    /// <param name="take">How many items to take.</param>
+    /// <param name="flags">The flags to use for this operation. Currently flags are ignored.</param>
+    /// <returns>
+    ///	An array of elements within the specified range.
+    ///	If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.
+    /// </returns>
+    /// <remarks>
+    /// <example>
+    /// <code>
+    /// ValkeyValue[] result = await client.SortedSetRangeByValueAsync(key, "a", "z", order: Order.Descending);
+    /// </code>
+    /// </example>
+    /// </remarks>
+    Task<ValkeyValue[]> SortedSetRangeByValueAsync(
+        ValkeyKey key,
+        ValkeyValue min = default,
+        ValkeyValue max = default,
+        Exclude exclude = Exclude.None,
+        Order order = Order.Ascending,
+        long skip = 0,
+        long take = -1,
+        CommandFlags flags = CommandFlags.None);
 }

csharp/sources/Valkey.Glide/Commands/Options/ZCountOptions.cs

@@ -0,0 +1,27 @@
+// Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+
+namespace Valkey.Glide.Commands.Options;
+
+/// <summary>
+/// Represents the range options for the ZCOUNT command.
+/// </summary>
+/// <param name="min">The minimum score boundary.</param>
+/// <param name="max">The maximum score boundary.</param>
+public readonly struct ZCountRange(ScoreBoundary min, ScoreBoundary max)
+{
+    /// <summary>
+    /// The minimum score boundary.
+    /// </summary>
+    public ScoreBoundary Min { get; } = min;
+
+    /// <summary>
+    /// The maximum score boundary.
+    /// </summary>
+    public ScoreBoundary Max { get; } = max;
+
+    /// <summary>
+    /// Converts the range to command arguments.
+    /// </summary>
+    /// <returns>An array of string arguments for the command.</returns>
+    internal string[] ToArgs() => [Min.ToString(), Max.ToString()];
+}