त्रुटि से निपटने - त्रुटियों पर एक कार्यक्रम विफल होना चाहिए या चुपचाप उन्हें अनदेखा करना चाहिए

Question

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

अपवाद हैंडलिंग के लिए, मुझे दो दृष्टिकोण दिखाई देते हैं। क्या मुझे प्रोग्राम लिखना चाहिए ताकि यह:

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

उपयोगकर्ता किस दृष्टिकोण से उचित उम्मीद करेगा?
क्या अपवादों को संभालने का एक बेहतर तरीका है?

इसके अतिरिक्त, अपवादों को संभालने के बारे में मेरे निर्णय से प्रभावित होना चाहिए कि क्या मैं एक नेटवर्क कनेक्शन के साथ काम कर रहा हूं या नहीं।

Comments

@ GlenH7 इसे आगे भुगतान करें ... :)

— gnat

क्या +1 संपादन का कोई तरीका है? ;) ओह, रुको, मैं तुम्हारा पीछा करता हूं। ज़रूर, करेंगे :)

— Arlen Beiler

"कौन सा दृष्टिकोण एक उपयोगकर्ता को यथोचित उम्मीद करेगा?"। क्या आपने अपने किसी उपयोगकर्ता से पूछने की कोशिश की? हॉलवे प्रयोज्य परीक्षण उल्लेखनीय रूप से प्रभावी हो सकता है। ब्लॉग

— ब्रायन ओकले

मेरे पास कोई उपयोगकर्ता नहीं है :)

— Arlen Beiler

Answer 1

कभी भी आपको एक त्रुटि को नजरअंदाज नहीं करना चाहिए जो आपके कार्यक्रम का सामना करता है। नंगे न्यूनतम पर, आपको इसे एक फ़ाइल या अधिसूचना के लिए किसी अन्य mecanism में लॉग करना चाहिए। कभी-कभी ऐसी परिस्थितियाँ भी हो सकती हैं जहाँ आप किसी त्रुटि को अनदेखा करना चाहते हैं लेकिन उसे दस्तावेज़ित कर सकते हैं! catchकिसी भी टिप्पणी के बिना एक खाली ब्लॉक न लिखें, यह बताते हुए कि यह खाली क्यों है।

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

Comments

वारंट -1 के लिए पर्याप्त नहीं है, लेकिन "कभी नहीं" एक मजबूत शब्द है, और ऐसी परिस्थितियां हैं जहां त्रुटियों की अनदेखी करना कार्रवाई का सही कोर्स है। उदाहरण के लिए, HDTV प्रसारण प्रसारित करने के लिए सॉफ्टवेयर। जब आप कुछ त्रुटियों का सामना करते हैं, जो आप अक्सर करेंगे, तो आप बस इसे अनदेखा कर सकते हैं और जो बाद में आता है उसे डिकोड करते रहें।

— whatsisname

@whatsisname: सच है, लेकिन आपको स्पष्ट रूप से दस्तावेज़ करना चाहिए कि आप इसे क्यों अनदेखा कर रहे हैं। आपकी टिप्पणी पर विचार करने के लिए अद्यतित उत्तर।

— मार्को-फिसेट

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

— माईविक्टर

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

— मजबूर करता है

@whatsisname मुझे लगता है कि आप उस मामले में "त्रुटि" की अपनी परिभाषा के बारे में सोचना चाह सकते हैं। प्राप्त आंकड़ों में त्रुटियां सॉफ्टवेयर प्रोग्राम की संरचना और निष्पादन में त्रुटियों के समान नहीं हैं।

— joshin4colours

Answer 2

आपको कभी चुपचाप त्रुटियों को नजरअंदाज नहीं करना चाहिए, क्योंकि आपका कार्यक्रम उन कार्यों की एक श्रृंखला पर बनाया गया है, जो स्पष्ट रूप से उन सभी चीजों पर निर्भर करते हैं जो उनके सही होने से पहले चले गए हैं। यदि चरण 3 में कुछ गलत हो जाता है, और आप चरण 4 पर जारी रखने का प्रयास करते हैं, तो चरण 4 अमान्य मान्यताओं के आधार पर शुरू होने जा रहा है, जिससे यह अधिक संभावना है कि यह एक त्रुटि भी उत्पन्न करेगा। (और यदि आप इसे भी अनदेखा करते हैं, तो चरण 5 एक त्रुटि फेंकता है, और चीजें वहां से स्नोबॉल करने लगती हैं।)

