Proposal: switch ignore case

[lechu445]

Currently switch statement on strings is case-sensitive.
Consider a way to provide an ignore-case switch construct so it could be optimized by compiler.

My example proposal:

switch(text, StringComparison.OrdinalIgnoreCase)
{
    case "some_value1":  
        break;  
    case "some_value2":  
        break;  
}

[yaakov-h]

How would this work?

[tannergooding]

Why not just switch(text.ToLower()) or switch(text.ToLowerInvariant())?

[tannergooding]

It would seem like a more generally useful feature (but still one that was just syntax sugar) would be to allow:

switch (T, IComparable) and have it lowered to an if...else chain that checks T against case using the specified comparer.

[yaakov-h]

@tannergooding How about IComparer or IEqualityComparer, too?

[mburbea]

@tannergooding , string switches generate a dictionary last I checked, so it should be possible to change the dictionary to have a StringComparer passed to it.

Also, if you're going to do the normalization approach, you should do text.ToUpperInvariant() based on the guidance found here. https://msdn.microsoft.com/en-us/library/bb386042.aspx

[Richiban]

Active patterns would solve this issue, although the syntax might look a little different, e.g.

switch(s)
{
    case IgnoreCase("some_value1"):
        break;  
    case IgnoreCase("some_value2"):
        break;  
}

[Richiban]

I would prefer to leave the switch(x, y) syntax for switching on two values at the same time (i.e. switching on a ValueTuple):

public static string FizzBuzz(int n)
{
    switch(i % 3, i % 5)
    {
        case (0, 0): return "fizzbuzz";
        case (0, _): return "fizz";
        case (_, 0): return "buzz";
        default:     return n.ToString();
    }
}

[vladd]

@tannergooding
"Why not just switch(text.ToLower())" — because it is not the same.

[gafter]

string.ToLower() uses the invariant culture's mapping, but that is an old incorrect frozen-in-time Unicode case-lower mapping. See https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/CaseInsensitiveComparison.cs for the lower-case mapping used by the VB compiler. It has a special case for the Turkish İ to compensate for the possibility that the platform lacks a suitable modern Unicode implementation (for most purposes removing the special case would have no effect).

[tannergooding]

@vladd, right. Looks like ToUpperInvariant() is the correct version to use:

• @mburbea's comment Proposal: switch ignore case #1321 (comment)
• The actual String.Equals implementation for OrdinalIgnoreCase does something similar
  • https://source.dot.net/#System.Private.CoreLib/src/System/String.Comparison.cs,949

In either case, I would still think supporting a more general syntax would be desirable:

• switch (T, IComparable)
• switch (T, IComparer)
• switch (T, IEqualityComparer)

That makes it more generally useful and still handles the desired case.

[HaloFour]

@tannergooding

For simple switch statements that does make sense, but in my opinion it makes a lot less sense now that switch is effectively a vehicle for pattern matching. It's not clear or obvious where any comparer would apply to anything other than constant patterns, and there might be some assumption that it would apply to recursive patterns, e.g.:

switch (person, StringComparer.OrdinalIgnoreCase) {
    case { LastName is "Gates" }: 
        // matches when LastName is "gates" or "GATES"?
        break;
}

[gafter]

ToUpperInvariant is not correct for two reasons. First, it uses the buggy Unicode table of the invariant locale. Second, it performs an upper-case mapping instead of a lower-case mapping. The advice of CA1308 is founded on the incorrect logic that a lower-case mapping produces results that do not round-trip. But that is true of the upper-case mapping as well - the whole point of the mapping is to map different characters to the same one for the purposes of considering them to be "the same". The Unicode specifications, and the historical VB language implementations, base case folding (which is used to compare strings ignoring case) on a locale-independent lower-case mapping.

[lechu445]

Dictionary can use IEqualityComparer<TKey> in constructor https://source.dot.net/#System.Private.CoreLib/shared/System/Collections/Generic/Dictionary.cs,69, so I would think adding switch (T, IEqualityComparer<T>) overload.

switch(text.ToUpper()), swich(text.ToUpperInvariant()), etc. - this approach requires extra string conversion and allocation.

[TheConstructor]

Any status on this?

If string-matching already uses a Dictionary to implement switch, I would also support a syntax to specify the IEqualityComparer<T>.

• It may not be combinable with case-patterns, but wouldn't block you from adding when. There just needs to be a decision, if patterns can be used, ignoring the setting, or would be syntax-errors, if a comparer is specified.
• It offers a natural way to adjust switch-behavior for other types
• Lastly in most cases, where I want to use StringComparer.OrdinalIgnoreCase, I usually have string-constant cases

