Comparing two strings, ignoring case in C# [duplicate]

This question already has an answer here开发者_StackOverflow中文版: What is difference between different string compare methods [duplicate] (1 answer) Closed 3 years ago.

Which of the following two is more efficient? (Or maybe is there a third option that's better still?)

string val = "AStringValue";

if (val.Equals("astringvalue", StringComparison.InvariantCultureIgnoreCase))

OR

if (val.ToLowerCase() == "astringvalue")

?

---

If you're looking for efficiency, use this:

string.Equals(val, "astringvalue", StringComparison.OrdinalIgnoreCase)

Ordinal comparisons can be significantly faster than culture-aware comparisons.

ToLowerCase can be the better option if you're doing a lot of comparisons against the same string, however.

As with any performance optimization: measure it, then decide!

---

The first one is the correct one, and IMHO the more efficient one, since the second 'solution' instantiates a new string instance.

---

The .ToLowerCase version is not going to be faster - it involves an extra string allocation (which must later be collected), etc.

Personally, I'd use

string.Equals(val, "astringvalue",  StringComparison.OrdinalIgnoreCase)

this avoids all the issues of culture-sensitive strings, but as a consequence it avoids all the issues of culture-sensitive strings. Only you know whether that is OK in your context.

Using the string.Equals static method avoids any issues with val being null.

---

My general answer to this kind of question on "efficiency" is almost always, which ever version of the code is most readable, is the most efficient.

That being said, I think (val.ToLowerCase() == "astringvalue") is pretty understandable at a glance by most people.

The efficience I refer to is not necesseraly in the execution of the code but rather in the maintanance and generally readability of the code in question.

---

I'd venture that the safest is to use the static method String.Equals to mitigate against the possibility of a NullReferenceException in the case that val is null.

---

The former is fastest. Turns out that val is immutable, and so a new string object is created with String.ToLowerCase(), rather than just direct comparison with the string comparer. Creating a new string object can be costly if you're doing this many times a second.

---

you may also want to look at that already answered question Differences in string compare methods in C#

---

1st is more efficient (and the best possible option) because val.ToLowerCase() creates a new object since Strings are immutable.