Performance - str_01 == str_02 vs (object)str_01 == (object)str_02

Question

Is there any performance optimization in below code samples where I compare two string?

First:

public static bool Compare_01()
{
    string str_01 = "a";
    string str_02 = "a";

    if (str_01 == str_02)
        return true;
    else
        return false;
}

Two:

public static bool Compare_02()
{
    string str_01 = "a";
    string str_02 = "a";

    if ((object)str_01 == (object)str_02)
        return true;
    else
        return false;
}

Both of them return true.

There is only one different in their il code:

1st:

IL_0001:  ldstr       "a"
IL_0006:  stloc.0     // str_01
IL_0007:  ldstr       "a"
IL_000C:  stloc.1     // str_02
IL_000D:  ldloc.0     // str_01
IL_000E:  ldloc.1     // str_02
IL_000F:  call        System.String.op_Equality

2nd:

IL_0001:  ldstr       "a"
IL_0006:  stloc.0     // str_01
IL_0007:  ldstr       "a"
IL_000C:  stloc.1     // str_02
IL_000D:  ldloc.0     // str_01
IL_000E:  ldloc.1     // str_02
IL_000F:  ceq         

I found something like this in System.String:

public static bool Equals(String a, String b) {
    // Here
    if ((Object)a==(Object)b) {
        return true;
    }
    // ****

    if ((Object)a==null || (Object)b==null) {
        return false;
    }

    if (a.Length != b.Length)
        return false;

    return EqualsHelper(a, b);
}

Answer 1

Your version "Two" does something different: it compares for reference equality (you can see this in the ceq in the IL you added in an edit). This will often work in basic tests, due to string interning - but it should not be relied upon. It is working by accident only.

Basically, just use:

return str_01 == str02;

This is the idiomatic way of expressing "compare these two strings for equality", and it will be inlined to a call to string.Equals(string a, string b) anyway.

Answer 2

The method Compare_01() and Compare_02() are not doing the same thing. The first one is comparing the string values while later comparing the references. Although both of them would return true as the JIT and Runtime will create a string a and assign the same address to both variables.

Each string literal does not necessarily result in a new string instance. When two or more string literals that are equivalent according to the string equality operator (Section 7.9.7) appear in the same assembly, these string literals refer to the same string instance. For instance, the output produced by MSDN

class Test 
{    static void Main() {
      object a = "hello";
      object b = "hello";
      System.Console.WriteLine(a == b);    
     } 
}

Why not simply return the expression result that is bool (true or false) if you want to compare the values.

public static bool CompareStr(String str1 , String str2)
{
      return str1 == str2;
}

Answer 3

Comparing references is faster, but strings can have the same value even if they are not the same instance. As the comparisons are doing different things, you can't use the reference comparison as an optimisation for string comparison.

If you compare two strings that have the same value but are not the same instance, you can see the difference:

string str_01 = "ab";
string str_02 = String.Concat("a", "b");

Console.WriteLine(str_01 == str_02);
Console.WriteLine((object)str_01 == (object)str_02);

Output:

True
False

The String.Equals method is using reference comparison to catch the case when you are comparing two strings that are actually the same instance. If the strings are separate instances, it goes on to compare the value of the strings.