For me it would seem to a good addition to the language

[333fred]

This is not championed by any member of the LDM, so there is no status.

[TahirAhmadov]

I don't think this was mentioned previously, so here goes: not only there are issues with ToLower() WRT non-English letters, but let's not forget it allocates another string, whereas an equator method can compare in case insensitive manner without such allocation.

PS. Right after I wrote this, I found one comment above which mentioned allocation :) Oh well, I'll just leave it be.

[hrumhurum]

Here comes a C# syntax proposal for switch statements and expressions with configurable comparer.

1. Allow switch statements by a StringComparison:

switch (text) by StringComparison.OrdinalIgnoreCase
{
    case "some_value1":  
        break;  
    case "some_value2":  
        break;  
}

2. Allow switch statements by a comparer:

switch (text) by StringComparer.OrdinalIgnoreCase
{
    case "some_value1":  
        break;  
    case "some_value2":  
        break;  
}

3. Allow switch expressions by a StringComparison:

int token =
    text switch by StringComparison.OrdinalIgnoreCase
    {
        "some_value1" => 0,
        "some_value2" => 1
    };

4. Allow switch expressions by a comparer:

int token =
    text switch by StringComparer.OrdinalIgnoreCase
    {
        "some_value1" => 0,
        "some_value2" => 1
    };

The StringComparison variants are provided only for convenience due to widespread usage of System.String and System.ReadOnlySpan<char> types. The syntax variants that use a comparer are universal and allow any type to be compared, not only the string types.

[kyoyama-kazusa]

Maybe this problem will be solved via "explicit extension" with "Active Pattern" (#277) or "User-defined Positional Patterns" (#1047) (although extension feature does not support for pattern matching, it could be supported in the future):

explicit extension StringWithCasingComparisonExtension for ValueTuple<string, StringComparison>
{
    // NOTE: In fact I'm not familiar with extension declaration syntax.
    // I think it may be written like this :)
    public static bool operator is(string s)
        => this.Item1.Equals(s, this.Item2);
}

Then:

(string, StringComparison) s = ("Value_To_Be_Compared", StringComparison.OrdinalIgnoreCase);
if (s is "value_to_be_compared")
   // ...

or

if (("Value_To_Be_Compared", StringComparison.OrdinalIgnoreCase) is "value_to_be_compared")
   // ...

or

switch ("Value_To_Be_Compared", StringComparison.OrdinalIgnoreCase)
{
    case "value_to_be_compared":
        // ...
        break;
}

[gioce90]

This syntax improvement would be so amazing

[realbart]

Accepting switch (SomeType value, IEqualityComparer<SomeType>) seems to have no obvious drawbacks.

But how would we translate this to switch expressions?

Switch expressions don't need braces, so (value, myEualityComparer) switch { ... } would be interpreted as a switch over a value tuple.

Maybe value switch(myEqualityComparer) { ... } ?

[andriysavin]

Another, more radical, idea could be using the with keyword, as it's contextual. E.g. value switch with myEqualityComparer { ... }

[Richiban]

Active patterns solve this usecase and are generally are much more useful.

For example, with active patterns you will be able to specify which strings you want to match without sensitivity to case, even if they're nested in another pattern:

switch (person) {
    case { LastName is IgnoreCase("Gates") }: 
        // matches when LastName is "gates" or "GATES" or any other combination
        break;
}

The proposal, as it stands, is too narrow-focused to be included in the language, I feel.

[bartkemps]

Yes, and you can also do:

foo = person switch
{
    var p when string.Equals(p.LastName, "Gates"), StringComparison.OrdinalIgnoreCase) => 1,
    _ => 0
};

However, instead of repeating the "ToLower" you're repeating the IgnoreCase.
It's about the repeating, which is specific to switches.

    private static ProfileImageType GetProfileImageType(string name) 
        => Path.GetFileNameWithoutExtension(name) switch
        {
            var n when string.Equals(n, nameof(ProfileImageType.Avatar), StringComparison.OrdinalIgnoreCase) => ProfileImageType.Avatar,
            var n when string.Equals(n, nameof(ProfileImageType.Logo), StringComparison.OrdinalIgnoreCase) => ProfileImageType.Logo,
            _ => ProfileImageType.Unknown,
        };

There is a solid use case for long lists of types that need to compared in a similar fashion.