क्या सी # में घोंसला पकड़ने की कोशिश करने के लिए यह बुरा अभ्यास है?

Question

क्या निम्न कोड खराब अभ्यास है?

try //Try Overall Operation 
     { 
      try //Try section 1 of operation 
       { 

       } 
      catch(exception ex) 
       { 
        //handle exception code 
        //throw the exception 
     } 
catch (exception ex) 
     { 
      // send soap exception back to SOAP client. 
     } 

मैं देखने के एक कार्यक्रम की समीक्षा बिंदु से पता है, अन्य डेवलपर्स देख 2 की कोशिश करता सीधे उस तरह नेस्ट क्यों आश्चर्य हो सकता है, लेकिन यह पूरी तरह से वर्जित है, या यह अब अभ्यास स्वीकार किया जाता है दिन?

धन्यवाद दोस्तों, मैं सब कुछ आपके साथ रिफैक्टरिंग के बारे में सहमत हूं, उप कार्यक्षमता के लिए एक अलग विधि बनाने जा रहा हूं, विधि वास्तव में लंबी हो रही थी। मैं आप सभी को बहुत प्रभावित हूं जिन्होंने इसे उठाया ...

Answer 1

नहीं। मुझे नहीं लगता कि यह बुरा अभ्यास है।

यदि आप पहली बार कुछ कर रहे हैं, तो नेस्टेड प्रयास जिसे आप पकड़ सकते हैं और सही तरीके से संभाल सकते हैं, यह बिल्कुल ठीक है, खासकर यदि आप दो हैंडलरों में विभिन्न प्रकार के अपवादों को "पकड़" रहे हैं।

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

Answer 2

मेरी राय में यह होना जरूरी नहीं है। कभी-कभी आप दूसरे कोड में विफल होने पर भी निष्पादित करने की पहली कोशिश के भीतर कुछ कोड चाहते हैं।

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

Answer 3

यह भयानक नहीं है, हालांकि यदि आप सिर्फ अपवाद प्रकार से निपटने के रूप में आवश्यक बजाय द्वारा इस का समाधान नहीं कर सकते हैं:

try 
{ 

} 
catch (SqlException ex) 
{ 
// Catches specific exception 
} 
catch (Exception ex) 
{ 
// Catch-all 
} 

हर आप एक कोशिश पकड़ आप बयानों का एक और धागा बना रहे है कि encabumbers readabilitiy। उदा .:

try 
{ 
    try 
    { 
    } 
    catch (Exception ex) 
    { 
    } 
} 
catch (Exception ex) 
{ 
} 

Answer 4

यह आपके कार्यक्रम को क्या करने की आवश्यकता है इस पर निर्भर करता है। संभवतः काम के सबसे छोटे दायरे के आस-पास अपने try/catch को लपेटना सबसे अच्छा है और अप्रत्याशित व्यवहार, साइड इफेक्ट्स या बग से बचने के लिए जितना संभव हो सके अपवाद हैंडलिंग को ध्यान में रखें। कई बार इसका मतलब try/catch ब्लॉक का अनुक्रम होगा, जो ठीक है।

Answer 5

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

try 
{ 
    // Do something 
    try 
    { 
     // Do something 
    } 
    catch(MyException e) 
    { 
     // handle 
     throw; // <--- This is important, it rethrows the same exception while maintaining the stack trace. This is *different* from "throw e" 
    } 
} 
catch(AnotherException e) 
{ 
    // handle 
} 

Answer 6

यह बुरा अभ्यास नहीं है, जब तक कि तर्क इसे वारंट करता है।

उदाहरण के लिए, यदि बाहरी-अधिकांश try एक SQL अपवाद को पकड़ने के लिए है, और आंतरिक-अधिकांश try आईओ अपवाद के लिए है, तो ऐसा करना उचित हो सकता है।

हालांकि, पकड़ने से बचने के लिए सावधान रहें- सभी प्रयास खंड जो कोड की बड़ी संख्या को कवर करते हैं। उन अच्छे अभ्यास नहीं हैं।

Answer 7

नहीं, यह आवश्यक रूप से खराब रूप नहीं है।

बस इन प्रकार के अधिकांश प्रश्नों की तरह (यानी क्या ग़लत बुराई है ?, क्या (बुराई) बुराई है?) इन चीजों की जगह है और अगर उनकी आवश्यकता होती है तो ठीक है।

Answer 8

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