क्यों कोशिश की जाती है {…} अंत में {…} अच्छा; {}} पकड़ने की कोशिश {} खराब है?

Question

मैंने देखा है कि लोग कहते हैं कि बिना किसी तर्क के कैच का उपयोग करना बुरा है, खासकर अगर वह कैच कुछ नहीं करता है:

StreamReader reader=new  StreamReader("myfile.txt");
try
{
  int i = 5 / 0;
}
catch   // No args, so it will catch any exception
{}
reader.Close();

हालाँकि, यह अच्छा रूप माना जाता है:

StreamReader reader=new  StreamReader("myfile.txt");
try
{
  int i = 5 / 0;
}
finally   // Will execute despite any exception
{
  reader.Close();
}

जहाँ तक मैं बता सकता हूँ, एक अंतिम ब्लॉक में सफाई कोड डालने और कोशिश के बाद सफाई कोड डालने के बीच का एकमात्र अंतर..कैच ब्लॉक है यदि आपके पास अपने प्रयास खंड (उस मामले में, अंत में सफाई कोड होगा) भागो, लेकिन कोशिश के बाद कोड (नहीं होगा)।

अन्यथा, आखिर ऐसा क्या खास है?

Comments

इससे पहले कि आप एक बाघ को पकड़ने की कोशिश करें जिसे आप संभाल नहीं सकते हैं, आपको अपनी अंत में इच्छाओं का दस्तावेजीकरण करना चाहिए।

प्रलेखन में अपवाद विषय कुछ अच्छी जानकारी दे सकता है। अंत में ब्लॉक उदाहरण पर एक नज़र डालें ।

— अथफौड

Answer 1

बड़ा अंतर यह है कि try...catchअपवाद को निगल जाएगा, इस तथ्य को छिपाते हुए कि एक त्रुटि हुई। try..finallyअपना क्लीनअप कोड चलाएगा और फिर अपवाद चलता रहेगा, किसी ऐसी चीज से निपटना, जो जानता है कि इसके साथ क्या करना है।

Comments

एनकैप्सुलेशन के साथ लिखे गए किसी भी कोड को केवल उस बिंदु पर अपवाद को संभालने में सक्षम होने की संभावना है जहां इसे उठाया गया है। बस इसे पास करने से हताश आशा में कॉल स्टैक वापस हो जाता है कि कुछ और कुछ अभिमानी अपवाद को संभालने में सक्षम होंगे आपदा के लिए एक नुस्खा है।

— डेविड अर्नो

ज्यादातर मामलों में, यह अधिक स्पष्ट है कि क्लास लिब्रियर स्तर की तुलना में आवेदन स्तर (जैसे, एक निश्चित कॉन्फ़िगरेशन सेटिंग) से एक विशेष अपवाद क्यों होगा।

— मार्क सिडेड

डेविड - मैं कार्यक्रम को तेजी से विफल करना पसंद करूंगा, ताकि मुझे समस्या के बारे में अवगत कराया जा सके, ताकि किसी अज्ञात स्थिति में चल रहे कार्यक्रम को छोड़ दें।

— एरिक फोर्ब्स

यदि आपका कार्यक्रम अपवाद के बाद किसी अज्ञात स्थिति में है तो आप कोड को गलत कर रहे हैं।

— ज़ैन लिंक्स

@DavidArno, किसी भी कोड को दिमाग में एनकैप्सुलेशन के साथ लिखा जाता है, केवल उनके दायरे में अपवाद को संभालना चाहिए। किसी और को संभालने के लिए किसी और चीज को पास करना चाहिए। अगर मेरे पास कोई एप्लिकेशन है जो उपयोगकर्ताओं से फ़ाइल नाम प्राप्त करता है, तो फ़ाइल पढ़ता है, और मेरे फ़ाइल रीडर को फ़ाइल खोलने के लिए अपवाद मिलता है, इसे उन्हें पास करना चाहिए (या अपवाद का उपभोग करें और नया फेंक दें) ताकि एप्लिकेशन कह सके , अरे - फाइल नहीं खुली, चलो एक अलग के लिए उपयोगकर्ता को संकेत दें। फ़ाइल रीडर उपयोगकर्ताओं को संकेत देने या प्रतिक्रिया में कोई अन्य कार्रवाई करने में सक्षम नहीं होना चाहिए। इसका एकमात्र उद्देश्य फाइलों को पढ़ना है।