बात यह है कि जैसे-जैसे त्रुटियां ढेर होती जाती हैं, अंतत: आप कुछ त्रुटि में इतने बड़े हो जाएंगे कि आप इसे नजरअंदाज नहीं कर सकते, क्योंकि इसमें उपयोगकर्ता को कुछ दिया जाएगा, और यह पूरी तरह से गलत होगा। तब आपके पास उपयोगकर्ताओं को आपके कार्यक्रम के बारे में शिकायत है कि आप सही काम नहीं कर रहे हैं, और आपको इसे ठीक करना होगा। और अगर "उपयोगकर्ता को कुछ देना है" भाग 28 चरण में है, और आपको पता नहीं है कि मूल त्रुटि जो यह सब गड़बड़ पैदा कर रही है वह चरण 3 में थी क्योंकि आपने चरण 3 में त्रुटि को अनदेखा कर दिया है, तो आप एक एक समय की समस्या समस्या डिबगिंग!

दूसरी ओर, यदि चरण 3 में वह त्रुटि उपयोगकर्ता के चेहरे में सब कुछ उड़ा देती है, और एक त्रुटि कहती है SOMETHING WENT BADLY WRONG IN STEP 3!(या इसके तकनीकी समकक्ष, एक स्टैक ट्रेस) उत्पन्न करती है, तो परिणाम एक ही है - उपयोगकर्ता आपके बारे में शिकायत कर रहा है कार्यक्रम सही काम नहीं कर रहा है - लेकिन इस बार आप ठीक से जानते हैं कि आप इसे ठीक करने के लिए कब देखना शुरू करेंगे ।

संपादित करें: टिप्पणियों के जवाब में, अगर कुछ गलत हो जाता है जिसे आपने प्रत्याशित किया है और पता है कि कैसे संभालना है, तो यह अलग है। उदाहरण के लिए, एक विकृत संदेश प्राप्त करने की स्थिति में, यह प्रोग्राम त्रुटि नहीं है; यह "उपयोगकर्ता खराब इनपुट प्रदान करता है जो सत्यापन विफल हो गया।" उपयोगकर्ता को यह बताने के लिए उपयुक्त प्रतिक्रिया है कि वह आपको अमान्य इनपुट दे रहा है, जो कि ऐसा लगता है जैसे आप कर रहे हैं। इस तरह के एक मामले में स्टैक ट्रेस को क्रैश करने और उत्पन्न करने की आवश्यकता नहीं है।

Comments

कैसे अंतिम ज्ञात अच्छी स्थिति में लौटने के बारे में, या एक राहत पाश के मामले में, बस उस संदेश को छोड़ने और अगले एक पर जाने के लिए।

— अर्लेन बीइलर

@Arlen: यहां तक ​​कि एक बुरा विचार हो सकता है। त्रुटियां इसलिए होती हैं क्योंकि कुछ ऐसा हुआ था जिसे आप अनुमान नहीं लगाते थे जब आप इसे कोड कर रहे थे । इसका मतलब है कि आपकी सभी धारणाएं खिड़की से बाहर चली गई हैं। यदि आप कुछ डेटा संरचना को संशोधित करने के माध्यम से आधे रास्ते में थे, तो "अंतिम ज्ञात अच्छी स्थिति" अब अच्छी नहीं हो सकती है और अब यह असंगत स्थिति में है, उदाहरण के लिए।

— मेसन व्हीलर

क्या होगा अगर मैं इसकी उम्मीद कर रहा हूँ, जैसे कि भ्रष्ट संदेशों को डीसेरलाइज़ेशन को रोकना। कुछ मामलों में, मैंने अपवाद को अनुक्रमित किया है और इसे तार के पार वापस भेज दिया है। वहां, प्रश्न को मेरा संपादन देखें।

— अर्लेन बीलर

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

— मेसन व्हीलर

Answer 3

"ब्लो अप" और "उपेक्षा" के बीच अन्य विकल्प हैं।

यदि त्रुटि पूर्वानुमेय और परिहार्य है, तो अपना डिज़ाइन बदलें या इससे बचने के लिए अपने कोड को रिफलेक्टर करें।

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

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

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

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

देखें एरिक Lippert उत्तम अपवाद हैंडलिंग लेख के वर्गीकरण और अपवादों से निपटने के बारे में अधिक सुझावों के लिए।

