C # में आखिरकार उपयोग क्यों?

Question

अंत में जो कुछ भी होता है, उसे हमेशा (लगभग) निष्पादित किया जाता है, इसलिए इसमें कोड संलग्न करने या इसे छोड़ने के बीच क्या अंतर है?

Comments

इसे छोड़ने से क्या मतलब है?

— रमेश

और "(लगभग)" से आपका क्या तात्पर्य है?

— बेस्का

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

— डोर हाई आर्क

योग्य, हाँ, यह सच है, लेकिन आप वास्तव में उसके लिए कोड नहीं कर सकते हैं?

— एड एस।

@ ईडी: लेनदेन का उपयोग करें। आपकी कोशिश क्लॉज को कुछ प्रकार के अस्थायी या स्मृति-परिवर्तन करने की होती है, जो कि एकल, परमाणु, अंत में क्लॉज में परिवर्तन के लिए बनी रह सकती है। यह शायद ही कभी आसान है और विशेष हार्डवेयर की आवश्यकता हो सकती है।

— डोर हाई आर्क

Answer 1

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

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

try
{
    doSomething();
}
catch
{
    catchSomething();
}
finally
{
    alwaysDoThis();
}

जब आप यह कर सकते हैं:

try
{
    doSomething();
}
catch
{
    catchSomething();
}

alwaysDoThis();

इसका उत्तर यह है कि आपके कैच स्टेटमेंट के अंदर कोड बहुत बार या तो एक अपवाद को हटा देगा या वर्तमान फ़ंक्शन से बाहर निकल जाएगा। बाद वाले कोड के साथ, "alwaysDoThis ();" कॉल निष्पादित नहीं करेगा यदि कैच स्टेटमेंट के अंदर कोड रिटर्न जारी करता है या एक नया अपवाद फेंकता है।

Comments

हम्म। मैंने जो कहा, उससे बहुत कुछ मिलता-जुलता, लेकिन स्पष्ट और अधिक सटीक। निश्चित 1।

— बेस्का

यह कोशिश {} ब्लॉक के अंदर "वापसी" पर भी लागू होती है।

— लुकास

वास्तव में, यह एक पकड़ के बिना भी लागू होता है {} ब्लॉक (बस कोशिश करें / अंत में, अपवाद को छोड़ दें)

— लुकास

बेहतर तो मेरा है, काम पर था और विस्तार से जवाब देने में दस मिनट खर्च नहीं करना चाहता था। +1

— मैट ब्रिग्स

हां, यह वही था जो मेरे मन में था: डी नाउ मैं इसे समझता हूं।

— रोड्रिगो

Answer 2

कोशिश-अंत का उपयोग करने के अधिकांश फायदे पहले ही बताए जा चुके हैं, लेकिन मुझे लगा कि मैं इसे जोड़ूंगा:

try
{
    // Code here that might throw an exception...

    if (arbitraryCondition)
    {
        return true;
    }

    // Code here that might throw an exception...
}
finally
{
    // Code here gets executed regardless of whether "return true;" was called within the try block (i.e. regardless of the value of arbitraryCondition).
}

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

Comments

यह वस्तुतः एकमात्र कारण है जिसका मैं अंत में उपयोग करता हूं

— क्रिस्टोफर टाउनसेंड

Answer 3

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

 SqlConnection myConn = new SqlConnection("Connectionstring");
        try
        {
            myConn.Open();
            //make na DB Request                
        }
        catch (Exception DBException)
        {
            //do somehting with exception
        }
        finally
        {
           myConn.Close();
           myConn.Dispose();
        }

यदि आप त्रुटि को पकड़ना नहीं चाहते हैं तो उपयोग करें

 using (SqlConnection myConn = new SqlConnection("Connectionstring"))
        {
            myConn.Open();
            //make na DB Request
            myConn.Close();
        }

और यदि कोई त्रुटि है, तो कनेक्शन ऑब्जेक्ट को स्वचालित रूप से निपटाया जाएगा, लेकिन आप त्रुटि को कैप्चर नहीं करते हैं

Comments

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

— लुकास

अच्छा, उपयोग का उल्लेख करने के लिए धन्यवाद। मुझे जवाब देना होगा, नहीं तो।

— डैन रोसेन्स्टार्क

Answer 4

क्योंकि अंत में एक कैच ब्लॉक में एक अपवाद को हैंडल नहीं करने पर भी निष्पादित हो जाएगा।

Answer 5

अंत में बयान वापसी के बाद भी निष्पादित कर सकते हैं।

private int myfun()
{
    int a = 100; //any number
    int b = 0;
    try
    {
        a = (5 / b);
        return a;
    }
    catch (Exception ex)
    {
        Response.Write(ex.Message);
        return a;
    }

 //   Response.Write("Statement after return before finally");  -->this will give error "Syntax error, 'try' expected"
    finally
    {
      Response.Write("Statement after return in finally"); // --> This will execute , even after having return code above
    } 

    Response.Write("Statement after return after finally");  // -->Unreachable code
}

