क्यों खाली पकड़ ब्लॉक एक बुरा विचार है? [बन्द है]

Question

मैंने कोशिश-कैच पर एक सवाल देखा है , जो लोग (जॉन स्कीट सहित) कहते हैं कि खाली कैच ब्लॉक वास्तव में एक बुरा विचार है? यही कारण है? क्या कोई स्थिति नहीं है जहां एक खाली पकड़ एक गलत डिजाइन निर्णय नहीं है?

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

Comments

मैं एक टिप्पणी लिखता हूँ कि यह खाली क्यों होना चाहिए।

— मेहरदाद अफश्री

... या कम से कम लॉग इन करें कि वह पकड़ा गया था।

— मैट बी

@ocdecio: सफाई कोड के लिए इसे टालें , सामान्य रूप से इससे बचें।

— जॉन सॉन्डर्स

@ocdecio: कोशिश का उपयोग करने से बचने का एक और मामला है..चेक तब है जब आप ज्ञात प्रकार की विफलताओं के अपवादों को पकड़ते हैं। उदाहरण के लिए संख्यात्मक रूपांतरण अपवाद

— MPritchard

@ocdecio - try..finally try..empty कैच से बेहतर है क्योंकि एरर स्टैक को जारी रखता है - या तो फ्रेमवर्क को संभालने के लिए, या प्रोग्राम को मारने के लिए और उपयोगकर्ता को प्रदर्शित करने के लिए - दोनों ही परिणाम "से बेहतर हैं" मौन विफलता ”।

— नैट

Answer 1

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

यह एक चेतावनी चेतावनी प्रकाश पर काले टेप लगाने के बराबर प्रोग्रामिंग है।

मेरा मानना ​​है कि आप अपवादों से कैसे निपटते हैं, इस बात पर निर्भर करता है कि आप किस सॉफ्टवेयर में काम कर रहे हैं: रेनफॉरेस्ट में अपवाद ।

Comments

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

— जॉन रुडी

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

— माइकल बूर

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

— डेविड थॉर्नले

@ जेसन: बहुत कम से कम, आपको यह बताते हुए एक विस्तृत टिप्पणी शामिल करनी चाहिए कि आप अपवादों को चुप क्यों कर रहे हैं।

— नेड बाचेल्डर

यह उत्तर दो चीजों को मानता है: 1. जो अपवाद को फेंका जा रहा है, वह वास्तव में एक सार्थक है और वह जो उस कोड को लिखता है जो फेंकता है वह जानता था कि वह क्या कर रहा था; 2. यह अपवाद वास्तव में एक "त्रुटि स्थिति" है और नियंत्रण प्रवाह के रूप में दुरुपयोग नहीं किया जाता है (हालांकि यह मेरे पहले बिंदु का अधिक विशिष्ट मामला है)।

— बोरिस बी।

Answer 2

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

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

Answer 3

मैं यह नहीं कहूंगा कि जहां तक ​​खाली ब्लॉक्स का इस्तेमाल करने वालों की बात है, वह एक खराब प्रोग्रामर है और वह यह नहीं जानता कि वह क्या कर रहा है ...

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

उदाहरण के लिए, कुछ http सर्वर लाइब्रेरी पर विचार करें, अगर सर्वर अपवाद छोड़ देता है तो मैं कम देखभाल नहीं कर सकता क्योंकि क्लाइंट डिस्कनेक्ट हो गया है और index.htmlभेजा नहीं जा सकता है।

Comments

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

— बेन वोइगट

Answer 4

ऐसे दुर्लभ उदाहरण हैं जहां इसे उचित ठहराया जा सकता है। अजगर में आप अक्सर इस तरह के निर्माण को देखते हैं:

try:
    result = foo()
except ValueError:
    result = None

तो ऐसा करना ठीक है (आपके आवेदन के आधार पर):

result = bar()
if result == None:
    try:
        result = foo()
    except ValueError:
        pass # Python pass is equivalent to { } in curly-brace languages
 # Now result == None if bar() returned None *and* foo() failed