Comments

मेरी राय में, अब तक का सबसे अच्छा जवाब।

— थर्सडेजेक

Answer 4

इस सवाल पर मेरे विचार हैं:

एक अच्छा प्रारंभिक सिद्धांत तेजी से विफल होना है। विशेष रूप से, आपको किसी भी विफलता के लिए त्रुटि हैंडलिंग कोड कभी नहीं लिखना चाहिए, जिसके लिए आपको सटीक कारण नहीं पता है।

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

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

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

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

Answer 5

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

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

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

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

विज्ञापन संपादित करना, एकमात्र अंतर यह है कि आपको उपयोगकर्ता को देने और काम न करने से पहले कुछ समय के लिए पुन: प्रयास करने पर विचार करना चाहिए, क्योंकि नेटवर्क में क्षणिक त्रुटियां होने की संभावना है जो यदि आप फिर से प्रयास करते हैं तो पुनः प्राप्त नहीं करेंगे।

Comments

क्या आप वास्तव में पहली पंक्ति के अंत में एक प्रश्न चिह्न लगाने के लिए थे?

— बजे एक CVn

@ माइकलकॉर्जलिंग: नहीं। कॉपी-पेस्ट त्रुटि (प्रश्न से फॉर्म्युलेशन की नकल की और गलती से प्रश्न चिह्न शामिल किया)।

— Jan Hudec

Answer 6

ऐसे मामलों का एक वर्ग है जहां त्रुटियों को अनदेखा करना सही बात है: जब ऐसा कुछ नहीं है जो संभवतः स्थिति के बारे में किया जा सकता है और जब खराब और संभवत: गलत परिणाम बिना परिणाम से बेहतर होते हैं।

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

Answer 7

मेरा मानना ​​है कि जब भी यह किसी मुद्दे पर चलता है तो किसी कार्यक्रम को चुपचाप अनदेखा करना चाहिए या कहर करना चाहिए।

मैं अपनी कंपनी के लिए लिखने वाले आंतरिक सॉफ्टवेयर के साथ क्या करता हूं ...

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

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

मैं जिन सबसे बड़ी चीजों से बचने की कोशिश करता हूं उनमें से एक त्रुटि के बाद प्रोग्राम क्रैश होने से बचने के लिए सक्षम नहीं है। मैं हमेशा उपयोगकर्ता को एप्लिकेशन को बंद किए बिना जारी रखने का विकल्प देने की कोशिश करता हूं।

मेरा मानना ​​है कि अगर कोई बग के बारे में नहीं जानता है - तो यह कभी तय नहीं होगा। मैं भी त्रुटि से निपटने का एक दृढ़ विश्वास है कि आवेदन एक बग की खोज की है एक बार कार्य जारी रखने के लिए अनुमति देता है।

यदि त्रुटि नेटवर्क से संबंधित है - पहली जगह पर त्रुटि से बचने के लिए फ़ंक्शन को निष्पादित करने से पहले फ़ंक्शन एक साधारण नेटवर्क संचार परीक्षण क्यों नहीं करते हैं? फिर बस उपयोगकर्ता को सचेत करें कि कोई कनेक्शन उपलब्ध नहीं है कृपया अपने इंटरनेट आदि को सत्यापित करें और पुनः प्रयास करें?

Comments

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

— जेफ

Answer 8

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

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

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

के लिए क्रम त्रुटियों , इस तरह के नेटवर्क या धारावाहिक संचार विफलताओं या अनुपलब्ध या दूषित फ़ाइलों के रूप में है कि संभवतः बग-मुक्त कोड के साथ भी हो सकता है:

1. त्रुटि लॉग करें।
2. (वैकल्पिक) चुपचाप फिर से प्रयास करने या अन्यथा ऑपरेशन से उबरने का प्रयास।
3. यदि ऑपरेशन विफल हो रहा है या अप्राप्य है, तो उपयोगकर्ता को विज़ुअली त्रुटि की रिपोर्ट करें। फिर ऊपर के रूप में, उपयोगकर्ता तय कर सकता है कि क्या करना है। कम से कम एस्टन के सिद्धांत को याद रखें , क्योंकि डेटा अखंडता का नुकसान उपयोगकर्ता के लिए आश्चर्यजनक है जब तक कि आपने उन्हें समय से पहले चेतावनी नहीं दी हो।

Answer 9

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