C # आपको 'अशक्त' करने की अनुमति क्यों देता है?

Question 1

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

इसकी अनुमति क्यों है?

throw null;

इस स्निपेट में, शुक्र है कि 'पूर्व' अशक्त नहीं है, लेकिन क्या यह कभी हो सकता है?

try
{
  throw null;
}
catch (Exception ex)
{
  //can ex ever be null?

  //thankfully, it isn't null, but is
  //ex is System.NullReferenceException
}

Question 2

क्योंकि भाषा विनिर्देश System.Exceptionवहाँ प्रकार की अभिव्यक्ति की उम्मीद करता है (इसलिए, nullउस संदर्भ में एक मान्य है) और इस अभिव्यक्ति को गैर-अशक्त होने के लिए प्रतिबंधित नहीं करता है। सामान्य तौर पर, ऐसा कोई तरीका नहीं है जिससे यह पता लगाया जा सके कि उस अभिव्यक्ति का मूल्य है nullया नहीं। यह रुकने की समस्या को हल करना होगा। रनटाइम को nullवैसे भी मामले से निपटना होगा । देख:

Exception ex = null;
if (conditionThatDependsOnSomeInput) 
    ex = new Exception();
throw ex;

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

_{अस्वीकरण (इससे पहले कि मैं एरिक लिपर्ट द्वारा थप्पड़ मारा जाता हूं): इस डिजाइन निर्णय के पीछे तर्क के बारे में मेरी अपनी अटकलें हैं। बेशक, मैं डिजाइन मीटिंग में नहीं गया हूं;)}

आपके दूसरे प्रश्न का उत्तर, कि क्या कैच क्लॉज़ के भीतर एक अभिव्यक्ति चर पकड़ा जा सकता है, कभी भी अशक्त हो सकता है: जबकि C # विनिर्देश इस बारे में चुप है कि क्या अन्य भाषाएं nullप्रचारित करने के लिए अपवाद का कारण बन सकती हैं , यह इस तरह परिभाषित करता है कि अपवाद प्रचारित हैं:

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

के लिए null, बोल्ड स्टेटमेंट गलत है। इसलिए, जबकि विशुद्ध रूप से सी # कल्पना कहती है, हम यह नहीं कह सकते कि अंतर्निहित रनटाइम कभी भी अशक्त नहीं होगा, हम यह सुनिश्चित कर सकते हैं कि अगर ऐसा है, तो भी यह केवल सामान्य catch {}क्लॉज द्वारा नियंत्रित किया जाएगा ।

सीएलआई पर C # कार्यान्वयन के लिए, हम ECMA 335 विनिर्देश का उल्लेख कर सकते हैं। वह दस्तावेज़ सभी अपवादों को परिभाषित करता है कि सीएलआई आंतरिक रूप से फेंकता है (जिनमें से कोई भी नहीं null) और उल्लेख करता है कि उपयोगकर्ता द्वारा परिभाषित अपवाद ऑब्जेक्ट्स को throwनिर्देश द्वारा फेंक दिया गया है । उस निर्देश का विवरण वस्तुतः C # throwकथन के समान है (सिवाय इसके कि वह वस्तु के प्रकार को प्रतिबंधित न करे System.Exception):

विवरण:

throwअनुदेश अपवाद वस्तु (प्रकार फेंकता Oस्टैक पर) और ढेर खाली। अपवाद तंत्र के विवरण के लिए, विभाजन I देखें।
[नोट: जबकि सीएलआई किसी भी वस्तु को फेंकने की अनुमति देता है, सीएलएस एक विशिष्ट अपवाद वर्ग का वर्णन करता है जिसका उपयोग भाषा अंतर के लिए किया जाएगा। नोट नोट]

अपवाद:

System.NullReferenceExceptionअगर फेंक दिया जाता है objहै null।

शुद्धता:

सही CIL यह सुनिश्चित करता है कि ऑब्जेक्ट हमेशा या तो nullऑब्जेक्ट रेफ़रेंस (यानी, प्रकार का O) हो।

मेरा मानना है कि ये निष्कर्ष निकालने के लिए पर्याप्त हैं अपवाद कभी नहीं पकड़े गए हैं null।

Question 3

जाहिर है, आप अशक्त फेंक सकते हैं, लेकिन यह अभी भी कहीं अपवाद में बदल गया है।

nullएक (पूरी तरह से असंबंधित) अशक्त संदर्भ अपवाद में एक वस्तु परिणाम फेंकने का प्रयास ।

यह पूछना कि आपको फेंकने की अनुमति क्यों nullहै, यह पूछना कि आपको ऐसा करने की अनुमति क्यों है:

object o = null;
o.ToString();

Question 4

यहाँ से लिया गया :

यदि आप इस अभिव्यक्ति का उपयोग अपने C # कोड में करते हैं तो यह NullReferenceException को फेंक देगा। ऐसा इसलिए है क्योंकि फेंक-स्टेटमेंट को इसके एकल पैरामीटर के रूप में अपवाद की वस्तु की आवश्यकता है। लेकिन यह बहुत ही वस्तु मेरे उदाहरण में शून्य है।

Question 5

हालांकि C # में null को फेंकना संभव नहीं हो सकता है क्योंकि थ्रो उस का पता लगा लेगा और इसे NullReferenceException में बदल देगा, यह null प्राप्त करना संभव है ... मैं अभी वह प्राप्त कर रहा हूं, जो मेरे कैच का कारण बनता है (जो नहीं था एक अशक्त संदर्भ अपवाद का अनुभव करने के लिए 'पूर्व' अशक्त होने की उम्मीद करना, जिसके परिणामस्वरूप मेरा ऐप मर जाता है (क्योंकि यह आखिरी कैच था)।

इसलिए, जब हम C # से नल नहीं फेंक सकते, तो netherworld null को फेंक सकता है, इसलिए इसे प्राप्त करने के लिए आपका सबसे बाहरी कैच (अपवाद पूर्व) बेहतर होगा। सिर्फ आपकी जानकारी के लिए।

Question 6

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

Question 7

जवाब देने की कोशिश कर रहा है "..अचानक 'पूर्व' शून्य नहीं है, लेकिन क्या यह कभी हो सकता है?"

चूँकि हम यकीनन ऐसे अपवादों को नहीं फेंक सकते जो कि अशक्त है, एक कैच क्लॉज को भी एक अपवाद नहीं पकड़ना पड़ेगा जो कि अशक्त हो। इस प्रकार, पूर्व कभी भी अशक्त नहीं हो सकता है।

अब मैं देखता हूं कि यह प्रश्न वास्तव में पहले से ही पूछा गया है ।

Question 8

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

निश्चित नहीं है कि यह वास्तव में क्या हो रहा है, लेकिन यह घटना की व्याख्या करता है।

यह सच है (और मुझे लगता है कि एक बेहतर तरीका से बाहर निकलना करने के लिए शून्य से कम हो सकता है नहीं लगता है;), इसका मतलब यह है कि पूर्व संभवत: अशक्त नहीं हो सकता है।

Question 9

पुराने c # में:

इस वाक्यविन्यास पर विचार करें:

public void Add<T> ( T item ) => throw (hashSet.Add ( item ) ? null : new Exception ( "The item already exists" ));

मुझे लगता है कि यह इससे छोटा है:

public void Add<T> ( T item )
{
    if (!hashSet.Add ( item ))
        throw new Exception ( "The item already exists" );
}