Jeter et le retour des valeurs dans .NET

Question

Considérez ce qui suit:

 TextReader reader = new StreamReader(file); 
     XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 
     return (T)xmlSerializer.Deserialize(reader); 

Et

 using (TextReader reader = new StreamReader(file)) 
     { 
      XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 
      return (T)xmlSerializer.Deserialize(reader); 
     } 

ce qui va réellement se produire dans ce dernier morceau de code? Est-ce que le Dispose() sera appelé?

Answer 1

La ressource de l'instruction using, reader sera éliminée lorsque la portée d'utilisation se termine. En cas vous êtes c'est lorsque le résultat de la désérialisation a été casté en T.

vous pourriez vous étendre êtes code à la (à peu près) équivalent ci-dessous:

TextReader reader = null; 
try{ 
    reader = new StreamReader(file); 
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 
    var obj = xmlSerializer.Deserialize(reader); 
    T returnVal = (T)obj; 
    return returnVal; 
} finally{ 
    reader.Dispose(); 
} 

dans cette version, il devient clair que le dernier lecteur utilisé est bien avant l'instruction de retour.

Si vous deviez retourner le lecteur, vous auriez des problèmes car l'objet renvoyé serait éliminé et donc inutilisable.

EDIT: L'IL du code ci-dessus est:

IL_0000: nop 
    IL_0001: ldnull 
    IL_0002: stloc.0 
    .try 
    { 
    IL_0003: nop 
    IL_0004: ldstr  "" 
    IL_0009: newobj  instance void [mscorlib]System.IO.StreamReader::.ctor(string) 
    IL_000e: stloc.0 
    IL_000f: ldtoken !!T 
    IL_0014: call  class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) 
    IL_0019: newobj  instance void [System.Xml]System.Xml.Serialization.XmlSerializer::.ctor(class [mscorlib]System.Type) 
    IL_001e: stloc.1 
    IL_001f: ldloc.1 
    IL_0020: ldloc.0 
    IL_0021: callvirt instance object [System.Xml]System.Xml.Serialization.XmlSerializer::Deserialize(class [mscorlib]System.IO.TextReader) 
    IL_0026: stloc.2 
    IL_0027: ldloc.2 
    IL_0028: unbox.any !!T 
    IL_002d: stloc.3 
    IL_002e: ldloc.3 
    IL_002f: stloc.s CS$1$0000 
    IL_0031: leave.s IL_003d 
    } // end .try 
    finally 
    { 
    IL_0033: nop 
    IL_0034: ldloc.0 
    IL_0035: callvirt instance void [mscorlib]System.IO.TextReader::Dispose() 
    IL_003a: nop 
    IL_003b: nop 
    IL_003c: endfinally 
    } // end handler 
    IL_003d: nop 
    IL_003e: ldloc.s CS$1$0000 
    IL_0040: ret 
} // end of method 

la chose à noter est que CS 1 $ 0000 qui est la valeur de retour est poussée à la pile juste avant la seule instruction RET. Donc l'ordre d'exécution est différent de ce à quoi il ressemble dans le code C#. En outre, il vaut la peine de noter les commandes stloc.s CS $ 1 $ 0000 et leave.s qui stockent la valeur de retour suivie par l'un des GOTO glorifiés. leave.s quitte l'essai et saute à l'étiquette IL_003d, juste avant de pousser la valeur de retour à la pile

Answer 2

Oui, le Dispose sera appelé.

Answer 3

Oui, voir ici: -

http://msdn.microsoft.com/en-us/library/yh598w02(VS.80).aspx

Answer 4

Oui, il sera appelé.

La déclaration using est le sucre syntaxique pour:

try 
{ 
    // Do stuff 
    return; 
} 
finally 
{ 
    // Dispose 
} 

et le finally sera appelé même sur le return.

Vous pouvez donc l'utiliser en toute sécurité.

Answer 5

Oui, c'est ainsi qu'il sera converti en IL.

TextReader reader; 
    T returnValue; 
    try{ 
     reader = new StreamReader(file)); 
     XmlSerializer xmlSerializer = new XmlSerializer(typeof(T)); 
     var obj = xmlSerializer.Deserialize(reader); 
     returnVal = (T)obj; 
    } 
    finally{   
     reader.Dispose(); 
     return returnVal;    
    }