डिस्पोजेबल, ब्लॉकों का उपयोग करके/कोशिश करें/पकड़ें

Question

आज एक मानसिक ब्लॉक होने के बाद, मेरे तर्क को सत्यापित करने के लिए एक हाथ की आवश्यकता है, जिसे फ्यूबर नहीं किया गया है।

परंपरागत रूप से मैं फ़ाइल करना होगा मैं/हे इस के समान:

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

बहरहाल, यह बहुत ही सुंदर नहीं है।

आदर्श रूप से मैं using ब्लॉक का उपयोग करने के लिए फ़ाइलस्ट्रीम का निपटान करने के लिए ब्लॉक करना चाहता हूं, हालांकि मैं उपयोग और कोशिश/पकड़ के बीच तालमेल के बारे में अनिश्चित हूं।

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

हालांकि, मुझे चिंता है कि ब्लॉक का उपयोग के भीतर से समय से पहले बाहर निकलने के (फेंका अपवाद के माध्यम से) के लिए ब्लॉक का उपयोग की अनुमति न दे रहा हूँ:

यह मैं कैसे ऊपर लागू करना चाहते हैं है पूर्ण निष्पादन और इसकी वस्तु को साफ करें। क्या मैं सिर्फ पागल हूं, या क्या यह वास्तव में जिस तरह से मेरा इरादा रखता है वह काम करेगा?

Answer 1

तुम सिर्फ पागल जा रहा है कर रहे हैं और जिस तरह से आप यह चाहते हैं

एक बयान का उपयोग कर :) के लिए काम करेंगे, एक कोशिश/के बराबर अंत में ब्लॉक है कि क्या यह एक ट्राई/कैच या नहीं अंदर क्या है।

तो अपने कोड समान है:

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

चिंता है, यह साफ हो जाएगा मत करो अपेक्षा के अनुरूप नहीं है और अपने मूल की तुलना में क्लीनर है।

वास्तव में आपके व्यापार तर्क में कथन का उपयोग करके/आखिरकार उर्फ ​​का प्रयास करना और यूआई टियर में या भौतिक स्तर सीमा पर शीर्ष-स्तरीय हैंडलर में प्रयास/पकड़ना बहुत आम है। कुछ की तरह:

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

और

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

Answer 3

यह काम करेगा - आंतरिक कथन का उपयोग के रूप में एक ही तरह से संकलित एक कोशिश अंत में ब्लॉक

Answer 4

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

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

कोड के दूसरे टुकड़े में अनुवाद किया जाता है यह

Answer 5

उपयोग ब्लॉक का उपयोग ठीक उसी तरह काम करेगा जब आप अनुवाद ब्लॉक का अनुवाद करते हैं ly सिर्फ

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

आप try..finally की जरूरत नहीं है, तो आप एक using() की क्या ज़रूरत है। वे एक ही ऑपरेशन करते हैं।

यदि आप आश्वस्त नहीं हैं, तो अपनी असेंबली पर Reflector पर इंगित करें और जेनरेट कोड की तुलना करें।