Disposables, Verwenden und Versuchen/Catch Blocks

Question

Eine geistige Blockade heute, brauchen eine Hand, die meine Logik nicht mutiert.

Traditionell würde ich Datei tun i/o ähnlich wie diese:

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(); 
} 

Dies ist jedoch nicht sehr elegant ist.

Idealerweise würde ich gerne den using Block verwenden, um den Filestream zu entfernen, wenn ich fertig bin, aber ich bin unsicher über die Synergie zwischen der Verwendung und versuchen/fangen.

Dies ist, wie ich die oben implementieren möchte:

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

Aber ich mache mich Sorgen, dass ein vorzeitiger Ausgang (via Ausnahme ausgelöst) aus dem mit Block unter Verwendung des Block nicht zulassen kann vervollständige die Ausführung und räume das Objekt auf. Bin ich nur paranoid, oder wird das tatsächlich so funktionieren, wie ich es vorhabe?

Answer 1

Sie sind nur paranoid und ist es so, wie Sie es

eine using-Anweisung an :) beabsichtigen funktionieren entspricht einem try/finally-Block, ob es in einem try/catch ist oder nicht.

So Ihr Code ist ähnlich:

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

Keine Sorge, säubert es wie erwartet und ist sauberer als Ihr Original.

In der Tat ist es viel häufiger eine try/finally aka using-Anweisung in Ihrer Geschäftslogik und eine try/catch in einem Top-Level-Handler in der UI-Schicht oder an einer physischen Tiergrenze. Etwas wie:

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

und

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

Answer 3

Dies funktioniert - intern die Anweisung using kompiliert die gleiche Art und Weise wie ein Try-finally-Block

Answer 4

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

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

zweites Stück Code in übersetzt wird Dies

Answer 5

Der using-Block wird genau so funktionieren, wie Sie den übersetzten Block implementieren, ist real ly

nur

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

Sie brauchen nicht die try..finally, wenn Sie einen using() haben. Sie führen die gleiche Operation durch.

Wenn Sie nicht überzeugt sind, zeigen Sie Reflector auf Ihre Assembly und vergleichen Sie den generierten Code.