दिलचस्प पोस्ट
वापसी कुंजी के साथ UITextView के लिए कीबोर्ड को कैसे खारिज करें? जावा विंडो में मेरी विंडो के बाहर माउस क्लिक निर्देशांक कैसे प्राप्त करें क्या पीडीओएसटीएटमेंट :: बिंदपाम () वैकल्पिक पास पैरामीटर नामों के लिए अग्रणी बृहदान्त्र है? UIScrollView autolayout बाधाओं का उपयोग नहीं करता है दस्तावेज़ के विकल्प क्या हैं? लिखिए? कैसे आईफोन 5 (वाइडस्क्रीन डिवाइस) का पता लगा सकता है? दिन, घंटे, मिनट और सेकंड में सेकंड कन्वर्ट करें पीएचपी फ़ंक्शंस में निर्मित फिर से परिभाषित करें मुझे कैसे पता चलेगा कि मेरी खिड़कियों मशीन पर जेडीके कहाँ स्थापित है? जावास्क्रिप्ट समारोह में वैश्विक चर परिभाषित करें एक DOM वातावरण में reflow कब होता है? स्काला में "संदर्भ बाध्य" क्या है? सुपरक्लास कंस्ट्रक्टर को फोन करने के लिए नियम क्या हैं? नियमित अभिव्यक्ति का उपयोग करते हुए एक बड़ी स्ट्रिंग के उपस्ट्रिंग को खोजने के लिए जावा का उपयोग करना मर्ज पर व्हाइसेस्पेस को कैसे निकालें

जावा या सी # में अपवाद प्रबंधन के लिए सर्वोत्तम अभ्यास

मैं अपने आवेदन में अपवादों को कैसे संभालना है, यह निर्णय लेने में फंस गया हूँ।

यदि अपवादों के साथ मेरी समस्याएं 1 से आती हैं तो 1) एक दूरस्थ सेवा के माध्यम से डेटा एक्सेस करना या 2) JSON ऑब्जेक्ट को डिसेराइज़ करना दुर्भाग्य से मैं इन कार्यों में से किसी एक के लिए सफलता की गारंटी नहीं दे सकता (नेटवर्क कनेक्शन काट, जेसनसन ऑब्जेक्ट जो मेरे नियंत्रण से बाहर है)

परिणामस्वरूप, अगर मुझे कोई अपवाद मिलता है तो मैं इसे फ़ंक्शन के भीतर पकड़कर कॉलर को गलत तरीके से लौटाता हूं। मेरा तर्क यह है कि सभी कॉलर वास्तव में इस बात की परवाह करता है कि कार्य सफल रहा है, ऐसा क्यों नहीं सफल रहा है

यहां कुछ विशिष्ट नमूने कोड (जावा में) की एक विशिष्ट विधि है)

