12

In some languages (e.g. C++) you can't use operators like == for string comparisons as that would compare the address of the string object, and not the string itself. However, in C# you can use == to compare strings, and it will actually compare the content of the strings. But there are also string functions to handle such comparisons, so my question is; should you?

Given two strings: 

string aa = "aa"; 
string bb = "bb";

Should you compare them like this: 

bool areEqual = (aa == bb);

Or should you use the Equal function, like this: 

bool areEqual = aa.Equals(bb);

Is there any technical difference anyway? Or reasonable arguments for best practice?

stiank81
  • 25,418
  • 43
  • 131
  • 202
  • 3
    Minor quibble: In C++, `std::string` can be compared with operator==. It's `char[]` and `char *` that can't. The term *string* is somewhat ambiguous in C++. – Marcelo Cantos Dec 28 '09 at 10:23
  • Thanks for clearing that up! It's been a while since I've been doing c++, and obviously my records of it is a bit buzzed.. – stiank81 Dec 28 '09 at 10:33

5 Answers5

26

This is the implementation of the operator:

    public static bool operator == (String a, String b) {
       return String.Equals(a, b);
    }

Don't lose any sleep over this.

Hans Passant
  • 922,412
  • 146
  • 1,693
  • 2,536
  • 1
    Now, that's useful to know! :-) No sleep lost anyway - really just wondering if there is a best practice. – stiank81 Dec 28 '09 at 10:34
25

I wouldn't use:

aa.Equals(bb)

unless I knew aa couldn't possibly be null. I might use:

string.Equals(aa,bb)

But I'd mainly use that it I wanted to use one of the specific StringComparison modes (invariant, ordinal, case-insensitive, etc). Although I might also use the StringComparer implementations, since they are a bit easier to abstract (for example, to pass into a Dictionary<string, Foo> for a case-insensitive ordinal dictionary). For general purpose usage,

a == b

is fine.

Marc Gravell
  • 1,026,079
  • 266
  • 2,566
  • 2,900
2

There is no technical difference (unless aa is null). Use whatever looks better to you. In my opinion, using operator overloads makes the code clearer.

Use functions when you need (or might need in future) their additional arguments (as in CompareTo())

yu_sha
  • 4,290
  • 22
  • 19
1

Best-practise-wise, I would tend to always use an Equals() function for string comparison. This makes it clear when someone else reads your code that you specifically want the strings compared.

Steve De Caux
  • 1,779
  • 12
  • 13
-3

generally speaking, == does pointer equality, while .equals checks whether the attributes are equal. So if you did something like

a = 'a';
b = 'a';
bool c = (a == b);
bool d = (a.Equals(b))

then c should return false and d should be true.

Ritwik Bose
  • 5,889
  • 8
  • 32
  • 43
  • 2
    It **really** depends what `a` and `b` are typed as here. If they are `string` it won't compile. If they are `char` it will be `true` twice. If they are `object` it will be `false`/`true`. But none of these quite match the question (and you'd need to watch for compiler interning too). – Marc Gravell Dec 28 '09 at 10:23
  • Not neccessarily as .NET uses string interning, which means that that could actually be the same string under the covers. – RCIX Dec 28 '09 at 10:25
  • @RCIX - that would only apply for `string a = "a"; string b = "a";`, but yes, I agree. – Marc Gravell Dec 28 '09 at 10:26
  • @RCIX - or more importantly, `object a = "a"; object b = "a";` – Marc Gravell Dec 28 '09 at 10:26