हाल ही में एक .NET प्रोजेक्ट में, मुझे एक निश्चित इंटरफ़ेस को लागू करने वाली कक्षाओं को खोजने के लिए प्लगइन DLL की गणना करने के लिए कोड लिखना था। प्रासंगिक बिट कोड (VB.NET, क्षमा करें) में है:

    For Each dllFile As String In dllFiles
        Try
            ' Try to load the DLL as a .NET Assembly
            Dim dll As Assembly = Assembly.LoadFile(dllFile)
            ' Loop through the classes in the DLL
            For Each cls As Type In dll.GetExportedTypes()
                ' Does this class implement the interface?
                If interfaceType.IsAssignableFrom(cls) Then

                    ' ... more code here ...

                End If
            Next
        Catch ex As Exception
            ' Unable to load the Assembly or enumerate types -- just ignore
        End Try
    Next

हालांकि इस मामले में भी, मैं स्वीकार करता हूं कि विफलता को कहीं लॉग करना शायद एक सुधार होगा।

Comments

मैंने आपका उत्तर देखने से पहले उन उदाहरणों में से एक के रूप में log4net का उल्लेख किया।

— स्कॉट लॉरेंस

Answer 5

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

संबंधित नोट पर, अधिकांश लोग नहीं जानते कि {} ब्लॉक को एक {} या अंत में {} के साथ पकड़ा जा सकता है, केवल एक की आवश्यकता है।

Comments

+1 या जोड़ा प्रभाव के लिए उस अंतिम वाक्य में 'या' पर जोर

— दूंगा

यह दूसरा पैराग्राफ भाषा-निर्भर हो सकता है, हालांकि, सही?

— डेविड जेड

ज़ाहिर है जब तक आप IE6 या IE7 ;-) ... जहां पकड़ के बारे में बात कर रहे हैं है की आवश्यकता है या अंत में निष्पादित नहीं करता है। (यह IE8 btw में तय किया गया था)

— scunliffe

स्रोत: webbugtrack.blogspot.com/2007/11/…

— scunliffe

सच सच। भाषाओं को उजागर करने लायक हो सकता है। मेरा मानना ​​है कि .net ठीक है

— MPritchard

Answer 6

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

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

Comments

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

— डेविड थॉर्नले

हाँ, हर चीज़ के लिए एक समय और एक जगह होती है। सामान्य तौर पर, हालांकि, मुझे लगता है कि एक अच्छा कैच ब्लॉक अच्छा होना नियम का अपवाद है - यह एक दुर्लभ मामला है जहां आप वास्तव में अपवाद को अनदेखा करना चाहते हैं (आमतौर पर, आईएमओ, यह अपवादों के खराब उपयोग का परिणाम है)।

— रीड कोपसे

@ डेविड थॉर्नले: आप कैसे जानते हैं कि यह कुछ भी प्रभावित करने वाला नहीं है यदि आप कम से कम अपवाद का निरीक्षण नहीं करते हैं कि क्या यह एक अपेक्षित और निरर्थक त्रुटि है या जो इसके बजाय ऊपर की ओर प्रचारित होना चाहिए?

— डेव शेरोहमान

@ डव: catch (Exception) {}एक बुरा विचार है, catch (SpecificExceptionType) {}पूरी तरह से ठीक हो सकता है। प्रोग्रामर डीआईडी ​​अपवाद का निरीक्षण करता है, कैच क्लॉज में टाइप जानकारी का उपयोग करके।

— बेन वोइग्ट

Answer 7

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

लेकिन उस मामले में भी, एक डीबग संदेश क्रम में हो सकता है।

Answer 8

प्रति जोश बलोच - मद 65: क्या अपवाद को नजरअंदाज नहीं की प्रभावी जावा :

1. एक खाली कैच ब्लॉक अपवादों के उद्देश्य को पराजित करता है
2. बहुत कम से कम, कैच ब्लॉक में एक टिप्पणी होनी चाहिए जिसमें यह बताया गया है कि अपवाद को अनदेखा करना क्यों उचित है।

Answer 9

