दिलचस्प पोस्ट
आईएसओ में NSURL कनेक्शन और मूल HTTP प्रमाणीकरण आईओएस पर हवाई जहाज मोड का पता लगाएं SQLSERVER में सूचीगैग बाईपास एंड्रॉइड यूएसबी होस्ट अनुमति पुष्टिकरण संवाद एकाधिक लुकअप के लिए फ़ंक्शन को लूपिंग करना ईओनिक ऐप $ http के साथ कॉस सक्षम सर्वर को कनेक्ट नहीं कर सकता टॉमकेट 7 – सर्वलेट 3.0: लगातार पूल में अमान्य बाइट टैग कोई भी नाम के साथ जावा विधि कॉल करना Android में कस्टम सूची दृश्य में खोज कार्यक्षमता का उपयोग कैसे करें एडीटी और एसडीके उपकरण v17 के अपडेट के बाद जीएसएन नोक्लास डीफफाउंड एरर javax.websocket क्लाइंट सरल उदाहरण पसंदीदा इंटरफेसऑरेंटेशनफॉरियोजन को एक समर्थित इंटरफ़ेस ओरिएंटेशन वापस करना होगा जीएनयू बनाने के साथ "स्रोत पेड़ से बाहर" सी-प्रोग्राम बिल्डिंग @ प्री-अपेट और @ क्रेपरिसिस्ट हाइबरनेट / जेपीए (सत्र का उपयोग कर) किसी भी उपयोग के लिए RVVN संदर्भों का उपयोग करें?

आखिरकार एक अपवाद छेड़ने पर क्या होता है?

यदि एक अंत में ब्लॉक एक अपवाद फेंकता है, तो वास्तव में क्या होता है?

विशेष रूप से, क्या होता है अगर अंत में ब्लॉक के माध्यम से अपवाद फेंका जाता है इस ब्लॉक में बाकी बयानों (बाद में) क्या आते हैं?

मुझे पता है कि अपवाद ऊपर की तरफ फैल जाएगा I

Solutions Collecting From Web of "आखिरकार एक अपवाद छेड़ने पर क्या होता है?"

यदि एक अंत में ब्लॉक एक अपवाद क्या वास्तव में होता है फेंकता है?

यह अपवाद बाहर और ऊपर फैलता है, और (कर सकते हैं) एक उच्च स्तर पर संभाला जाएगा

आपका आखिरी ब्लॉक उस बिंदु से पूरा नहीं होगा जहां अपवाद फेंक दिया जाता है।

अगर अंतिम ब्लॉक पहले के अपवाद के निपटान के दौरान क्रियान्वित कर रहा था, तो पहला अपवाद खो गया है।

सी # 4 भाषा विनिर्देश § 8.9.5: अगर अंत में ब्लॉक एक और अपवाद फेंकता है, तो वर्तमान अपवाद की प्रक्रिया को समाप्त कर दिया गया है।

इस तरह के प्रश्नों के लिए मैं आमतौर पर विजुअल स्टूडियो में एक खाली कंसोल एप्लिकेशन प्रोजेक्ट को खोलता हूं और एक छोटा नमूना प्रोग्राम लिखता हूं:

 using System; class Program { static void Main(string[] args) { try { try { throw new Exception("exception thrown from try block"); } catch (Exception ex) { Console.WriteLine("Inner catch block handling {0}.", ex.Message); throw; } finally { Console.WriteLine("Inner finally block"); throw new Exception("exception thrown from finally block"); Console.WriteLine("This line is never reached"); } } catch (Exception ex) { Console.WriteLine("Outer catch block handling {0}.", ex.Message); } finally { Console.WriteLine("Outer finally block"); } } } 

जब आप प्रोग्राम चलाते हैं तो आपको सटीक आदेश दिखाई देगा जिसमें catch और finally ब्लॉक निष्पादित होते हैं। कृपया ध्यान दें कि अपवाद के बाद अंतिम ब्लॉक में कोड निष्पादित नहीं किया जा रहा है (वास्तव में, इस नमूना कार्यक्रम में विज़ुअल स्टूडियो आपको चेतावनी देगा कि उसे अपरिवर्तनीय कोड मिल गया है):

 कोशिश ब्लॉक से फेंक दिया आंतरिक पकड़ ब्लॉक हैंडलिंग अपवाद
 आंतरिक अंततः ब्लॉक
 अंत में ब्लॉक से फेंक दिया बाहरी पकड़ ब्लॉक हैंडलिंग अपवाद
 बाहरी अंत में ब्लॉक