— इहानी

Answer 2

"अंत में मैं एक बयान" कुछ आप हमेशा करना चाहिए सुनिश्चित करने के लिए कार्यक्रम राज्य है समझदार "। जैसे, यह हमेशा एक के लिए अच्छा रूप है, अगर कोई संभावना है कि अपवाद कार्यक्रम की स्थिति को बंद कर सकते हैं। कंपाइलर यह सुनिश्चित करने के लिए भी बड़ी लंबाई में जाता है कि आपका आखिर कोड चलाया जाए।

"कैच" का एक बयान है "मैं इस अपवाद से उबर सकता हूं"। आपको केवल उन अपवादों से उबरना चाहिए जिन्हें आप वास्तव में सही कर सकते हैं - बिना तर्क के पकड़ "अरे, मैं किसी भी चीज़ से उबर सकता हूँ!", जो लगभग हमेशा असत्य है।

यदि यह हर अपवाद से उबरना संभव था, तो यह वास्तव में एक अर्थपूर्ण वक्रोक्ति होगा, जिसके बारे में आप अपने इरादे को घोषित कर रहे हैं। हालांकि, यह नहीं है, और निश्चित रूप से कुछ अपवादों को संभालने के लिए आपके ऊपर लगभग निश्चित रूप से फ़्रेम बेहतर होगा। जैसे, अंत में उपयोग करें, अपने सफाई कोड को मुफ्त में प्राप्त करें, लेकिन फिर भी अधिक जानकार हैंडलर इस मुद्दे से निपटने दें।

Comments

आपकी भावना व्यापक है, लेकिन दुर्भाग्य से एक और महत्वपूर्ण मामले को नजरअंदाज करता है: स्पष्ट रूप से एक ऐसी वस्तु को अमान्य करना, जिसके आक्रमणकारी अब पकड़ नहीं सकते। एक सामान्य पैटर्न एक लॉक प्राप्त करने के लिए कोड के लिए है, एक वस्तु में कुछ बदलाव करते हैं, और लॉक को रिलीज़ करते हैं। यदि कुछ परिवर्तन करने के बाद अपवाद होता है, लेकिन सभी परिवर्तनों के कारण, वस्तु को अमान्य स्थिति में छोड़ा जा सकता है। भले ही IMHO बेहतर विकल्प मौजूद होना चाहिए , मुझे कोई भी बेहतर दृष्टिकोण नहीं है, जो किसी भी अपवाद को पकड़ने के लिए होता है, जबकि वस्तु स्थिति अमान्य हो सकती है, राज्य को स्पष्ट रूप से अमान्य कर सकती है, और फिर से फेंक सकती है।

— सुपरकैट

Answer 3

क्योंकि जब वह एक एकल पंक्ति एक अपवाद फेंकता है, तो आप इसे नहीं जान पाएंगे।

कोड के पहले ब्लॉक के साथ, अपवाद बस अवशोषित हो जाएगा , प्रोग्राम तब भी निष्पादित करना जारी रखेगा, जब प्रोग्राम की स्थिति गलत हो सकती है।

दूसरे खंड के साथ, अपवाद जाएगा फेंक दिया और ऊपर बुलबुले लेकिनreader.Close() अभी भी चलाने के लिए गारंटी है।

यदि अपवाद की उम्मीद नहीं है, तो एक कोशिश मत करो..क्योंकि बस को ब्लॉक करें, बाद में डिबग करना मुश्किल होगा जब प्रोग्राम खराब स्थिति में चला गया और आपको पता नहीं क्यों।

Answer 4

अंत में निष्पादित किया जाता है चाहे कोई भी हो। इसलिए, यदि आपका ट्रायल ब्लॉक सफल रहा, तो यह निष्पादित होगा, यदि आपका ट्रायल ब्लॉक विफल हो जाता है, तो यह कैच ब्लॉक को निष्पादित करेगा, और फिर अंत में ब्लॉक करेगा।

