दिलचस्प पोस्ट
जानकारी के लिए एक वेबसाइट (या पेज) को कैसे स्कैन करें, और इसे मेरे कार्यक्रम में लाएं? LINQ का उपयोग करके सूची में डुप्लिकेट निकालें एस्केप कमांड लाइन तर्क सी # में लेन () और .__ len __ () के बीच का अंतर? @ सत्रसैक्ड बीन दायरे को खो देता है और हर समय पुन: निर्मित हो जाता है, फ़ील्ड शून्य हो जाते हैं html एक समूह में केवल एक चेकबॉक्स का चयन करें जावा में दूसरे धागे से स्विंगिंग GUI (स्विंग) उपयोगकर्ता द्वारा चयनित पाठ से HTML लौटें स्प्रिंग कैसे काम करता है? TextureView पर वीडियो बजाना जावा सबलेट पर एचटीएमएल 5 फाइल अपलोड करें कौन प्राथमिकता, maxRequestLength या maxAllowedContentLength? एंड्रॉइड एडीबी नहीं मिला सेलेनियम में जावास्क्रिप्ट चल रहा है पायथन का उपयोग कर Android पर किसी आशय के माध्यम से किसी भी प्रकार की फ़ाइल को चुनें

अपवाद या त्रुटि कोड

कल, मुझे एक सहकर्मी के साथ एक गर्म बहस हो रही थी, जो प्राथमिक त्रुटि रिपोर्टिंग विधि होगी। मुख्य रूप से हम ऐप्लिकेशन परतों या मॉड्यूल के बीच त्रुटियों की रिपोर्ट करने के लिए अपवाद या त्रुटि कोड के उपयोग की चर्चा कर रहे थे।

क्या आप तय करने के लिए नियमों का उपयोग करते हैं कि आप त्रुटि रिपोर्टिंग के लिए अपवाद फेंक या त्रुटि कोड को वापस लाते हैं?

वेब के समाधान से एकत्रित समाधान "अपवाद या त्रुटि कोड"

उच्चस्तरीय सामानों में अपवाद; कम-स्तरीय सामग्री में, त्रुटि कोड

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

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

रेमंड चेन और जोएल दोनों ने सब कुछ के लिए अपवादों का उपयोग करने के खिलाफ कुछ सुवक्ता तर्क दिए हैं

मैं आम तौर पर अपवादों को पसंद करता है, क्योंकि उनके पास अधिक प्रासंगिक जानकारी है और स्पष्ट रूप से प्रोग्रामर को त्रुटि (जब ठीक से इस्तेमाल किया जा सकता है) व्यक्त कर सकते हैं

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

संक्षेप में मैं लगभग सभी स्थितियों में त्रुटि कोड पर अपवाद पसंद करता हूं I

मुझे अपवाद पसंद है क्योंकि

  • वे तर्क के प्रवाह को दोहराते हैं
  • वे वर्ग पदानुक्रम से लाभ उठाते हैं जो अधिक सुविधाएं / कार्यक्षमता प्रदान करता है
  • जब ठीक से उपयोग की जाने वाली त्रुटियों की एक विस्तृत श्रृंखला का प्रतिनिधित्व किया जा सकता है (उदाहरण के लिए एक अमान्य MethodCallException भी एक तर्क एक्सेप्शन है, क्योंकि दोनों होते हैं, जब आपके कोड में एक बग है जो रनटाइम के पहले detectable होना चाहिए), और
  • वे त्रुटि को बढ़ाने के लिए इस्तेमाल किया जा सकता है (यानी एक FileReadException क्लास परिभाषा में फाइल को मौजूद है या नहीं, या लॉक आदि की जांच करने के लिए कोड शामिल हो सकता है)

अपने कार्यों के कॉल करने वालों द्वारा त्रुटि कोड को अनदेखा किया जा सकता है (और अक्सर!)। अपवाद किसी भी तरह से त्रुटि से निपटने के लिए उन्हें कम से कम बल देता है। यहां तक ​​कि अगर इसके साथ निपटने के उनके संस्करण के लिए एक खाली पकड़ हैंडलर (उच्छ्वास) है

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

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

  • ऑब्जेक्ट ओरिएंटेड अपवाद हैंडलिंग इन पर्ल में
  • अपवाद बनाम स्थिति रिटर्न

उन लोगों में कुछ अच्छे संबंध हैं जो आपको आगे पढ़ सकते हैं।

