Replacing Nested if Statement With AND

Question

I am wondering whether nested if is better than AND statement. I have a loop that goes so many times so I am thinking of faster execution available. Below is the code that has same logic with my code. The nested if statement is inside a loop.

   for ( int i = 0; i < array.length; i++)
   {
      // do stuff
      if (x == 5)
      {
         if (y == 3)
         {
             // do stuff
         }
      }
   }  

Will my code be faster by a significant difference if I replace the nested if with this And STATEMENT?

     if ((x == 5) && (y == 3))
           // do stuff

I have read this link but I didn't find the answer. I am a student and still learning, thanks for all the feedback!

Answer 1

.NET will stop checking if the first part of the conditional is false, so there will be no performance difference between the two.

Answer 2

No, there won't be any difference between the two. However, the AND makes fewer lines and is more readable (if you don't have that many conditions)

There are cases where ifs are better and feel more natural, one common example is the following:

String s=//...
if(s==null)return;
if(s.Length > 0) //do something

With an AND, this can be replaced by:

if ((s!=null) && (s.Length > 0)) //Dosomething

Many developers do this mistake:

if ((s.Length > 0) && (s!=null) ) //Dosomething

Which will end up in a null reference exception

As you can see, it is more natural to think of doing the null check first when using separate ifs

Answer 3

No, it will not have a significant difference on performance, but there may be a difference in readability.

Both of those will generate the same IL when compiled with optimization/release(Tested with LINQPad):

IL_0000:  ldc.i4.5    
IL_0001:  stloc.0     
IL_0002:  ldc.i4.s    0A 
IL_0004:  stloc.1     
IL_0005:  ldloc.0     
IL_0006:  ldc.i4.5    
IL_0007:  bne.un.s    IL_000D
IL_0009:  ldloc.1     
IL_000A:  ldc.i4.3    
IL_000B:  pop         

Even without optimization the difference is not that significant:

Nested statements:

IL_0001:  ldc.i4.5    
IL_0002:  stloc.0     
IL_0003:  ldc.i4.s    0A 
IL_0005:  stloc.1     
IL_0006:  ldloc.0     
IL_0007:  ldc.i4.5    
IL_0008:  ceq         
IL_000A:  ldc.i4.0    
IL_000B:  ceq         
IL_000D:  stloc.2     
IL_000E:  ldloc.2     
IL_000F:  brtrue.s    IL_0020
IL_0011:  nop         
IL_0012:  ldloc.1     
IL_0013:  ldc.i4.3    
IL_0014:  ceq         
IL_0016:  ldc.i4.0    
IL_0017:  ceq         
IL_0019:  stloc.2     
IL_001A:  ldloc.2     
IL_001B:  brtrue.s    IL_001F
IL_001D:  nop         
IL_001E:  nop 

Not Nested statements:

IL_0001:  ldc.i4.5    
IL_0002:  stloc.0     
IL_0003:  ldc.i4.s    0A 
IL_0005:  stloc.1     
IL_0006:  ldloc.0     
IL_0007:  ldc.i4.5    
IL_0008:  bne.un.s    IL_0013
IL_000A:  ldloc.1     
IL_000B:  ldc.i4.3    
IL_000C:  ceq         
IL_000E:  ldc.i4.0    
IL_000F:  ceq         
IL_0011:  br.s        IL_0014
IL_0013:  ldc.i4.1    
IL_0014:  nop         
IL_0015:  stloc.2     
IL_0016:  ldloc.2     
IL_0017:  brtrue.s    IL_001B
IL_0019:  nop 

Answer 4

In compiled code, there is no reason the speeds should be different, they will translate to exactly the same assembly code. I definitely agree about the readability factor, and it will shorten the length of your class as well.