इसके अलावा, निम्नलिखित निर्माण का उपयोग करने की कोशिश करना बेहतर है:

using (StreamReader reader=new  StreamReader("myfile.txt"))
{
}

जैसा कि उपयोग कथन स्वचालित रूप से एक कोशिश / अंत में लपेटा जाता है और धारा स्वचालित रूप से बंद हो जाएगी। (यदि आप वास्तव में अपवाद को पकड़ना चाहते हैं, तो आपको स्टेटमेंट का उपयोग करने की कोशिश करनी होगी / पकड़ना होगा)।

Comments

यह सही नहीं है। का उपयोग करते हुए कोड को कोशिश / पकड़ के साथ लपेटना नहीं है, यह कहना चाहिए कि आखिरकार कोशिश करें

— pr0nin

Answer 5

जबकि निम्नलिखित 2 कोड ब्लॉक बराबर हैं, वे समान नहीं हैं।

try
{
  int i = 1/0; 
}
catch
{
  reader.Close();
  throw;
}

try
{
  int i = 1/0;
}
finally
{
  reader.Close();
}

1. 'अंत में' इरादा-खुलासा कोड है। आप संकलक और अन्य प्रोग्रामर को घोषित करते हैं कि इस कोड को चलाने की आवश्यकता है, चाहे कोई भी हो।
2. यदि आपके पास कई कैच ब्लॉक हैं और आपके पास सफाई कोड है, तो आपको अंत में आवश्यकता है। अंत में, आप प्रत्येक कैच ब्लॉक में अपना सफाई कोड डुप्लिकेट कर रहे होंगे। (DRY सिद्धांत)

अंत में ब्लॉक विशेष हैं। सीएलआर पहचानता है और कोड को अंततः ब्लॉक ब्लॉक से अलग कोड के साथ मानता है, और सीएलआर इस बात की गारंटी देता है कि अंतिम ब्लॉक हमेशा निष्पादित होगा। यह संकलक से सिर्फ चीनी नहीं है।

Answer 6

मैं इस बात से सहमत हूं कि यहां सर्वसम्मति से क्या प्रतीत होता है - एक खाली 'कैच' खराब है क्योंकि यह कोशिश करता है कि जो भी अपवाद है वह कोशिश ब्लॉक में हो सकता है।

इसके अलावा, एक पठनीयता के दृष्टिकोण से, जब मुझे एक 'कोशिश' ब्लॉक दिखाई देता है, तो मुझे लगता है कि एक संगत 'कैच' स्टेटमेंट होगा। यदि आप केवल 'अंत में' ब्लॉक में संसाधनों का आवंटन सुनिश्चित करने के लिए एक 'कोशिश' का उपयोग कर रहे हैं, तो आप इसके बजाय 'उपयोग' कथन पर विचार कर सकते हैं :

using (StreamReader reader = new StreamReader('myfile.txt'))
{
    // do stuff here
} // reader.dispose() is called automatically

आप किसी भी ऑब्जेक्ट के साथ 'यूज़' स्टेटमेंट का उपयोग कर सकते हैं जो आईडीआईसोपेरिकल लागू करता है। ब्लॉक के अंत में ऑब्जेक्ट के डिस्पोजल () विधि को स्वचालित रूप से कहा जाता है।

Answer 7

उपयोग करें Try..Catch..Finally, यदि आपकी विधि जानता है कि स्थानीय रूप से अपवाद को कैसे संभालना है। अपवाद कोशिश में होता है, हाथ में पकड़ने और उसके बाद अंत में साफ किया जाता है।

मामले में यदि आपकी विधि अपवाद को संभालने का तरीका नहीं जानती है लेकिन उपयोग के बाद एक बार सफाई की आवश्यकता होती है Try..Finally

इसके द्वारा अपवाद को कॉलिंग विधियों में प्रचारित किया जाता है और यदि कॉलिंग विधियों में कोई उपयुक्त कैच स्टेटमेंट हैं तो। यदि वर्तमान विधि या कॉलिंग विधियों में से कोई अपवाद हैंडलर नहीं हैं तो एप्लिकेशन क्रैश हो जाता है।

