Why Does The Compiler Add An Unnecessary Local Variable

Question

This C# code: ``` private void LoadAssignments(AssignmentType assignmentType, Collection assignments) { bool flag; DataTable lessons = this.GetResults(assignmentType); try { IEnumerator enumerator = lessons.Rows.GetEnumerator(); try { while (true) { flag = enumerator.MoveNext(); if (!flag) { break; } DataRow row = (DataRow)enumerator.Current; } } finally { IDisposable disposable = enumerator as IDisposable; flag = disposable == null; if (!flag) { disposable.Dispose(); } } } finally { flag = lessons == null; if (!flag) { lessons.Dispose(); } } } ``` produces this CIL (.NET 4) ``` .method private hidebysig instance void LoadAssignments ( valuetype TTReporterCore.AssignmentType assignmentType, class [mscorlib]System.Collections.ObjectModel.Collection`1 assignments ) cil managed { .locals init ( [0] bool flag, [1] class [System.Data]System.Data.DataTable lessons, [2] class [mscorlib]System.Collections.IEnumerator enumerator, [3] class [Syst…

Accepted Answer

It seems like a temporary local is created to hold the results of the comparison (i.e. disposable == null).

Trying this example:

```
class Program
{
   static void Main()
   {
       if (1 == 1) return;
   }
}
```

..is producing the following IL on my box (Microsoft (R) Visual C# 2010 Compiler version 4.0.30319.1):

```
.method private hidebysig static void  Main() cil managed
{
  .entrypoint
  .maxstack  1
  .locals init (bool V_0)
  IL_0000:  nop
  IL_0001:  ldc.i4.0
  IL_0002:  stloc.0
  IL_0003:  br.s       IL_0005
  IL_0005:  ret
}
```

local V_0 is created, even though it's actually not used. I believe it's an obvious optimisation even for 'non' optimized compilation :) ..or more likely: all necessary code is generated to enable debugging. I don't know how it might be used in a debugging session, but it's my best guess.

When compiled optimized (i.e. Release configuration) I don't see the extra local.

Why Does The Compiler Add An Unnecessary Local Variable

Solution

Problem