C#, ottimizzazione strana

Question

Sto provando a leggere il mio codice C# compilato.

questo è il mio codice:

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

Ma!

Sappiamo tutti che un utilizzo si traduce in questo:

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

(dal OleDbCommand è un tipo di riferimento).

Ma quando ho decompilare il mio assemblaggio (compilato con .NET 2.0) ottengo questo 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:; 
    } 

Sto parlando di questa linea: if ((insertCommand == null) != null).

Diciamo insertCommand IS null. Quindi la prima parte restituisce true. (true != null) restituisce true. Allora, l'eliminazione è ancora saltata? Strano, molto strano.

Se incollo questo in Visual Studio, ReSharper mi avverte già: L'espressione è sempre vero ...

Grazie!

-Kristof

Answer 1

Il decompilatore ha un bug. Questa linea

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

avrebbe dovuto essere decompilato per

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

che, sebbene inutilmente dettagliato, è almeno codice corretto.

Il decompilatore probabilmente fa questa versione inutilmente prolissa, perché il compilatore C# spesso sceglie di emettere

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

come se avessi scritto

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

Dal momento che il codice generato per entrambi i programmi è la stessa , il decompilatore non sempre sa quale sia il codice più sensibile da visualizzare.

Il motivo dell'imprevisto "!= falso "è perché quando generiamo IL che verifica se qualcosa è vero, il codice più veloce e compatto che possiamo generare è quello di verificare se non è falso. False è rappresentato come zero in IL, e c'è un'istruzione a buon mercato per" è questa cosa zero? "

Answer 2

quando si decompilare codice, non sono garantiti per ottenere il codice originale di nuovo. Quando il codice .net è compilato in IL, è ottimizzato. A volte vedrai qualcosa di pazzo quando un'applicazione traduce l'IL in C#. Questo non significa che il codice non funzioni, è proprio come l'applicazione (in questo caso il resharper) ha tradotto l'IL.

Se siete preoccupati, guarderei direttamente all'IL per vedere in che cosa è stato compilato.

Nota a margine: l'IL decompilato in C# o VB.net non è garantito per la compilazione. :)

Un altro prodotto da provare è Reflector