Differences in string compare methods in C#

 

Comparing string in C# is pretty simple. In fact there are several ways to do it. I have listed some in the block below. What I am curious about are the differences between them and when one should be used over the others? Should one be avoided at all costs? Are there more I haven't listed? 

string testString = "Test";
string anotherString = "Another";

if (testString.CompareTo(anotherString) == 0) {}
if (testString.Equals(anotherString)) {}
if (testString == anotherString) {}

(Note: I am looking for equality in this example, not less than or greater than but feel free to comment on that as well)

Here are the rules for how these functions work:

stringValue.CompareTo(otherStringValue)

  • null comes before a string
  • it uses CultureInfo.CurrentCulture.CompareInfo.Compare , which means it will use a culture-dependent comparison. This might mean that ß will compare equal to SS in Germany, or similar

    • stringValue.Equals(otherStringValue)

  • null is not considered equal to anything
  • unless you specify a StringComparison option, it will use what looks like a direct ordinal equality check, ie ß is not the same as SS , in any language or culture

    • stringValue == otherStringValue

  • Is not the same as stringValue.Equals() .
  • The == operator calls the static Equals(string a, string b) method (which in turn goes to an internal EqualsHelper to do the comparison.
  • Calling .Equals() on a null string gets null reference exception, while on == does not.

    • Object.ReferenceEquals(stringValue, otherStringValue)

    Just checks that references are the same, ie it isn't just two strings with the same contents, you're comparing a string object with itself.

    Note that with the options above that use method calls, there are overloads with more options to specify how to compare.

    My advice if you just want to check for equality is to make up your mind whether you want to use a culture-dependent comparison or not, and then use .CompareTo or .Equals , depending on the choice.

    From MSDN:

    "The CompareTo method was designed primarily for use in sorting or alphabetizing operations. It should not be used when the primary purpose of the method call is to determine whether two strings are equivalent. To determine whether two strings are equivalent, call the Equals method."

    They suggest using .Equals instead of .CompareTo when looking solely for equality. I am not sure if there is a difference between .Equals and == for the string class. I will sometimes use .Equals or Object.ReferenceEquals instead of == for my own classes in case someone comes along at a later time and redefines the == operator for that class.

    If you are ever curious about differences in BCL methods, Reflector is your friend :-)

    I follow these guidelines:

    Exact match: EDIT: I previously always used == operator on the principle that inside Equals(string, string) the object == operator is used to compare the object references but it seems strA.Equals(strB) is still 1-11% faster overall than string.Equals(strA, strB), strA == strB, and string.CompareOrdinal(strA, strB). I loop tested with a StopWatch on both interned/non-interned string values, with same/different string lengths, and varying sizes (1B to 5MB). 

    strA.Equals(strB)

    Human-readable match (Western cultures, case-insensitive): 

    string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase) == 0

    Human-readable match (All other cultures, insensitive case/accent/kana/etc defined by CultureInfo): 

    string.Compare(strA, strB, myCultureInfo) == 0

    Human-readable match with custom rules (All other cultures): 

    CompareOptions compareOptions = CompareOptions.IgnoreCase
                              | CompareOptions.IgnoreWidth
                              | CompareOptions.IgnoreNonSpace;
string.Compare(strA, strB, CultureInfo.CurrentCulture, compareOptions) == 0
    链接地址: http://www.djcxy.com/p/58630.html

    上一篇: 如何正确比较Java中的两个整数？

    下一篇: C＃中字符串比较方法的差异