13

Let's say I have two strings: a and b. To compare whether a and be have the same values when case is ignored, I've always used:

// (Assume a and b have been verified not to be null)

if (a.ToLower() == b.ToLower())

However, using Reflector, I've seen this a few times in the .NET Framework:

// (arg three is ignoreCase)

if (string.Compare(a, b, true) == 0)

I tested which is faster, and the ToLower() beat Compare() every time with the strings I used.

Is there a reason why to Compare() instead of ToLower()? Something about different CultureInfo? I'm scratching my head.

Rui Jarimba
  • 11,166
  • 11
  • 56
  • 86
core
  • 32,451
  • 45
  • 138
  • 193

6 Answers6

23

The main thing you should be concerned about isn't performance, it's correctness, and from that aspect the method you probably want to be using for a case insensitive comparison is either:

string.Compare(a, b, StringComparison.OrdinalIgnoreCase) == 0;

or

a.Equals(b, StringComparison.OrdinalIgnoreCase)

(The first one is useful if you know the strings may be null; the latter is simpler to write if you already know that at least one string is non-null. I've never tested the performance but assume it will be similar.)

Ordinal or OrdinalIgnoreCase are a safe bet unless you know you want to use another comparison method; to get the information needed to make the decision read this article on MSDN.

Greg Beech
  • 133,383
  • 43
  • 204
  • 250
  • +1 here - performance just doesn't matter. And if you reach a point where using a slightly-less string comparison method is causing performance problems, you need to rethink your approach. – Rex M Feb 02 '09 at 00:42
  • 1
    Microsoft recommends against using string.Compare() to check for equalify. There is an equivalent string.Equals() that will handle the null checks. I would recommend string.Equals(a, b, StringComparison.OrdianlIgnoreCase); – JSwartzen Sep 01 '15 at 15:34
  • If the string can be null, I'd *hope* for a `NullReferenceException` instead of an incorrect result. Because you cannot compare *nothing* with *something*. In the odd cases where `null` makes sense I'd check for `null` beforehand and return `false` rather than replacing it with a *compare* function that is used to replace `Equals`, obfuscating the code. – Maarten Bodewes Nov 13 '18 at 17:26
6

The Remarks section of the MSDN article should explain things. Essentially, the reason is for compatibility across different cultures settings.

Noldorin
  • 144,213
  • 56
  • 264
  • 302
3

When comparing strings you should always use an explicit StringComparison member. The String functions are somewhat inconsistent in how they choose to compare strings. The only way to guarantee the comparision used is to a) memorize all of them (this includes both you and everyone on your team) or b) use an explicit comparison for every function.

It's much better to be explicit and not rely on group knowledge being perfect. Your teammates will thank you for this.

Example:

if ( StringComparison.OrdinalIgnoreCase.Equals(a,b) )

Using ToLower for comparison has 2 problems I can think of off the top of my head

  1. It allocates memory. Comparison functions should not allocate memory unless they absolutely have to.
  2. Strings can be lowered in several ways. Most notable Ordinal or Culture Sensitive lower. Which way does .ToLower() work? Personally, I don't know. It's much better to pass an explicit culture than rely on the default.
JaredPar
  • 733,204
  • 149
  • 1,241
  • 1,454
  • 2
    That doesn't compile. did you mean: `String.Equals(a, b, StringComparison.OrdinalIgnoreCase.Equals)`? – Avi Cherry Oct 08 '14 at 18:14
  • I don't know, I looked at the Microsoft docs and I didn't really find out what `OrdinalIgnoreCase` actually *does* either. I can hazard a guess that it only ups or lowers ASCII or Latin, but it would remain a guess. – Maarten Bodewes Nov 13 '18 at 17:29
0

ToLower() is not a comparison function, it puts the string to lower case. When the == operator is used on String objects in C# it is optimized by the compiler. At the core, Both depend on System.String.Equals as seen in Reflector.

John T
  • 23,735
  • 11
  • 56
  • 82
0

Another MSDN article that provides some DOs and DON'Ts and recommendations for what comparison method to use in various cases: New Recommendations for Using Strings in Microsoft .NET 2.0

codybartfast
  • 7,323
  • 3
  • 21
  • 25
0

Could your post your test that shows calling ToLower() is faster than a case-insensitive comparison? My tests show the opposite to be true! Regardless, other posters' points about correctness stand.

Jim Arnold
  • 2,238
  • 14
  • 18