इसके द्वारा Try..Finallyयह सुनिश्चित किया जाता है कि कॉलिंग विधियों के अपवाद को प्रचारित करने से पहले स्थानीय सफाई की जाती है।

Comments

इस उत्तर के रूप में बुनियादी के रूप में, यह बिल्कुल सबसे अच्छा है। कोशिश करने / पकड़ने / अंत में, भले ही बाद में दो में से एक को खाली छोड़ दिया जाए, अच्छा है। बहुत कम ही ऐसी परिस्थितियाँ होती हैं जहाँ एक कैच ब्लॉक मौजूद हो सकता है और खाली हो सकता है, लेकिन कम से कम यदि आप हमेशा कोशिश / कैच / आखिर लिखते हैं, तो आप खाली ब्लॉक देखेंगे क्योंकि आप कोड को मना कर रहे हैं। खाली अंत में ब्लॉक उसी तरह से सहायक है। यदि आपको बाद में सफाई की आवश्यकता है, या अपवाद के समय एक राज्य को डिबग करने की आवश्यकता है, तो यह अविश्वसनीय रूप से सहायक है।

— जेसी विलियम्स

Answer 8

कोशिश..जबकि ब्लॉक अभी भी उठाए गए अपवादों को फेंक देगा। सभी finallyयह सुनिश्चित करते हैं कि अपवाद को फेंकने से पहले सफाई कोड चलाया जाता है।

कोशिश करें..एक खाली कैच के साथ किसी भी अपवाद का पूरी तरह से उपभोग करें और इस तथ्य को छिपाएं कि यह हुआ। पाठक बंद हो जाएगा, लेकिन सही बात हुई तो कोई बता नहीं रहा है। अगर आपका इरादा फ़ाइल में i लिखने का था तो क्या होगा ? इस स्थिति में, आप इसे कोड के उस हिस्से पर नहीं बनाएंगे और myfile.txt खाली हो जाएगा। क्या डाउनस्ट्रीम के सभी तरीके इसे ठीक से हैंडल करते हैं? जब आप खाली फ़ाइल देखते हैं, तो क्या आप सही ढंग से अनुमान लगा पाएंगे कि यह खाली है क्योंकि एक अपवाद फेंक दिया गया था? अपवाद को फेंकने के लिए बेहतर है और यह बताएं कि आप कुछ गलत कर रहे हैं।

एक और कारण है..इस तरह किया गया प्रयास पूरी तरह से गलत है। ऐसा करने से आप क्या कह रहे हैं, "कोई बात नहीं, मैं इसे संभाल सकता हूं।" किस बारे में StackOverflowException, क्या आप उसके बाद सफाई कर सकते हैं? किस बारे में OutOfMemoryException? सामान्य तौर पर, आपको केवल उन अपवादों को संभालना चाहिए जिनकी आप अपेक्षा करते हैं और संभालना जानते हैं।

Answer 9

यदि आप नहीं जानते कि किस प्रकार के अपवाद को पकड़ना है या इसके साथ क्या करना है, तो कैच स्टेटमेंट होने का कोई मतलब नहीं है। आपको बस इसे एक उच्चतर कॉल करने वाले के लिए छोड़ देना चाहिए जो स्थिति के बारे में अधिक जानकारी प्राप्त कर सकता है कि उसे क्या करना है।

आपके पास एक अपवाद होने के मामले में अंत में एक बयान होना चाहिए, ताकि आप कॉल करने वाले को फेंक दिए जाने से पहले संसाधनों को साफ कर सकें।

Answer 10

एक पठनीयता के नजरिए से, यह भविष्य के कोड-रीडर्स को स्पष्ट रूप से बता रहा है "यह सामान यहां महत्वपूर्ण है, इसे कुछ भी होने की जरूरत नहीं है।" यह अच्छा है।

इसके अलावा, खाली कैच स्टेटमेंट में उनके लिए एक निश्चित "गंध" होता है। वे एक संकेत हो सकते हैं कि डेवलपर्स विभिन्न अपवादों के माध्यम से नहीं सोच रहे हैं जो हो सकते हैं और उन्हें कैसे संभालना है।