अतिरिक्त टिप्पणी

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

 using System; class Program { static void Main(string[] args) { try { try { throw new Exception("exception thrown from try block"); } finally { Console.WriteLine("Inner finally block"); throw new Exception("exception thrown from finally block"); Console.WriteLine("This line is never reached"); } } catch (Exception ex) { Console.WriteLine("Outer catch block handling {0}.", ex.Message); } finally { Console.WriteLine("Outer finally block"); } } } 

जैसा कि आप आउटपुट से देख सकते हैं आंतरिक अपवाद "खो गया" (अर्थात् अनदेखी):

 आंतरिक अंततः ब्लॉक
 अंत में ब्लॉक से फेंक दिया बाहरी पकड़ ब्लॉक हैंडलिंग अपवाद
 बाहरी अंत में ब्लॉक

अगर अपवाद लंबित है (जब try ब्लॉक finally लेकिन कोई catch नहीं है), नया अपवाद उस स्थान को बदल देता है

यदि कोई अपवाद लंबित नहीं है, तो यह finally ब्लॉक के बाहर एक अपवाद फेंकने के रूप में काम करता है।

अपवाद फैलता है

"मूल अपवाद" (फ्लाइट में फेंक दिया गया) को बचाने के लिए त्वरित और (स्पष्ट रूप से स्पष्ट) स्निपेट और बलिदान "अंत में अपवाद" ( finally ब्लॉक में फेंक दिया गया), मूल रूप से आपके लिए अधिक महत्वपूर्ण है:

 try { throw new Exception("Original Exception"); } finally { try { throw new Exception("Finally Exception"); } catch { } } 

