कोशिश/पकड़ ब्लॉक में पूरा कोड

Question

मैं जानना चाहता हूं कि good practicetry block के अंदर रखने के लिए या मुझे only the code which I feel it will cause a specific exception रखना चाहिए?
और मैं बुनियादी अपवाद को पकड़ने चाहिए हमेशा

कोड 1: कोशिश ब्लॉक में पूरा कोड

myFunction(){ 
try{ 
    ......... 
    Code with chance of OneException 
    ............. 
}catch(OneException e){ 
    ............ 
}catch(Exception e){ 
    .............. 
} 
} 

कोड 2: केवल कोड कोशिश ब्लॉक में अपवाद की संभावना के साथ

myFunction(){ 
    ....... 
    try{ 
    Code with chance of OneException 
    }catch(OneException e){ 
    ............ 
    } 
    ............ 
} 

कोड 3: क्या मुझे अपवाद हमेशा

01 पकड़ना चाहिए

myFunction(){ 
     ....... 
     try{ 
     Code chance of OneException 
     }catch(OneException e){ 
     ............ 
     }catch(Exception e){ 
     .............. 
     } 
     ........ 
    } 

इनमें से (कोड 1, कोड 2 और कोड 3) कौन सा सबसे अच्छा है?
मैं मुख्य रूप से जावा और सी के साथ चिंता का विषय ++ कोडिंग

Answer 1

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

यह कहा गया है, मुझे लगता है कि जब आप "OneException का कोड मौका" लिखते हैं तो आप जानते हैं कि OneException को कैसे संभालना है, लेकिन अपवाद नहीं है, है ना? तो फिर ... केवल OneException को संभालें।

Answer 2

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

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

कोशिश में बिताए गए "समय" को सीमित करना ... पकड़ना पढ़ने में आसान बनाता है और आकस्मिक पकड़ने से कम प्रवण होता है। मैं आपको नहीं बता सकता कि कितने घंटे गुम हो गए हैं क्योंकि किसी ने अपवाद को पकड़ने का फैसला किया है जिसे प्रचारित किया जाना चाहिए था।

Answer 3

• ए) यह एक बुरा अभ्यास है, कोशिश ब्लॉक के अंदर पूरा कोड डालने के लिए।

  • ए 1) अपवादों को पकड़ने के अलावा, एक कोशिश-ब्लॉक एक दस्तावेज है जहां एक अपवाद हो सकता है। तो इसे कारण के करीब रखें, आपको दिमाग है।
  • a2) खराब परिस्थितियों में, आपके पास पढ़ने के लिए एक फ़ाइल है, और बाद में लिखने के लिए एक जोड़ें, लेकिन आपका अपवाद (FileNotFoundException) केवल पहले दिमाग में लिखा गया था। समस्याग्रस्त स्थानों के आस-पास एक दुबला गुंजाइश आपको और समस्याओं की पहचान करने में मदद करेगी।

• बी) पूर्णता के लिए मूल अपवाद नहीं पकड़ें या एकाधिक पकड़ ब्लॉक से बचें। अगर आप किसी फ़ाइल को लिखना चाहते हैं, तो कई चीजें गलत हो सकती हैं: गुम अनुमति, अवैध फ़ाइल नाम, डिवाइस पर कोई स्थान नहीं छोड़ा गया ...। यदि आप उपयोगकर्ता को एक सामान्य संदेश प्रस्तुत करते हैं ("फ़ाइल नहीं लिख सका" + नाम), वह नहीं जानता कि क्या करना है। यथासंभव सटीक बनें, और आप उसे सूचित कर सकते हैं, "डिवाइस पर केवल 20 एमबी छोड़ा गया" + devicename + "हमें एक और 8 एमबी (कुल मिलाकर 28 एमबी) की आवश्यकता है; कृपया कुछ जगह खाली करें और दोहराएं या एक अलग डिवाइस चुनें!") । यदि आप "अपवाद" पकड़ते हैं, तो संभावना अधिक होती है, कि आप कुछ अपवाद के बारे में सोच रहे हैं, लेकिन कोई दूसरा होता है, और सही तरीके से संभाला नहीं जाता है, क्योंकि कैच-ब्लॉक उस संभावना के साथ दिमाग में नहीं लिखा गया था। इस अपवाद को खोजने का सबसे अच्छा मौका यह है कि लॉग को चालू करने के लिए, या लॉग इन करने के लिए, यदि लॉग नियमित रूप से नियंत्रित होते हैं।

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

try { 
... 
} 
catch {FileNotFoundException fnfe} 
{ 
    throw new MyApiException (fnfe); 
} 
catch {PermissionDeniedException pde} 
{ 
    throw new MyApiException (pde); 
} 
catch {IOException ioe} 
{ 
    throw new MyApiException (ioe); 
} 

इस तरह , आपका ग्राहक तय कर सकता है कि अपवाद को कैसे संभाला जाए, और आपके अपवाद के अंदर, यदि विशिष्ट रुचि का अपवाद मिलेगा।

Landei बताते हैं, जावा 7 में वहाँ एक सरल तकनीक कई अपवाद को पकड़ने के लिए किया जाएगा, है, लेकिन केवल एक आम सुपर क्लास के साथ इस तरह नहीं है, जहां आप वास्तव में संभाल कर सकते हैं बिंदु पर this link here

Answer 4

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

मैं जावा के लिए पता नहीं है, लेकिन C++ आप स्थिरांक संदर्भ द्वारा पकड़ने चाहिए:

try 
{ 
    // code that can throw an exception 
} 
catch (const SomeExceptionType & error) 
{ 
    // handle the error 
} 

Answer 5

सी ++ जावा या सी # या नहीं है ... जहाँ आप करने के लिए catch (या finally) खंड की जरूरत है अपने आप के बाद साफ करो। सी ++ में, RAII ऐसा करता है। नतीजतन, मैं कभी भी कभी भी try/catch सी ++ में कथन लिखता हूं, जहां मैं इसे कोड गंध मानता हूं।

तो, बल्कि विचार कर कोड की जो शैली आप try/catch साथ संयोजन के रूप में इस्तेमाल करना चाहिए की तुलना में, आप अपने आप से पूछना चाहिए कि क्या आप उस try/catch बिल्कुल की जरूरत है।