desechables, usando & Try/Catch Blocks

Question

Tengo un bloqueo mental hoy, necesito una mano que verifique que mi lógica no está marcada con fubar.

Tradicionalmente Haría/S de archivos similar a esto:

FileStream fs = null; // So it's visible in the finally block 
try 
{ 
    fs = File.Open("Foo.txt", FileMode.Open); 

    /// Do Stuff 
} 
catch(IOException) 
{ 
    /// Handle Stuff 
} 
finally 
{ 
    if (fs != null) 
     fs.Close(); 
} 

Sin embargo, esto no es muy elegante.

Idealmente me gustaría usar el bloque using para eliminar el filestream cuando termine, sin embargo, no estoy seguro de la sinergia entre el uso y el try/catch.

Así es como me gustaría poner en práctica lo anterior:

try 
{ 
    using(FileStream fs = File.Open("Foo.txt", FileMode.Open)) 
    { 
     /// Do Stuff 
    } 
} 
catch(Exception) 
{ 
    /// Handle Stuff 
} 

Sin embargo, me preocupa que una salida prematura (a través excepción lanzada) desde dentro del bloque utilizando no puede permitir que el bloque usando a completar la ejecución y limpiar su objeto. ¿Estoy paranoico, o esto funcionará realmente de la manera en que lo intento?

Answer 1

Estás siendo paranoico y que funcionará el camino donde lo quiere :)

A usando afirmación es equivalente a un try/finally, ya sea dentro de un try/catch o no.

Así que su código es similar a:

try 
{ 
    FileStream fs = null; 
    try 
    { 
     fs = File.Open("Foo.txt", FileMode.Open); 
     // Do stuff 
    } 
    finally 
    { 
     if (fs != null) 
     { 
      fs.Dispose(); 
     } 
    } 
} 
catch(Exception) 
{ 
    /// Handle Stuff 
} 

Answer 2

No se preocupe, se va a limpiar como se esperaba y es más limpio que el original.

De hecho, es mucho más común tener una declaración Try/finally aka usando en su lógica empresarial, y una try/catch en un controlador de nivel superior en el nivel UI o en un límite de nivel físico. Algo así como:

try 
{ 
    DoStuffWithFile("foo.txt"); 
} 
catch(Exception ex) 
{ 
    ... 
} 

y

public void DoStuffWithFile(string fileName) 
{ 
    using(FileStream fs = File.Open(fileName,...)) 
    { 
     // Do Stuff 
    } 
} 

Answer 3

Esto funcionará - internamente la instrucción using compila la misma manera que un try-finally

Answer 4

try 
    { 
     FileStream fs = null; 
     try 
     { 
      fs = File.Open("Foo.txt", FileMode.Open); 

     } 
     finally 
     { 
      fs.Dispose(); 
     } 
    } 
    catch(Exception) 
    { 
     /// Handle Stuff 
    } 

segunda pieza de código se traduce en

Answer 5

El bloque de uso funcionará exactamente como lo entendiste. El bloque de uso es real Ly simplemente

try 
{ 
    FileStream fs = null; 
    try 
    { 
     fs = File.Open("Foo.txt", FileMode.Open)) 
     //Do Stuff 
    } 
    finally 
    { 
     if(fs != null) 
      fs.Dispose(); 
    } 
} 
catch(Exception) 
{ 
    /// Handle Stuff 
} 

Answer 6

que no es necesario el try..finally si tiene un using(). Ellos realizan la misma operación.

Si no está convencido, indique Reflector en su conjunto y compare el código generado.