Answer 6

finally, जैसे की:

try {
  // do something risky
} catch (Exception ex) {
  // handle an exception
} finally {
  // do any required cleanup
}

अपने try..catchब्लॉक के बाद कोड निष्पादित करने के लिए एक गारंटीकृत अवसर है , भले ही आपके प्रयास ब्लॉक ने अपवाद को फेंक दिया हो या नहीं।

यह संसाधनों को जारी करने, डीबी कनेक्शन, फ़ाइल हैंडल आदि जैसी चीजों के लिए एकदम सही है।

Comments

उन सभी उदाहरणों का उपयोग आमतौर पर एक ब्लॉकिंग ब्लॉक के साथ किया जाता है, लेकिन यह वास्तव में आपके उत्तर से अलग नहीं होता है।

— जोएल कोएहॉर्न

Answer 7

मैं फ़ाइल रीडर अपवाद उदाहरण के साथ अंत में उपयोग की व्याख्या करूंगा

• अंत में उपयोग करके

try{

  StreamReader strReader = new StreamReader(@"C:\Ariven\Project\Data.txt");
  Console.WriteLine(strReader.ReadeToEnd());
  StreamReader.Close();
}
catch (Exception ex)
{
  Console.WriteLine(ex.Message);
}

उपरोक्त उदाहरण में, यदि Data.txt नामक फ़ाइल गायब है, तो एक अपवाद को फेंक दिया जाएगा और उसे संभाल लिया जाएगा, लेकिन कहा गया कथन कभी भी निष्पादित नहीं किया जाएगा। इस वजह से पाठक से जुड़े संसाधन कभी जारी नहीं हुए।StreamReader.Close();

• उपरोक्त समस्या को हल करने के लिए, हम अंत में उपयोग करते हैं

StreamReader strReader = null;
try{
    strReader = new StreamReader(@"C:\Ariven\Project\Data.txt");
    Console.WriteLine(strReader.ReadeToEnd());
}
catch (Exception ex){
    Console.WriteLine(ex.Message);
}
finally{
    if (strReader != null){
        StreamReader.Close();
    }
}

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

नोट: "@" का उपयोग एक शब्दशः स्ट्रिंग बनाने के लिए किया जाता है , ताकि "अपरिचित एस्केप सीक्वेंस" की त्रुटि से बचा जा सके। @ प्रतीक का अर्थ है उस स्ट्रिंग को शाब्दिक रूप से पढ़ना, और अन्यथा नियंत्रण वर्णों की व्याख्या न करना।

Answer 8

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

Answer 9

कभी-कभी आप एक अपवाद (कोई कैच ब्लॉक) को संभालना नहीं चाहते हैं, लेकिन आप कुछ सफाई कोड निष्पादित करना चाहते हैं।

उदाहरण के लिए:

try
{
    // exception (or not)
}
finally
{
    // clean up always
}

Comments

यदि अपवाद नहीं पकड़ा गया है, तो अंत में ब्लॉक का निष्पादन इस बात पर निर्भर करता है कि ऑपरेटिंग सिस्टम अपवाद खोलना ऑपरेशन को ट्रिगर करता है या नहीं।

— विकास वर्मा

Answer 10

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

Answer 11

आह ... मुझे लगता है कि मैं देख रहा हूँ कि तुम क्या कह रहे हो! मुझे एक सेकंड में ले गया ... आप सोच रहे हैं कि "आखिरकार ब्लॉक के बजाय अंत में ब्लॉक में क्यों रखें और कोशिश-कैच-एंड के बाहर पूरी तरह से"।

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

Answer 12

अंत में ब्लॉक का नियंत्रण प्रवाह या तो कोशिश या कैच ब्लॉक के बाद है।

[1. First Code]
[2. Try]
[3. Catch]
[4. Finally]
[5. After Code]

अपवाद के साथ 1> 2> 3> 4> 5 यदि 3 में रिटर्न स्टेटमेंट 1> 2> 3> 4 है

अपवाद के बिना 1> 2> 4> 5 यदि 2 में रिटर्न स्टेटमेंट 1> 2> 4 है

Answer 13

जैसा कि प्रलेखन में उल्लेख किया गया है :

कैच और अंत में एक साथ उपयोग का एक प्रयास ब्लॉक में संसाधनों को प्राप्त करना और उनका उपयोग करना है, एक कैच ब्लॉक में असाधारण परिस्थितियों से निपटना और अंततः ब्लॉक में संसाधनों को जारी करना है।

यह भी पढ़ने लायक है इस , जिसमें कहा गया है:

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

तो यह स्पष्ट है कि एक finallyखंड में रहने वाले कोड को निष्पादित किया जाएगा भले ही एक पूर्व catchखंड में एक returnबयान था।