public boolean doSomething(Object p_somthingToDoOn) { boolean result = false; try{ // if dirty object then clean doactualStuffOnObject(p_jsonObject); //assume success (no exception thrown) result = true; } catch(Exception Ex) { //don't care about exceptions Ex.printStackTrace(); } return result; } 

मुझे लगता है कि यह दृष्टिकोण ठीक है, लेकिन मैं जानना चाहता हूं कि अपवादों को प्रबंधित करने के लिए सर्वोत्तम अभ्यास क्या हैं (क्या मैं वास्तव में किसी अपवाद को बुलबुला करता हूं, कॉल स्टैक?)।

महत्वपूर्ण सवालों के सारांश में:

  1. क्या यह सिर्फ अपवादों को पकड़ने के लिए ठीक है, लेकिन उन्हें बबल नहीं करता है या सिस्टम को औपचारिक रूप से सूचित कर रहा है (या तो उपयोगकर्ता के लिए लॉग या एक अधिसूचना के माध्यम से)?
  2. अपवादों के लिए कौन-से सर्वोत्तम प्रथाएं हैं, जिनका परिणाम सब कुछ में एक प्रयास / पकड़ ब्लॉक की आवश्यकता नहीं है?

ऊपर का पालन करें / संपादित करें

सभी फीडबैक के लिए धन्यवाद, अपवाद प्रबंधन ऑनलाइन पर कुछ उत्कृष्ट स्रोत मिले:

  • अपवाद हैंडलिंग के लिए सर्वोत्तम अभ्यास | ओ रेली मीडिया
  • अपवाद एनटीईटी में सर्वश्रेष्ठ व्यवहारों को संभालना
  • उत्तम प्रथाएं: अपवाद प्रबंधन (अनुच्छेद अब archive.org प्रतिलिपि को इंगित करता है)
  • अपवाद-हैंडलिंग एंटीपार्टर्न

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

इसके अतिरिक्त कोड-रोट के लिए अत्यधिक प्रयास / कैच के माध्यम से देखें या अपवाद को अपना सम्मान न दें (एक अपवाद सिस्टम को चेतावनी दे रहा है, और क्या चेतावनी दी जानी चाहिए?)।

इसके अलावा, यह m3rLinEz से एक सुंदर पसंद टिप्पणी है

मैं एंडर्स हेजल्स्बर्ग से सहमत हूं और आप यह मानते हैं कि सबसे ज्यादा कॉल करने पर ही ध्यान दिया जाता है कि ऑपरेशन सफल है या नहीं।

इस टिप्पणी से अपवादों के निपटारे के बारे में सोचने के लिए कुछ प्रश्न सामने आए हैं:

  • फेंक दिया जाने वाला अपवाद क्या है?
  • यह कैसे संभाल करने के लिए इसे समझ में आता है?
  • क्या कॉलर वास्तव में अपवाद के बारे में परवाह करता है या क्या वे बस परवाह करते हैं कि कॉल सफल था?
  • एक कॉलर को एक संभावित अपवाद को सुशोभित करने के लिए मजबूर कर रहा है?
  • क्या आप भाषा के आदर्शों का सम्मान करते हैं?
    • क्या आपको वास्तव में बुलियन की तरह एक सफल झंडे लौटने की आवश्यकता है? रिटर्निंग बूलियन (या एक इं) एक जावा की तुलना में सी मानसिकता से अधिक है (जावा में आप केवल अपवाद को संभाल लेंगे) एक
    • भाषा के साथ जुड़े त्रुटि प्रबंधन निर्माण का पालन करें :)!

वेब के समाधान से एकत्रित समाधान "जावा या सी # में अपवाद प्रबंधन के लिए सर्वोत्तम अभ्यास"

यह मेरे लिए अजीब लगता है कि आप अपवादों को पकड़ना चाहते हैं और उन्हें त्रुटि कोड में बदलना चाहते हैं। आपको क्यों लगता है कि कॉलर अपवादों पर त्रुटि कोड पसंद करेंगे, जब बाद में जावा और सी # दोनों में डिफ़ॉल्ट है?

आपके प्रश्नों के लिए:

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

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

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

सामान्य तौर पर मैं निम्नलिखित नियमों का उपयोग करता हूं:

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

मैं निम्नलिखित कोड को एक गंध होने लगता है:

 try { //do something } catch(Exception) { throw; } 

इस तरह से कोड कोई बात नहीं है और इसमें शामिल नहीं होना चाहिए।

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

विफलता और अपवाद

पृष्ठ के निचले हिस्से में भी महान संसाधन हैं

मैं एंडर्स हेजल्स्बर्ग से सहमत हूं और आप यह मानते हैं कि सबसे ज्यादा कॉल करने पर ही ध्यान दिया जाता है कि ऑपरेशन सफल है या नहीं।

बिल वेनर्स : आपने अपवादों की जांच के संबंध में स्केलेबिलिटी और वर्जनिंग चिंताओं का उल्लेख किया है। क्या आप स्पष्ट कर सकते हैं कि उन दो मुद्दों से क्या मतलब है?

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

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

बिल वेनर्स : लेकिन क्या आप उस मामले में अपने कोड को तोड़कर नहीं कर रहे हैं, यहां तक ​​कि बिना किसी अपवाद के भाषा में? यदि नए संस्करण foo एक नए अपवाद को फेंकने जा रहा है जो क्लाइंट को हैंडलिंग के बारे में सोचना चाहिए, तो उनका कोड टूटा नहीं है, इस तथ्य से कि वे कोड लिखा करते समय अपवाद की उम्मीद नहीं करते थे?

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

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

संपादित करें: कनवर्स्टियन पर अधिक विवरण जोड़ा गया

चेक अपवाद आम तौर पर एक विवादास्पद समस्या है, और विशेष रूप से जावा में (बाद में मैं उनके पक्ष में उन लोगों के लिए कुछ उदाहरण ढूंढने की कोशिश करता हूं और उनका विरोध करता हूं)।

अंगूठे के नियमों के अनुसार, अपवाद निपटने इन दिशा-निर्देशों के आसपास कुछ खास क्रम में होना चाहिए:

  • रखरखाव की खातिर, हमेशा अपवादों को लॉग इन करें ताकि जब आप बग्स को देख सकें, तो लॉग आपको आपके बग की जगह शुरू होने पर इंगित करने में सहायता करेगा। कभी भी printStackTrace() या इसे पसंद नहीं छोड़े, संभावना है कि आपके उपयोगकर्ता में से एक को उन स्टैक ट्रेस के अंत में एक मिलेगा, और इसका शून्य ज्ञान है कि इसके साथ क्या करना है।
  • उन अपवादों को पकड़ो जिन्हें आप संभाल सकते हैं, और केवल उन्हीं को रख सकते हैं, और उन्हें संभाल सकते हैं , केवल उन्हें ढेर के ऊपर फेंक न दें
  • हमेशा एक विशिष्ट अपवाद वर्ग पकड़ो, और आमतौर पर आपको कभी भी Exception नहीं चाहिए, आप अन्यथा महत्वपूर्ण अपवादों को निगलने की संभावना रखते हैं।
  • कभी नहीं (कभी) पकड़ने की Error !! , जिसका मतलब है: कभी भी Throwable पकड़ नहीं सकते क्योंकि Error एस उत्तरार्द्ध के उपवर्ग हैं। Error एस समस्याएं हैं जो आप सबसे अधिक संभावना को संभालने में सक्षम नहीं होंगे (जैसे OutOfMemory , या अन्य जेवीएम मुद्दों)

आपके विशिष्ट मामले के बारे में, सुनिश्चित करें कि आपके विधि को कॉल करने वाला कोई भी ग्राहक उचित मूल्य प्राप्त करेगा। यदि कुछ विफल रहता है, तो बूलियन-लौटने की विधि झूठी लौटा सकती है, लेकिन यह सुनिश्चित कर लें कि जिन स्थानों पर आप कॉल करते हैं, वे उस तरीके को संभालने में सक्षम हैं।

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

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

पूर्व।

 try { sendMessage(); if(message == success) { doStuff(); } else if(message == failed) { throw; } } catch(Exception) { logAndRecover(); } 

यह कोड मुझे बारफ बनाता है आईएमओ आपको अपवादों से तब तक ठीक नहीं होना चाहिए जब तक कि इसकी एक महत्वपूर्ण प्रोग्राम न हो। यदि आपके फेंक अपवाद तब खराब चीजें हो रही हैं

उपर्युक्त सभी उचित लगता है, और अक्सर आपके कार्यस्थल में एक नीति हो सकती है हमारे स्थान पर हमने अपवाद के प्रकारों को परिभाषित किया है: SystemException (अनचेक) और ApplicationException (चेक)

हमने इस बात पर सहमति व्यक्त की है कि SystemException वसूली योग्य होने की संभावना नहीं है और शीर्ष पर एक बार संभाला जाएगा। आगे संदर्भ प्रदान करने के लिए, हमारे SystemException को यह बताए जाने के लिए SystemException जाता है कि वे कहाँ थे, जैसे RepositoryException SystemException , SystemException , आदि।

ApplicationException को व्यवसायिक अर्थ हो सकता है जैसे InsufficientFundsException और ग्राहक कोड द्वारा नियंत्रित किया जाना चाहिए।

एक ठोस उदाहरण Witohut, अपने कार्यान्वयन पर टिप्पणी करना मुश्किल है, लेकिन मैं वापसी कोड का उपयोग कभी नहीं होगा, वे एक रखरखाव मुद्दे रहे हैं आप अपवाद को निगल सकते हैं, लेकिन आपको निर्णय लेने की आवश्यकता क्यों है, और हमेशा इवेंट और स्टैकट्र्रेस लॉग करें अन्त में, जैसा कि आपके विधि के पास कोई अन्य संसाधन नहीं है, यह काफी बेमानी है (इनकैप्सुलेशन को छोड़कर?), तो doactualStuffOnObject(p_jsonObject); एक बूलीयन लौटा सकता है!

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

कभी-कभी ऐसा हो सकता है कि आप जिस अपवाद का सामना कर रहे हैं, वह कॉल करने वाले (यानी यह एक नेटवर्क अपवाद) को समझने में सक्षम नहीं होगा, इस मामले में आपको इसे डोमेन विशिष्ट अपवाद में लपेटना चाहिए।

अगर दूसरी ओर, अपवाद आपके प्रोग्राम में एक अपठनीय त्रुटि का संकेत देता है (यानी इस अपवाद का अंतिम परिणाम कार्यक्रम समाप्ति होगा) मैं व्यक्तिगत रूप से इसे पकड़े और एक रनटाइम अपवाद फेंकने के द्वारा स्पष्ट करना चाहता हूं।

यदि आप अपने उदाहरण में कोड पैटर्न का उपयोग करने जा रहे हैं, तो इसे TryDoSomething को कॉल करें, और केवल विशिष्ट अपवादों को पकड़ें।

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

उन मामलों में जहां TryXXXX समझ में आता है जब आप किसी तीसरी पार्टी के फ़ंक्शन को लपेटते हैं जो कि वास्तव में असाधारण नहीं हैं, या फ़ंक्शन को कॉल किए बिना परीक्षण करना सरल मुश्किल है। एक उदाहरण कुछ ऐसा होगा:

 // throws NumberNotHexidecimalException int ParseHexidecimal(string numberToParse); bool TryParseHexidecimal(string numberToParse, out int parsedInt) { try { parsedInt = ParseHexidecimal(numberToParse); return true; } catch(NumberNotHexidecimalException ex) { parsedInt = 0; return false; } catch(Exception ex) { // Implement the error policy for unexpected exceptions: // log a callstack, assert if a debugger is attached etc. LogRetailAssert(ex); // rethrow the exception // The downside is that a JIT debugger will have the next // line as the place that threw the exception, rather than // the original location further down the stack. throw; // A better practice is to use an exception filter here. // see the link to Exception Filter Inject above // http://code.msdn.microsoft.com/ExceptionFilterInjct } } 

चाहे आप tryXXX की तरह एक पैटर्न का उपयोग करें या एक शैली प्रश्न का अधिक है। सभी अपवादों को पकड़ने और उन्हें निगलने का प्रश्न एक शैली मुद्दा नहीं है। सुनिश्चित करें कि अप्रत्याशित अपवादों को प्रचारित करने की अनुमति है!

मैं सुझाव देता हूं कि आप जिस भाषा का उपयोग कर रहे हैं, उसके लिए मानक पुस्तकालय से आपकी संकेत लेना। मैं सी # के लिए बात नहीं कर सकता, लेकिन जावा को देखें

उदाहरण के लिए java.lang.reflect.Array में एक स्थिर set विधि है:

 static void set(Object array, int index, Object value); 

सी रास्ता होगा

 static int set(Object array, int index, Object value); 

… वापसी मूल्य के साथ एक सफलता सूचक है लेकिन आप सी दुनिया में अब और नहीं हैं

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

जैसा कि अन्य लोगों ने ध्यान दिया है – आप जिस तरह के अपवाद को पकड़ते हैं, उसमें आपको यथासंभव विशेष होना चाहिए।

यदि आप अपवाद को पकड़ने और गलत लौटने जा रहे हैं, तो यह एक बहुत विशिष्ट अपवाद होना चाहिए। आप ऐसा नहीं कर रहे हैं, आप उन सभी को पकड़ रहे हैं और झूठी लौट रहे हैं। अगर मुझे मायकाइन्सऑनफियर एक्सपैशन मिलता है तो मैं इसके बारे में तुरंत जानना चाहता हूं! बाकी अपवादों के बारे में मुझे परवाह नहीं हो सकती तो आपके पास अपवाद हैंडलर का एक ढेर होना चाहिए जो कुछ अपवादों (पुनर्स्थापना, या नया अपवाद पकड़ने और पुनः स्थापित करने के लिए जो कुछ बेहतर होता है, को पकड़ने और पुनः स्थापित करने के लिए) कहता है "यहां कुछ गलत है" और बस दूसरों के लिए झूठी वापसी करें

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

संपादित करें: एक कोशिश / पकड़ने में सब कुछ लपेटने के प्रश्न के रूप में, मुझे लगता है कि जवाब हाँ है अपवाद आपके कोड में इतने दुर्लभ होना चाहिए कि कैच ब्लॉक में कोड इतनी कम ही कार्यान्वित करता है कि यह प्रदर्शन बिल्कुल नहीं मारता है। एक अपवाद एक राज्य होना चाहिए जहां आपका राज्य मशीन तोड़ दिया और पता नहीं था कि क्या करना है। कम से कम एक अपवाद पुनर्स्थापित करें जो बताता है कि उस समय क्या हो रहा था और उसके अंदर कैद अपवाद था "विधि doSomeStuff () में अपवाद" किसी के लिए बहुत उपयोगी नहीं है, जिसकी पहचान करने की आवश्यकता है कि जब आप अवकाश पर हैं (या एक नई नौकरी में) तो क्यों टूट गया?

मेरी रणनीति:

अगर मूल समारोह शून्य से वापस आ गया तो मैं इसे बदलकर bool लौटाता हूं। अगर अपवाद / त्रुटि हुई, तो फर्जी झूठी बात है , अगर सबकुछ ठीक हो तो ठीक है

यदि फ़ंक्शन को कुछ वापस करना चाहिए तो अपवाद / त्रुटि उत्पन्न हुई रिटर्न नल , अन्यथा वापसीयोग्य आइटम।

Bool के बजाय त्रुटि का विवरण युक्त एक स्ट्रिंग लौटा जा सकता है

प्रत्येक मामले में लौटने से पहले त्रुटि लॉग इन करें

यहां कुछ उत्कृष्ट उत्तर दिए गए हैं। मैं जोड़ना चाहूंगा, अगर आप किसी पोस्ट के साथ समाप्त हो जाएंगे, तो कम से कम स्टैक ट्रेस से प्रिंट करें कहो कि आप उस समय क्या कर रहे थे, और एक्स। मेसेज (), डेवलपर को एक लड़ाई का मौका देने के लिए

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

फिर भी, यथोचित रूप से वे पठनीयता में अद्भुत काम करते थे, लेकिन आपको दो सामान्य नियमों का पालन करना चाहिए:

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

  • निम्न-स्तर पर नहीं पकड़े गए कोड में उत्पन्न होने वाली किसी भी या सभी अजीब स्थितियों का प्रबंधन करने के लिए उच्चतर स्तर पर एक बड़े हैंडलर का उपयोग करें त्रुटियों (लॉग, पुनरारंभ, रिकवरी आदि) के साथ उपयोगी कुछ करें

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

पॉल।

मुझे उत्तर के साथ थोड़ा देर हो सकती है लेकिन त्रुटि से निपटने कुछ है जो हम हमेशा बदल सकते हैं और समय के साथ विकसित हो सकते हैं। यदि आप इस विषय के बारे में कुछ और पढ़ना चाहते हैं तो मैंने इसके बारे में अपने नए ब्लॉग में एक पोस्ट लिखा था http://taoofdevelopment.wordpress.com

हैप्पी कोडिंग