जब कोड ऊपर निष्पादित होता है, "मूल अपवाद" कॉल स्टैक का प्रचार करता है, और "अंत में अपवाद" खो जाता है।

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

 errorMessage = string.Empty; try { byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(xmlFileContent); webRequest = WebRequest.Create(url); webRequest.Method = "POST"; webRequest.ContentType = "text/xml;charset=utf-8"; webRequest.ContentLength = requestBytes.Length; //send the request using (var sw = webRequest.GetRequestStream()) { sw.Write(requestBytes, 0, requestBytes.Length); } //get the response webResponse = webRequest.GetResponse(); using (var sr = new StreamReader(webResponse.GetResponseStream())) { returnVal = sr.ReadToEnd(); sr.Close(); } } catch (Exception ex) { errorMessage = ex.ToString(); } finally { try { if (webRequest.GetRequestStream() != null) webRequest.GetRequestStream().Close(); if (webResponse.GetResponseStream() != null) webResponse.GetResponseStream().Close(); } catch (Exception exw) { errorMessage = exw.ToString(); } } 

अगर webRequest बनाया गया था लेकिन एक कनेक्शन त्रुटि के दौरान हुआ

 using (var sw = webRequest.GetRequestStream()) 

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

यदि आखिर में एक कोशिश-पकड़ के अंदर नहीं था, तो यह कोड वेबरिक्स्ट को साफ करते हुए एक अपवादित अपवाद का कारण होगा

 if (webRequest.GetRequestStream() != null) 

वहां से कोड ठीक से उस त्रुटि को संभालने के बिना बाहर निकलेगा और इसलिए कॉलिंग विधि के लिए समस्याएं पैदा करेगा।

उम्मीद है कि यह एक उदाहरण के रूप में मदद करता है

एक अपवाद फेंक रहा है, जबकि एक और अपवाद सक्रिय है, परिणामस्वरूप दूसरा अपवाद (दूसरा) अपवाद हो जाएगा।

यहाँ कुछ कोड है जो दिखाता है कि क्या होता है:

  public static void Main(string[] args) { try { try { throw new Exception("first exception"); } finally { //try { throw new Exception("second exception"); } //catch (Exception) { //throw; } } } catch (Exception e) { Console.WriteLine(e); } } 
  • कोड को चलाएं और आप "दूसरा अपवाद" देखेंगे
  • प्रयासों को पकड़ने और बयान को हटा दें और आप "पहला अपवाद" देखेंगे
  • इसके अलावा फेंक को हटा दें; बयान और आप फिर से "दूसरा अपवाद" देखेंगे।

कुछ महीने पहले भी मुझे इस तरह से कुछ का सामना करना पड़ा,

  private void RaiseException(String errorMessage) { throw new Exception(errorMessage); } private void DoTaskForFinally() { RaiseException("Error for finally"); } private void DoTaskForCatch() { RaiseException("Error for catch"); } private void DoTaskForTry() { RaiseException("Error for try"); } try { /*lacks the exception*/ DoTaskForTry(); } catch (Exception exception) { /*lacks the exception*/ DoTaskForCatch(); } finally { /*the result exception*/ DoTaskForFinally(); } 

इस तरह की समस्या को हल करने के लिए मैंने एक उपयोगिता वर्ग की तरह बनाया

 class ProcessHandler : Exception { private enum ProcessType { Try, Catch, Finally, } private Boolean _hasException; private Boolean _hasTryException; private Boolean _hasCatchException; private Boolean _hasFinnallyException; public Boolean HasException { get { return _hasException; } } public Boolean HasTryException { get { return _hasTryException; } } public Boolean HasCatchException { get { return _hasCatchException; } } public Boolean HasFinnallyException { get { return _hasFinnallyException; } } public Dictionary<String, Exception> Exceptions { get; private set; } public readonly Action TryAction; public readonly Action CatchAction; public readonly Action FinallyAction; public ProcessHandler(Action tryAction = null, Action catchAction = null, Action finallyAction = null) { TryAction = tryAction; CatchAction = catchAction; FinallyAction = finallyAction; _hasException = false; _hasTryException = false; _hasCatchException = false; _hasFinnallyException = false; Exceptions = new Dictionary<string, Exception>(); } private void Invoke(Action action, ref Boolean isError, ProcessType processType) { try { action.Invoke(); } catch (Exception exception) { _hasException = true; isError = true; Exceptions.Add(processType.ToString(), exception); } } private void InvokeTryAction() { if (TryAction == null) { return; } Invoke(TryAction, ref _hasTryException, ProcessType.Try); } private void InvokeCatchAction() { if (CatchAction == null) { return; } Invoke(TryAction, ref _hasCatchException, ProcessType.Catch); } private void InvokeFinallyAction() { if (FinallyAction == null) { return; } Invoke(TryAction, ref _hasFinnallyException, ProcessType.Finally); } public void InvokeActions() { InvokeTryAction(); if (HasTryException) { InvokeCatchAction(); } InvokeFinallyAction(); if (HasException) { throw this; } } } 

और इस तरह इस्तेमाल किया

 try { ProcessHandler handler = new ProcessHandler(DoTaskForTry, DoTaskForCatch, DoTaskForFinally); handler.InvokeActions(); } catch (Exception exception) { var processError = exception as ProcessHandler; /*this exception contains all exceptions*/ throw new Exception("Error to Process Actions", exception); } 

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

 public void MyMethod() { try { } catch{} finally { CodeA } CodeB } 

जिस तरह से कोडए और कोडबी द्वारा फेंक दिए गए अपवादों को संभाला जाता है वह वही है।

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

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

चाहे कोई अपवाद नहीं है या नहीं "आखिरकार" ब्लॉक निष्पादित करने की गारंटी है।

  1. अगर प्रयास ब्लॉक में एक अपवाद होने के बाद "अंत में" ब्लॉक निष्पादित किया जा रहा है,

  2. और अगर उस अपवाद का संचालन नहीं किया जाता है

  3. और अगर अंत में ब्लॉक एक अपवाद फेंकता है

फिर कोशिश के ब्लॉक में हुआ मूल अपवाद खो गया है।

 public class Exception { public static void Main() { try { SomeMethod(); } catch (Exception ex) { Console.WriteLine(ex.Message); } } public static void SomeMethod() { try { // This exception will be lost throw new Exception("Exception in try block"); } finally { throw new Exception("Exception in finally block"); } } } 

विवरण के लिए महान लेख

यह एक अपवाद फेंकता है;) आप किसी अन्य कैच क्लॉज में उस अपवाद को पकड़ सकते हैं