एक खाली कैच ब्लॉक अनिवार्य रूप से कह रहा है "मैं यह नहीं जानना चाहता कि क्या त्रुटियां हैं, मैं उन्हें अनदेखा करने जा रहा हूं।"

यह VB6 के समान है On Error Resume Next, सिवाय इसके कि ट्रायल ब्लॉक में अपवाद को फेंकने के बाद कुछ भी छोड़ दिया जाएगा।

जो तब मदद नहीं करता है जब कुछ टूट जाता है।

Comments

मैं वास्तव में कहूंगा "ऑन एरर रिज्यूमे नेक्स्ट" इससे भी बदतर है - यह सिर्फ अगली पंक्ति की परवाह किए बिना कोशिश करेगा। एक खाली कैच ट्राई स्टेटमेंट के क्लोजिंग ब्रेस को पास करने के लिए कूद जाएगा

— MP44chard

अच्छी बात। मुझे शायद अपनी प्रतिक्रिया में ध्यान देना चाहिए।

— पॉवरलॉर्ड

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

— मेटा-नाइट

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

— स्कॉट लॉरेंस

@ शब्द: कुछ भाषाओं (अर्थात जावा) ने अपवादों की जाँच कर ली है ... ऐसे अपवाद जिन्हें आप पकड़ने के लिए लिखने के लिए मजबूर हैं।

— पॉवरलॉर्ड

Answer 10

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

Answer 11

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

Answer 12

क्योंकि अगर एक अपवाद है फेंक दिया क्या तुमने कभी इसे देख नहीं होगा - चुपचाप नाकाम रहने के सबसे खराब संभव विकल्प है - आप गलत व्यवहार और जहां यह हो रहा है देखो करने के लिए कोई जानकारी नहीं मिल जाएगा। कम से कम एक लॉग संदेश वहाँ डाल दिया! भले ही यह कुछ ऐसा हो जो 'कभी नहीं हो सकता'!

Answer 13

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

Answer 14

मुझे लगता है कि खाली कैच के बयान से सबसे ज्यादा गुस्सा आता है, जब कुछ अन्य प्रोग्रामर ने ऐसा किया। मेरा मतलब यह है कि जब आपको किसी और से कोड को डीबग करने की आवश्यकता होती है, तो कोई भी खाली कैच स्टेटमेंट इस तरह के उपक्रम को अधिक कठिन बना देता है, तो यह होना चाहिए। IMHO कैच स्टेटमेंट में हमेशा किसी न किसी तरह का एरर मैसेज दिखाना चाहिए - भले ही एरर हैंडल न हो उसे कम से कम इसका पता लगाना चाहिए (ऑल ऑन डिबग मोड में)।

Answer 15

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

try
{
    // Do some processing.
}
catch (FileNotFound fnf)
{
    HandleFileNotFound(fnf);
}
catch (Exception e)
{
    if (!IsGenericButExpected(e))
        throw;
}

public bool IsGenericButExpected(Exception exception)
{
    var expected = false;
    if (exception.Message == "some expected message")
    {
        // Handle gracefully ... ie. log or something.
        expected = true;
    }

    return expected;
}

Comments

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

— एमपीट्रचर्ड

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

— xanadont

मैं मूल रूप से COMException के बारे में सोच रहा था। आप एक विशिष्ट ErrorCode के लिए परीक्षण कर सकते हैं और उन कोड को संभाल सकते हैं जिनकी आप अपेक्षा करते हैं। मैं ऐसा अक्सर करता हूं जब ArcOjbects के साथ प्रोग्रामिंग करता हूं।

— xanadont

-1 अपवाद संदेश के आधार पर कोड में निर्णय लेना वास्तव में एक बुरा विचार है। सटीक संदेश शायद ही कभी प्रलेखित है और किसी भी समय बदल सकता है; यह एक कार्यान्वयन विवरण है। या संदेश स्थानीय संसाधन स्ट्रिंग पर आधारित हो सकता है। किसी भी मामले में यह केवल मानव द्वारा पढ़ने के लिए है।

— Wim Coenen

