Write a method that parses a comma-separated filter string into validated filter values.

• Null or blank filter returns an empty dictionary.
• Keys are case-insensitive.
• The allowed key set must be provided.
• Unknown keys throw ArgumentException.
• Segments without : throw ArgumentException.
• Last duplicate key wins.

I would split on commas for segments, then split each segment at the first colon. I would trim key and value, copy the allowed keys into a case-insensitive lookup, and store parsed filters in a case-insensitive dictionary. I would avoid accepting arbitrary keys because API filters often become SQL or query-building input later.

public static IReadOnlyDictionary<string, string> ParseFilters(
    string? filter,
    ISet<string> allowedKeys)
{
    if (allowedKeys is null)
    {
        throw new ArgumentNullException(nameof(allowedKeys));
    }

    var result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
    var allowed = new HashSet<string>(allowedKeys, StringComparer.OrdinalIgnoreCase);

    if (string.IsNullOrWhiteSpace(filter))
    {
        return result;
    }

    foreach (var segment in filter.Split(',', StringSplitOptions.RemoveEmptyEntries))
    {
        var separatorIndex = segment.IndexOf(':');
        if (separatorIndex <= 0 || separatorIndex == segment.Length - 1)
        {
            throw new ArgumentException($"Invalid filter segment '{segment}'.");
        }

        var key = segment[..separatorIndex].Trim();
        var value = segment[(separatorIndex + 1)..].Trim();

        if (!allowed.Contains(key))
        {
            throw new ArgumentException($"Filter '{key}' is not supported.");
        }

        result[key] = value;
    }

    return result;
}

Parsing is O(n) over the filter string plus dictionary lookups for each segment. Space is O(k), where k is the number of distinct parsed keys.

• Blank input.
• Unknown filter key.
• Missing colon or missing value.
• Duplicate keys.
• Value containing a colon if the format allows it; this implementation keeps text after the first colon.

• Use spaces around keys and values.
• Use casing differences such as Status and status.
• Use unsupported keys to ensure validation fails early.

• Accepting arbitrary keys and pushing risk downstream.
• Splitting on every colon and breaking values that contain colon.
• Not trimming whitespace.
• Leaving duplicate behavior undefined.