Question

I’m trying to read my compiled C# code.

this is my code:

using(OleDbCommand insertCommand = new OleDbCommand("...", connection))
{
   // do super stuff
}

But!

We all know that a using gets translated to this:

{
    OleDbCommand insertCommand = new OleDbCommand("...", connection)
    try
    {
        //do super stuff
    }
    finally
    {
        if(insertCommand != null)
            ((IDisposable)insertCommand).Dispose();
    }
}

(since OleDbCommand is a reference type).

But when I decompile my assembly (compiled with .NET 2.0) I get this in Resharper:

try
{
    insertCommand = new OleDbCommand("", connection);
Label_0017:
    try
    {
       //do super stuff
    }
    finally
    {
    Label_0111:
        if ((insertCommand == null) != null)
        {
            goto Label_0122;
        }
        insertCommand.Dispose();
    Label_0122:;
    }

I’m talking about this line: if ((insertCommand == null) != null).

Let’s say insertCommand IS null. Then the first part returns true. (true != null) returns true. So Then the disposing is still skipped? Weird, very weird.

If I paste this in Visual Studio, Resharper already warns me: Expression is always true…

Thanks!

-Kristof

Answer 1

The decompiler has a bug. This line

if ((insertCommand == null) != null) 

should have been decompiled to

if ((insertCommand == null) != false)

which, though needlessly verbose, is at least correct code.

The decompiler probably does this unnecessarily verbose version because the C# compiler often chooses to emit

if (x)
   Y();
Z();

as if you’d written

if (!x)
    goto L;
Y();
L: Z();

Since the code generated for both programs is the same, the decompiler doesn’t always know which one is the more sensible code to display.

The reason for the unexpected “!= false” is because when we generate IL that tests whether something is true, the fastest and most compact code we can generate is to test whether it is not false. False is represented as zero in IL, and there’s a cheap instruction for “is this thing zero?”