EEK। अपवाद। स्थान को स्थानीय बनाया जा सकता है और इस प्रकार आप जो उम्मीद करते हैं वह नहीं है। यह सिर्फ गलत है।

— फ्रैंकमर्स

Answer 16

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

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

एक और उदाहरण: सीएलआर 2.0 ने फाइनल थ्रेड पर अनियंत्रित अपवादों के तरीके को बदल दिया। 2.0 से पहले प्रक्रिया को इस परिदृश्य को जीवित रखने की अनुमति दी गई थी। वर्तमान सीएलआर में अंतिम थ्रेड पर अनहेल्डेड अपवाद के मामले में प्रक्रिया समाप्त हो जाती है।

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

Answer 17

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

इसलिए, आपके उदाहरण के साथ, यह उस मामले में एक बुरा विचार है क्योंकि आप सभी अपवादों को पकड़ रहे हैं और अनदेखा कर रहे हैं। यदि आप केवल पकड़ रहे थे EInfoFromIrrelevantSourceNotAvailableऔर इसे अनदेखा कर रहे थे , तो यह ठीक होगा, लेकिन आप नहीं हैं। आप भी अनदेखा कर रहे हैं ENetworkIsDown, जो महत्वपूर्ण हो सकता है या नहीं। आप अनदेखा कर रहे हैं ENetworkCardHasMeltedऔरEFPUHasDecidedThatOnePlusOneIsSeventeen , जो लगभग निश्चित रूप से महत्वपूर्ण हैं।

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

Answer 18

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

• अपवाद लॉगिंग; संदर्भ के आधार पर आप इसके बजाय पोस्ट किए गए एक अपवाद या संदेश को चाहते हो सकते हैं।

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

• ऐसे कार्यक्रम जो विफल नहीं हो सकते, हालांकि उन्हें अभी भी कम से कम कुछ लॉग करना चाहिए।

अधिकांश winforms अनुप्रयोगों के लिए, मैंने पाया है कि यह प्रत्येक उपयोगकर्ता इनपुट के लिए एक सिंगल स्टेटमेंट स्टेटमेंट के लिए पर्याप्त है। मैं निम्नलिखित विधियों का उपयोग करता हूं: (AlertBox सिर्फ एक त्वरित MessageBox.Show आवरण है)

  public static bool TryAction(Action pAction)
  {
     try { pAction(); return true; }
     catch (Exception exception)
     {
        LogException(exception);
        return false;
     }
  }

  public static bool TryActionQuietly(Action pAction)
  {
     try { pAction(); return true; }
     catch(Exception exception)
     {
        LogExceptionQuietly(exception);
        return false;
     }
  }

  public static void LogException(Exception pException)
  {
     try
     {
        AlertBox(pException, true);
        LogExceptionQuietly(pException);
     }
     catch { }
  }

  public static void LogExceptionQuietly(Exception pException)
  {
     try { Debug.WriteLine("Exception: {0}", pException.Message); } catch { }
  }

फिर हर ईवेंट हैंडलर कुछ ऐसा कर सकता है:

  private void mCloseToolStripMenuItem_Click(object pSender, EventArgs pEventArgs)
  {
     EditorDefines.TryAction(Dispose);
  }

या

  private void MainForm_Paint(object pSender, PaintEventArgs pEventArgs)
  {
     EditorDefines.TryActionQuietly(() => Render(pEventArgs));
  }

सैद्धांतिक रूप से, आप TryActionSilently हो सकते हैं, जो कॉल रेंडर करने के लिए बेहतर हो सकता है ताकि अपवाद संदेशों की अंतहीन मात्रा उत्पन्न न करें।

Answer 19

यदि आप नहीं जानते कि कैच ब्लॉक में क्या करना है, तो आप इस अपवाद को लॉग इन कर सकते हैं, लेकिन इसे खाली न छोड़ें।

        try
        {
            string a = "125";
            int b = int.Parse(a);
        }
        catch (Exception ex)
        {
            Log.LogError(ex);
        }

Comments

इसे क्यों ठुकरा दिया गया?

— वीनो

Answer 20

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