Answer 11

अंत में वैकल्पिक है - अगर सफाई के लिए कोई संसाधन नहीं हैं, तो "अंत में" ब्लॉक होने का कोई कारण नहीं है।

Answer 12

से लिया गया: यहां

अपवादों को उठाना और पकड़ना नियमित रूप से किसी विधि के सफल निष्पादन के भाग के रूप में नहीं होना चाहिए। कक्षा पुस्तकालयों को विकसित करते समय, क्लाइंट कोड को एक ऑपरेशन करने से पहले एक त्रुटि स्थिति के लिए परीक्षण करने का अवसर दिया जाना चाहिए, जिसके परिणामस्वरूप एक अपवाद को उठाया जा सकता है। उदाहरण के लिए, System.IO.FileStream एक CanRead प्रॉपर्टी प्रदान करता है जिसे रीड विधि को कॉल करने से पहले चेक किया जा सकता है, संभावित अपवाद को उठाए जाने से रोका जा सकता है, जैसा कि निम्नलिखित कोड स्निपेट में दर्शाया गया है:

स्ट्रीम के रूप में डिम स्ट्रैट = गेटस्ट्रीम () यदि (str.CanRead) तब 'स्ट्रीम को पढ़ने के लिए कोड एंड

किसी विशेष विधि को लागू करने से पहले किसी वस्तु की स्थिति की जांच करने का निर्णय जो अपवाद उठा सकता है, वस्तु की अपेक्षित स्थिति पर निर्भर करता है। यदि फ़ाइलस्ट्रीम ऑब्जेक्ट एक फ़ाइल पथ का उपयोग करके बनाया गया है जो मौजूद होना चाहिए और एक निर्माता जिसे रीड मोड में एक फ़ाइल वापस करनी चाहिए, तो CanRead प्रॉपर्टी की जांच करना आवश्यक नहीं है; FileStream को पढ़ने में असमर्थता विधि के किए गए कॉल के अपेक्षित व्यवहार का उल्लंघन होगा, और एक अपवाद को उठाया जाना चाहिए। इसके विपरीत, अगर एक विधि FileStream संदर्भ को लौटाने के रूप में प्रलेखित की जाती है, जो पढ़ने योग्य नहीं हो सकती है या नहीं, तो डेटा पढ़ने की कोशिश करने से पहले CanRead संपत्ति की जांच करना उचित है।

प्रदर्शन प्रभाव का वर्णन करने के लिए कि "अपवाद तक" रनिंग कोडिंग तकनीक का उपयोग करने का कारण बन सकता है, एक कलाकार का प्रदर्शन, जो एक InvalidCastException को फेंकता है यदि कलाकार विफल हो जाता है, तो ऑपरेटर से C # के रूप में तुलना की जाती है, जो किसी कलाकार के विफल होने पर नल देता है। दो तकनीकों का प्रदर्शन उस स्थिति के लिए समान है जहां कास्ट वैध है (टेस्ट 8.05 देखें), लेकिन उस मामले के लिए जहां कास्ट अमान्य है, और कास्ट का उपयोग अपवाद का कारण बनता है, एक कास्ट का उपयोग करने की तुलना में 600 गुना धीमा है ऑपरेटर के रूप में (टेस्ट 8.06 देखें)। अपवाद-फेंकने की तकनीक के उच्च-प्रदर्शन प्रभाव में अपवाद वस्तु को आवंटित करने, फेंकने, और पकड़ने की लागत और बाद के कचरा संग्रह की लागत शामिल है, जिसका अर्थ है कि अपवाद को फेंकने का तात्कालिक प्रभाव यह उच्च नहीं है। अधिक अपवाद के रूप में फेंक दिया जाता है,

Comments

स्कॉट - यदि आपने ऊपर जो पाठ उद्धृत किया है, वह expertsexchange.com के भुगतान के पीछे है, तो आपको शायद यहां पोस्ट नहीं करना चाहिए। मैं इस पर गलत हो सकता हूं लेकिन मैं शर्त लगा सकता हूं कि यह एक अच्छा विचार नहीं है।

