बिल्कुल उसी कोड के साथ पकड़ ब्लॉक मर्ज करें?

Question

मैं कोड पुन: उपयोग के कारणों के लिए निम्न कोड में पकड़ ब्लॉक मर्ज करना चाहते हैं:

try 
{ 
    DoSomeInputOutput(); 
} 
catch (InvalidOperationException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (InvalidDataException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentNullException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentOutOfRangeException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (ArithmeticException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (InvalidCastException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (Exception ex) 
{ 
    HandleUnknownException(ex); 
} 

कुछ इस तरह हैं:

try 
{ 
    DoSomeInputOutput(); 
} 
catch (InvalidOperationException ex) 
catch (InvalidDataException ex) 
catch (ArgumentNullException ex) 
{ 
    HandleKnownException1(ex); 
} 
catch (ArgumentOutOfRangeException ex) 
catch (ArithmeticException ex) 
catch (InvalidCastException ex) 
{ 
    HandleKnownException2(ex); 
} 
catch (Exception ex) 
{ 
    HandleUnknownException(ex); 
} 

कि संभव किसी भी तरह है?

धन्यवाद।

Answer 1

नहीं (या कम से कम: जब तक आप समूह को समूह को अपनाना नहीं चाहते हैं तब तक उस समूह के लिए विशिष्ट आधार-वर्ग साझा करने के लिए, जो वे आपके उदाहरण में नहीं हैं); इस परिदृश्य में आप केवल एक ही चीज कर सकते हैं catch (Exception ex) और ex पर रनटाइम परीक्षण करें। जब तक आप ऐसा कर चुके हैं, तो मुझे उम्मीद है कि आपका कोड पहले से ही "सुंदर" जैसा है (क्योंकि, महत्वपूर्ण बात यह है कि आपने पहले से ही एक विधि में हैंडलिंग कोड को दोबारा प्रतिक्रिया दी है)।

मैं रिक्ति बदलाव करने तो मैं महत्वपूर्ण कोड पर ध्यान केंद्रित कर सकते हैं परीक्षा होगी:

try 
{ 
    DoSomeInputOutput(); 
} 
// blah humorous scenario 1 
catch (InvalidOperationException ex) { HandleKnownException1(ex); } 
catch (InvalidDataException ex) { HandleKnownException1(ex); } 
catch (ArgumentNullException ex) { HandleKnownException1(ex); } 
// blah whimsical scenario 2 
catch (ArgumentOutOfRangeException ex) { HandleKnownException2(ex); } 
catch (ArithmeticException ex) { HandleKnownException2(ex); } 
catch (InvalidCastException ex) { HandleKnownException2(ex); } 
// unexpected comedy 
catch (Exception ex) { HandleUnknownException(ex); } 

(या कुछ और)।

कुछ तरीकों से यह इस प्रश्न में भी संबंध रखता है: switch/pattern matching idea।

Answer 2

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

Answer 3

संभवतः, आप इसे एक से अधिक स्थानों पर करते हैं। यदि हां, तो आप ऐसा क्यों नहीं करते:

{ 
    DoSomeInputOutput(); 
} 
catch (Exception ex) 
{ 
    HandleInputException(ex); 
} 

void HandleInputException(Exception ex) 
{ 
    if (ex is InvalidOperationException || ex is InvalidDataException || ex is ArgumentNullException) 
    { 
    HandleKnownException1 (ex); 
    } 
    else if ... 
    else if ... 
}