if (string) vs if (bool) in C#

Question

Is there a noticeable difference in performance/code quality if you use a string to compare at the start of an "if" instead of a boolean?

Example with string:

string isTrue = "true";
if (isTrue == "true"){
  // do something
}

Example with bool:

bool isTrue = true;
if (isTrue){
   //do something
}

I generally use a bool for these kind of comparisons but I've seen both variations online.

Answer 1

Based on code generated on tryroslyn

Code:

using System;
public class C {
    public void M() {
        string isStringTrue = "true";
        if (isStringTrue == "true")
        {
            // do something
        }              

        bool isBoolTrue = true;
        if (isBoolTrue)
        {
            //do something
        }
    }
}

Produce IL code:

.class private auto ansi '<Module>'
{
} // end of class <Module>

.class public auto ansi beforefieldinit C
    extends [mscorlib]System.Object
{
    // Methods
    .method public hidebysig 
        instance void M () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 34 (0x22)
        .maxstack 2
        .locals init (
            [0] string,
            [1] bool,
            [2] bool,
            [3] bool
        )

        IL_0000: nop
        IL_0001: ldstr "true"
        IL_0006: stloc.0
        IL_0007: ldloc.0
        IL_0008: ldstr "true"
        IL_000d: call bool [mscorlib]System.String::op_Equality(string, string)
        IL_0012: stloc.2
        IL_0013: ldloc.2
        IL_0014: brfalse.s IL_0018
        IL_0016: nop
        IL_0017: nop
        IL_0018: ldc.i4.1
        IL_0019: stloc.1
        IL_001a: ldloc.1
        IL_001b: stloc.3
        IL_001c: ldloc.3
        IL_001d: brfalse.s IL_0021
        IL_001f: nop
        IL_0020: nop
        IL_0021: ret
    } // end of method C::M

    .method public hidebysig specialname rtspecialname 
        instance void .ctor () cil managed 
    {
        // Method begins at RVA 0x207e
        // Code size 8 (0x8)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [mscorlib]System.Object::.ctor()
        IL_0006: nop
        IL_0007: ret
    } // end of method C::.ctor

} // end of class C

As you can see compare strings needs call method, compare bools don't need this.

Answer 2

Performance wise it is faster to compare two bools (Is the bit set or not?) vs. comparing two strings.

Code quality wise alternative #2 is to prefer. There isn't really any reason to use string comparison in this case when you have booleans available. It will obfuscate and make your code harder to understand and maintain.

Answer 3

I decided to give it a try and created the following code:

Stopwatch watch = new Stopwatch();
string str1 = "MyTest";
string str2 = str1.Substring(0,2)+"Test";
watch.Start();
if(str1 == str2)
{
    Console.WriteLine("str1 == str2");
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Restart();
var obj1 = (object)str1;
var obj2 = (object)str2;
if(obj1 == obj2)
{
    Console.WriteLine("obj1 == obj2");
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
string str3 = "MyTest";
string str4 = "MyTest";
watch.Restart();
if (str3 == str4)
{
     Console.WriteLine("str3 == str4");
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
watch.Restart();
watch.Restart();
var obj3 = (object)str3;
var obj4 = (object)str4;
if (obj3 == obj4)
{
    Console.WriteLine("obj3 == obj4");
}
watch.Stop();
Console.WriteLine(watch.Elapsed);
if (true)
{
     Console.WriteLine("true");
}
watch.Stop();
Console.WriteLine(watch.Elapsed);

it yielded the following result:

//str1 == str2  
//00:00:00.0564061 
//00:00:00.0000116 
//str3 == str4
//00:00:00.0103047 
//obj3 == obj4
//00:00:00.0000004 
//true 
//00:00:00.0000004

my two cents on the matter - by default, strings, if they are "hardcoded" are interned by the system, so str3 and str4 reference the same string. However, comparing two strings is always by value, so it actually has to run across the entire string. However, if the strings are interned (hold the same reference) and you convert them to an object it forces a by ref comperison - and that forces it to become a non costly operation, and actually have the same performence as checking a boolean.

** there should be an overhead of converting to object, but according to my tests, it seems unnoticable.

As for your question

obviously, checking a string is far more costly than checking a boolean, and is determined by the length of the strings, and how similar they are. So, using a string is not a good choice.

However

If you do use strings for checking equality - you should probably make sure they hold the same reference (str = str2 is an example) and check equality by ref.

(all of this is not really noticable, but still)

Answer 4

In your case, the bool comparison will maintain better code quality then string comparison.