— ओनोरियो कैटेनेशिया

Answer 13

केवल अपवाद को पुनर्व्यवस्थित करने के लिए कैच क्लॉज जोड़ना बुरा अभ्यास है।

Answer 14

यदि आप प्रोग्रामर के लिए C # पढ़ेंगे , तो आप समझ जाएंगे, कि अंततः ब्लॉक एक एप्लिकेशन को ऑप्टिमाइज़ करने और मेमोरी लीक को रोकने के लिए डिज़ाइन किया गया था।

सीएलआर पूरी तरह से लीक को खत्म नहीं करता है ... मेमोरी लीक हो सकती है यदि प्रोग्राम अनजाने में अवांछित वस्तुओं के संदर्भ में रखता है

उदाहरण के लिए जब आप एक फ़ाइल या डेटाबेस कनेक्शन खोलते हैं, तो आपकी मशीन उस लेनदेन को पूरा करने के लिए मेमोरी आवंटित करेगी, और उस मेमोरी को तब तक नहीं रखा जाएगा जब तक कि निपटारा या करीबी कमांड निष्पादित नहीं किया गया था। लेकिन यदि लेन-देन के दौरान कोई त्रुटि हुई थी, तो कार्यवाही कमांड को तब तक समाप्त नहीं किया जाएगा जब तक कि वह try.. finally..ब्लॉक के अंदर न हो ।

catchfinallyइस अर्थ से अलग था कि, कैच आपको स्वयं को त्रुटि को संभालने / प्रबंधित करने या व्याख्या करने का तरीका देने के लिए डिज़ाइन था। इसे ऐसे व्यक्ति के रूप में सोचें जो आपको बताता है "अरे मैंने कुछ बुरे लोगों को पकड़ा है, आप मुझे क्या करना चाहते हैं?" जबकि finallyयह सुनिश्चित करने के लिए डिज़ाइन किया गया था कि आपके संसाधन ठीक से रखे गए थे। यह किसी के बारे में सोचें कि क्या कुछ बुरे लोग हैं या नहीं, वह यह सुनिश्चित करेगा कि आपकी संपत्ति अभी भी सुरक्षित थी।

और आपको उन दोनों को अच्छे के लिए मिलकर काम करने देना चाहिए।

उदाहरण के लिए:

try
{
  StreamReader reader=new  StreamReader("myfile.txt");
  //do other stuff
}
catch(Exception ex){
 // Create log, or show notification
 generic.Createlog("Error", ex.message);
}
finally   // Will execute despite any exception
{
  reader.Close();
}

Answer 15

अंत में, आप संसाधनों को साफ कर सकते हैं, भले ही आपका कैच स्टेटमेंट अपवाद को कॉलिंग प्रोग्राम तक फेंकता हो। खाली कैच स्टेटमेंट वाले आपके उदाहरण के साथ, बहुत कम अंतर है। हालाँकि, यदि आपकी पकड़ में, आप कुछ प्रसंस्करण करते हैं और त्रुटि को फेंक देते हैं, या यहां तक ​​कि बस पकड़ भी नहीं है, तो अंत में अभी भी चलेगा।

Answer 16

अच्छी तरह से एक के लिए, यह आप को संभालने के लिए परेशान नहीं अपवादों को पकड़ने के लिए बुरा अभ्यास है। .Net अनुप्रयोग प्रदर्शन और स्केलेबिलिटी में सुधार से .Net प्रदर्शन के बारे में अध्याय 5 देखें । साइड नोट, आप शायद कोशिश ब्लॉक के अंदर धारा लोड कर रहे होंगे, इस तरह, आप असफल होने पर प्रासंगिक अपवाद को पकड़ सकते हैं। कोशिश ब्लॉक के बाहर धारा बनाना अपने उद्देश्य को पराजित करता है।

Answer 17

संभवतः कई कारणों के अलावा, अपवाद निष्पादित करने के लिए बहुत धीमा हैं। आप आसानी से अपने निष्पादन समय को पंगु बना सकते हैं यदि यह बहुत कुछ होता है।

Answer 18