मैं दो मॉडलों को कभी नहीं मिलाता … एक से दूसरे में परिवर्तित करना बहुत कठिन होता है क्योंकि आप स्टैक के एक भाग से आगे बढ़ते हैं जो त्रुटि कोड का उपयोग कर रहे हैं, जो अपवादों का उपयोग कर रहा है।

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

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

 Employee EmpOfMonth = GetEmployeeOfTheMonth(); 

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

 Employee EmpOfMonth; if (getEmployeeOfTheMonth(ref EmpOfMonth) == ERROR) // code to Handle the error here 

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

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

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

दूसरा कारण है कि मैं अपवादों को कैसे पसंद करता हूं और सामान्य निष्पादन के उनके टूटने का कारण यह है कि 'कुछ गलत तर्क' से 'सामान्य चीजें हो रही है' तर्क को अलग रखने के लिए इसे बहुत आसान बना देता है। मुझे य:

 try { // Normal things are happening logic catch (// A problem) { // Something went wrong logic } 

… यह करने के लिए बेहतर है:

 // Some normal stuff logic if (errorCode means error) { // Some stuff went wrong logic } // Some normal stuff logic if (errorCode means error) { // Some stuff went wrong logic } // Some normal stuff logic if (errorCode means error) { // Some stuff went wrong logic } 

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

अतीत में मैंने त्रुटि कोड शिविर में शामिल किया (बहुत सी प्रोग्रामिंग)। लेकिन अब मैंने प्रकाश को देखा है।

हां अपवाद सिस्टम पर बोझ का एक सा है। लेकिन वे कोड को सरल करते हैं, जिससे त्रुटियों की संख्या कम हो जाती है (और डब्ल्यूटीएफ)।

तो अपवाद का उपयोग करें लेकिन उन्हें बुद्धिमान का उपयोग करें और वे आपके मित्र होंगे।

अलग नोट के रूप में। मैंने जो दस्तावेज़ लिखना सीख लिया है वह अपवाद किस पद्धति द्वारा फेंका जा सकता है। दुर्भाग्य से यह अधिकांश भाषाओं द्वारा आवश्यक नहीं है लेकिन यह सही स्तर पर सही अपवादों को संभालने का मौका बढ़ता है।

विधि हस्ताक्षरों को आपसे संवाद करना चाहिए कि विधि क्या करती है। लंबे त्रुटि की तरह कुछ कोड = getErrorCode (); ठीक हो सकता है, लेकिन लंबी त्रुटि CODE = fetchRecord (); ये भ्रमित करता है।

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

अन्य सभी मामलों में, अपवाद शायद संभवतः जाने का तरीका है

मेरा दृष्टिकोण यह है कि हम एक ही समय में दोनों अपवादों और त्रुटियों के कोड का उपयोग कर सकते हैं।

मुझे कई प्रकार की अपवादों (उदाहरण के लिए: डेटावैलिडेटेशन अपवाद या प्रक्रिया इन्टरप्शन एक्सेपियन) परिभाषित करने के लिए उपयोग किया जाता है और प्रत्येक अपवाद के अंदर प्रत्येक समस्या का अधिक विस्तृत वर्णन परिभाषित करता है I

जावा में एक साधारण उदाहरण:

 public class DataValidationException extends Exception { private DataValidation error; /** * */ DataValidationException(DataValidation dataValidation) { super(); this.error = dataValidation; } } enum DataValidation{ TOO_SMALL(1,"The input is too small"), TOO_LARGE(2,"The input is too large"); private DataValidation(int code, String input) { this.input = input; this.code = code; } private String input; private int code; } 

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

मैं यहाँ बाड़ पर बैठ सकता हूं, लेकिन …

  1. यह भाषा पर निर्भर करता है
  2. आप जो भी मॉडल चुनते हैं, उसके बारे में सुसंगत रहें कि आप इसका उपयोग कैसे करते हैं।

पायथन में, अपवादों का उपयोग मानक अभ्यास है, और मैं अपने अपवादों को परिभाषित करने के लिए काफी खुश हूं। सी में आपके पास अपवाद नहीं है।

सी ++ (कम से कम एसटीएल में) में, अपवाद आम तौर पर केवल वास्तव में असाधारण त्रुटियों के लिए फेंक दिए जाते हैं (मैं वास्तव में खुद को कभी नहीं देखता हूं)। मेरे अपने कोड में कुछ अलग करने का कोई कारण नहीं है I हां रिटर्न वैल्यू को नजरअंदाज करना आसान है, लेकिन सी ++ आपको अपवाद को पकड़ने के लिए मजबूर नहीं करता है मुझे लगता है कि आपको इसे करने की आदत में आना पड़ेगा

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

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

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

अपवाद असाधारण परिस्थितियों के लिए हैं – यानी, जब वे कोड के सामान्य प्रवाह का हिस्सा नहीं हैं।

अपवाद और त्रुटि कोड मिश्रण करने के लिए काफी वैध है, जहां त्रुटि कोड कोड की प्रति से चलने में त्रुटि की बजाय किसी चीज की स्थिति का प्रतिनिधित्व करते हैं (जैसे बाल प्रक्रिया से रिटर्न कोड की जांच करना)।

लेकिन जब एक असाधारण परिस्थिति होती है तो मुझे विश्वास है कि अपवाद सबसे अभिव्यक्ति मॉडल हैं।

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

लेकिन दूसरी दिशा में जा रहा है, अपवाद का उपयोग करने से आप अपनी त्रुटि को संभालने के लिए और भी उच्च स्तर के पृथक्करण के निर्माण की अनुमति दे सकते हैं, जो आपके कोड को और अधिक अभिव्यंजक और प्राकृतिक बना सकते हैं। मैं इस उत्कृष्ट, अभी तक अधोरेखित, सी ++ विशेषज्ञ आंद्रेई एलेक्जेंड्रेस्को द्वारा लेख, जो उन्होंने कहा, "प्रवर्तन" के विषय पर लेख पढ़ने की सिफारिश करेगा: http://www.ddj.com/cpp/184403864 यद्यपि यह सी ++ आलेख है, सिद्धांत आम तौर पर लागू होते हैं, और मैंने लागू प्रवर्तन अवधारणा का अनुवाद सी # को सफलतापूर्वक किया है

सबसे पहले, मैं टॉम के जवाब से सहमत हूं कि उच्च-स्तरीय सामानों के उपयोग के अपवादों और कम-स्तरीय सामानों के लिए त्रुटि कोड के लिए, जब तक वह सेवा उन्मुखी वास्तुकला (एसओए) नहीं है

एसओए में, जहां विभिन्न मशीनों में तरीकों को बुलाया जा सकता है, तारों पर अपवाद पारित नहीं किया जा सकता है, इसके बजाए, हम नीचे की तरह संरचना के साथ सफलता / विफलता प्रतिक्रियाओं का उपयोग करते हैं (सी #):

 public class ServiceResponse { public bool IsSuccess => string.IsNullOrEmpty(this.ErrorMessage); public string ErrorMessage { get; set; } } public class ServiceResponse<TResult> : ServiceResponse { public TResult Result { get; set; } } 

और इस तरह प्रयोग करें:

 public async Task<ServiceResponse<string>> GetUserName(Guid userId) { var response = await this.GetUser(userId); if (!response.IsSuccess) return new ServiceResponse<string> { ErrorMessage = $"Failed to get user." }; return new ServiceResponse<string> { Result = user.Name }; } 

जब ये आपकी सेवा प्रतिक्रियाओं में लगातार उपयोग किए जाते हैं, तो यह एप्लिकेशन में सफलता / असफलताओं को संभालने का एक बहुत अच्छा पैटर्न बनाता है। इससे सेवाओं के साथ-साथ सेवाओं में एसिंक कॉल्स में आसान त्रुटि को संभालने की अनुमति मिलती है।

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

अमान्य संकेत दिए गए हैं जो dereferenced हो सकते हैं (उदाहरण के लिए जावा में NullPointerException पैदा करना) स्वीकार्य नहीं है।

कई अलग-अलग संख्यात्मक त्रुटि कोडों (-1, -2) का उपयोग करते हुए उसी फ़ंक्शन के रिटर्न वैल्यू आमतौर पर खराब शैली होती है, क्योंकि क्लाइंट "<0" के बजाय "== -1" चेक कर सकता है।

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

एक टीम में काम करने पर विचार करने के लिए एक अन्य चीज है, जहां इस तरह के फैसले को बनाने के लिए अल्ल्वेलवेलर्स के लिए एक स्पष्ट रेखा खींचना है। उदाहरण "उच्च-स्तरीय सामग्री के लिए अपवाद, निम्न-स्तरीय सामान के लिए त्रुटि कोड" बहुत ही व्यक्तिपरक हैं

किसी भी मामले में, जहां एक से अधिक तुच्छ प्रकार की त्रुटि संभव है, स्रोत कोड को किसी त्रुटि कोड को वापस करने के लिए या इसे संभाल करने के लिए संख्यात्मक शब्द का इस्तेमाल कभी नहीं करना चाहिए (वापस -7, यदि x == -7 …), लेकिन हमेशा नामित निरंतर (वापसी NO_SUCH_FOO, यदि x == NO_SUCH_FOO)।

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

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

इसलिए मेरी राय है कि यह दोनों अपवादों और त्रुटि कोड दोनों के साथ-साथ उपयोग करने के लिए सामान्य है

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

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

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

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

मेरा सामान्य नियम है:

  • फ़ंक्शन में केवल एक त्रुटि दिखाई दे सकती है: त्रुटि कोड का उपयोग करें (फ़ंक्शन के पैरामीटर के रूप में)
  • एक से अधिक विशिष्ट त्रुटि दिखाई दे सकती है: अपवाद छोड़ें

आपको दोनों का उपयोग करना चाहिए। यह बात तय करना है कि प्रत्येक एक का उपयोग कब करना है

कुछ परिदृश्य हैं जहां अपवाद स्पष्ट पसंद हैं :

  1. कुछ स्थितियों में आप त्रुटि कोड के साथ कुछ भी नहीं कर सकते हैं , और आपको इसे केवल कॉल स्टैक में ऊपरी स्तर में संभाल करने की आवश्यकता है , आमतौर पर बस त्रुटि लॉग करें, उपयोगकर्ता को कुछ प्रदर्शित करें या प्रोग्राम बंद करें इन मामलों में, त्रुटि कोड आपको त्रुटि कोड मैन्युअल रूप से स्तर के आधार पर बुलबुले करने की आवश्यकता होती है जो स्पष्ट रूप से अपवादों के साथ करना आसान होता है मुद्दा यह है कि यह अप्रत्याशित और अप्रतिबंधित परिस्थितियों के लिए है

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

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

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

  4. कन्स्ट्रक्टरों में आप अपवाद छोड़ सकते हैं।

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

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

वापसी कोड के बारे में सबसे लोकप्रिय आलोचना यह है कि "कोई त्रुटि कोड को अनदेखा कर सकता है, लेकिन उसी अर्थ में कोई भी अपवाद निगल सकता है। खराब अपवाद हैंडलिंग दोनों तरीकों में आसान है। लेकिन अच्छा त्रुटि कोड आधारित प्रोग्राम लिखना अभी भी बहुत आसान है एक अपवाद-आधारित कार्यक्रम लिखने की तुलना में । और अगर किसी भी कारण से सभी त्रुटियों को अनदेखा करने का फैसला किया जाता है ( on error resume next बाद पुराने on error resume next ), तो आप आसानी से रिटर्न कोड के साथ ऐसा कर सकते हैं और आप ऐसा नहीं कर सकते कि बहुत सारे प्रयासों के बिना बॉयलरप्लेट।

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

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

इसका सारांश प्रस्तुत करना:

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

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

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

फिर भी जीओ के बारे में, यह कई रिटर्न मानों को भी अनुमति देता है, जो कुछ ऐसा है जो रिटर्न कोड का उपयोग करने में बहुत मदद करता है, क्योंकि आप एक साथ एक त्रुटि और कुछ और लौट सकते हैं सी # / जावा पर हम यह प्राप्त कर सकते हैं कि पैरामीटर, ट्यूपल्स, या (मेरी पसंदीदा) जेनेरिक्स के साथ, जो ईनियम के साथ मिलकर कॉलर को स्पष्ट त्रुटि कोड प्रदान कर सकते हैं:

 public MethodResult<CreateOrderResultCodeEnum, Order> CreateOrder(CreateOrderOptions options) { .... return MethodResult<CreateOrderResultCodeEnum>.CreateError(CreateOrderResultCodeEnum.NO_DELIVERY_AVAILABLE, "There is no delivery service in your area"); ... return MethodResult<CreateOrderResultCodeEnum>.CreateSuccess(CreateOrderResultCodeEnum.SUCCESS, order); } var result = CreateOrder(options); if (result.ResultCode == CreateOrderResultCodeEnum.OUT_OF_STOCK) // do something else if (result.ResultCode == CreateOrderResultCodeEnum.SUCCESS) order = result.Entity; // etc... 

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

त्रुटि कोड भी काम नहीं करते जब आपकी पद्धति एक संख्यात्मक मान के अलावा अन्य कुछ देता है …