सभी अपवादों को पकड़ने की कोशिश / पकड़ने वाले ब्लॉक के साथ समस्या यह है कि यदि कोई अज्ञात अपवाद होता है, तो आपका कार्यक्रम अब अनिश्चित स्थिति में है। यह पूरी तरह से विफल फास्ट नियम के खिलाफ जाता है - आप नहीं चाहते कि आपका कार्यक्रम जारी रहे अगर कोई अपवाद होता है। ऊपर की कोशिश / कैच आउटऑफमेमोरी एक्सेप्शन को भी पकड़ लेगा, लेकिन यह निश्चित रूप से एक स्थिति है कि आपका प्रोग्राम नहीं चलेगा।

कोशिश / अंत में ब्लॉक आपको कोड को निष्पादित करने की अनुमति देता है, जबकि अभी भी तेजी से विफल हो रहा है। अधिकांश परिस्थितियों के लिए, आप केवल वैश्विक स्तर पर सभी अपवादों को पकड़ना चाहते हैं, ताकि आप उन्हें लॉग इन कर सकें, और फिर बाहर निकल सकें।

Answer 19

आपके उदाहरणों के बीच प्रभावी अंतर तब तक नगण्य है जब तक कोई अपवाद नहीं फेंका जाता है।

यदि, हालांकि, एक अपवाद फेंक दिया जाता है, जबकि 'कोशिश' खंड में, पहला उदाहरण इसे पूरी तरह से निगल जाएगा। दूसरा उदाहरण कॉल स्टैक तक अगले चरण के अपवाद को बढ़ाएगा, इसलिए कहा गया उदाहरणों में अंतर यह है कि कोई पूरी तरह से किसी भी अपवाद (पहले उदाहरण) को अस्पष्ट करता है, और दूसरा (दूसरा उदाहरण) संभावित बाद के संचालन के लिए अपवाद जानकारी को संभालता है जबकि अभी भी 'अंत' खंड में सामग्री को निष्पादित कर रहा है।

यदि, उदाहरण के लिए, आपको पहले उदाहरण के 'कैच' क्लॉज में कोड डालना था जो एक अपवाद को फेंक देता था (या तो जो शुरुआत में उठाया गया था, या एक नया), पाठक क्लीनअप कोड कभी भी निष्पादित नहीं करेगा। अंत में 'कैच' क्लॉज में क्या होता है, इस पर ध्यान दिए बिना ।

तो, 'कैच' और 'अंत' के बीच मुख्य अंतर यह है कि 'अंत में' ब्लॉक (कुछ दुर्लभ अपवादों के साथ) की सामग्री को निष्पादित करने की गारंटी माना जा सकता है , यहां तक ​​कि अप्रत्याशित अपवाद के बावजूद, किसी भी कोड का पालन करते समय एक 'कैच' क्लॉज (लेकिन एक 'अंततः' क्लॉज के बाहर) ऐसी गारंटी नहीं देता।

संयोग से, स्ट्रीम और स्ट्रीमराइडर दोनों ही आईडीसोप्लिकेशन लागू करते हैं, और इसे 'ब्लॉक' का उपयोग करके लपेटा जा सकता है। 'ब्लॉक का उपयोग करना' कोशिश के अंत में / / (कोई 'कैच' नहीं) के शब्दार्थ समतुल्य हैं, इसलिए आपका उदाहरण अधिक स्पष्ट रूप से व्यक्त किया जा सकता है:

using (StreamReader reader = new  StreamReader("myfile.txt"))
{
  int i = 5 / 0;
}

... जो गुंजाइश से बाहर जाने पर स्ट्रीमराइडर उदाहरण को बंद और निपटान करेगा। उम्मीद है की यह मदद करेगा।

Answer 20

कोशिश करें {...} पकड़ {} हमेशा खराब नहीं होती है। यह एक सामान्य पैटर्न नहीं है, लेकिन मैं इसका उपयोग तब करता हूं जब मुझे संसाधनों को शटडाउन करने की आवश्यकता होती है, चाहे जो भी हो, जैसे (संभवतः) एक थ्रेड के अंत में खुले सॉकेट को बंद करना।