📨 🚆 👩🏻‍🤝‍👨🏼 सी # 8 और शून्य वैधता। हम इसके साथ कैसे रहते हैं 🛃 👏 😻

नमस्ते सहयोगियों! यह उल्लेख करने का समय है कि हमारे पास C # 8 पर इयान ग्रिफिथ्स की मौलिक पुस्तक जारी करने की योजना है :

इस बीच, अपने ब्लॉग पर, लेखक ने दो संबंधित लेख प्रकाशित किए हैं जिसमें वह नई घटनाओं की बारीकियों जैसे कि अशक्तता, अशक्तता और अशक्तता पर विचार करता है। हमने दोनों लेखों का एक शीर्षक के तहत अनुवाद किया है और उनके बारे में चर्चा करने का सुझाव दिया है।

C # 8.0 में सबसे महत्वाकांक्षी नई सुविधा को अशक्त संदर्भ कहा जाता है ।

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

शून्य मानने में क्या गलत है? ऐसी दुनिया में जहां कोई भी लिंक शून्य पर इंगित हो सकता है, आपको इस पर विचार करना होगा कि आपके कोड में किसी भी लिंक का उपयोग किया जाता है, अन्यथा आप रनटाइम पर मना किए जाने का जोखिम उठाते हैं। कभी-कभी यह बहुत बोझ नहीं होता है; यदि आप एक चर newको उसी स्थान पर अभिव्यक्ति के साथ आरंभ करते हैं जहां आप इसे घोषित करते हैं, तो आप जानते हैं कि यह चर शून्य के बराबर नहीं है। लेकिन यहां तक कि इस तरह के एक सरल उदाहरण को कुछ संज्ञानात्मक भार से भरा हुआ है: सी # 8 की रिहाई से पहले, कंपाइलर आपको यह नहीं बता सकता है कि क्या आप कुछ भी कर रहे हैं जो इस मान को परिवर्तित कर सकता है null। लेकिन, जैसे ही आप कोड के विभिन्न टुकड़ों को सिलाई करना शुरू करते हैं, इस तरह की चीजों के बारे में निश्चितता के साथ न्याय करना अधिक कठिन हो जाता है: यह कैसे संभव है कि यह संपत्ति जिसे मैं अभी पढ़ रहा हूं, वह वापस आ सकती है null? क्या इसे प्रसारित करने की अनुमति हैnullउस विधि में? किन स्थितियों में मुझे यकीन हो सकता है कि मैं जिस पद्धति को बुला रहा हूं वह इस तर्क को outनहीं null, बल्कि एक अलग मूल्य पर सेट करेगी ? इसके अलावा, यह मामला ऐसी चीजों की जाँच करने के लिए याद करने तक सीमित नहीं है; यह पूरी तरह से स्पष्ट नहीं है कि यदि आप शून्य में चलते हैं तो आपको क्या करना चाहिए।

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

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

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

हालाँकि, जैसे ही आप इस नई सुविधा को सक्षम करते हैं - सब कुछ बदल जाता है। इसे सक्रिय करने का सबसे आसान तरीका <Nullablegt;enable</Nullablegt;तत्व के अंदर इसे जोड़ना है ।<PropertyGroup>आपकी फ़ाइल में .csproj। (मैं ध्यान देता हूं कि अधिक फिलिग्री नियंत्रण भी उपलब्ध है। यदि आपको वास्तव में इसकी आवश्यकता है, तो आप nullप्रत्येक पंक्ति में अनुमति दी जाने वाले व्यवहार को कॉन्फ़िगर कर सकते हैं । लेकिन, जब हमने हाल ही में अपनी सभी परियोजनाओं में इस सुविधा को शामिल करने का फैसला किया, तो यह पता चला कि यह एक पैमाने पर सक्रिय होगा। एक समय में एक परियोजना एक उल्लेखनीय कार्य है।)

जब सी # 8.0 में अनुमेय लिंक nullपूरी तरह से सक्रिय होते हैं, तो स्थिति बदल जाती है: अब डिफ़ॉल्ट रूप से यह माना जाता है कि लिंक केवल शून्य की अनुमति नहीं देते हैं यदि आप खुद को विपरीत निर्दिष्ट नहीं करते हैं, बिल्कुल महत्वपूर्ण प्रकारों के साथ ( यहां तक कि सिंटैक्स भी समान है: आप इंट लिख सकते हैं ?, यदि आप वास्तव में पूर्णांक मूल्य वैकल्पिक होना चाहते थे। अब आप स्ट्रिंग लिखते हैं ?, यदि आपका मतलब है कि आप एक स्ट्रिंग के लिए लिंक चाहते हैं या?null।)

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

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

सी # 8.0 अनुमेय लिंक शुरू करने की प्रक्रिया को सुचारू करता है null, क्योंकि यह आपको इस सुविधा को धीरे-धीरे पेश करने की अनुमति देता है। किसी को हां या ना पसंद करने की जरूरत नहीं है। यह async/awaitC # 5.0 में जोड़े गए फीचर से काफी अलग है , जो फैलने की ओर अग्रसर है: वास्तव में, अतुल्यकालिक ऑपरेशन कॉल करने के लिए बाध्य करते हैंasync, और इसलिए, इस कॉलर को कॉल करने वाला कोड होना चाहिए async, और इसी तरह, ढेर के शीर्ष पर। सौभाग्य से, प्रकार जो अनुमति देते nullहैं अलग तरीके से निर्मित होते हैं: उन्हें चुनिंदा और धीरे-धीरे लागू किया जा सकता है। यदि आवश्यक हो, तो आप फ़ाइलों को एक-एक करके या यहां तक कि लाइन द्वारा लाइन में काम कर सकते हैं।

अनुमति देने वाले प्रकारों का सबसे महत्वपूर्ण पहलूnull(धन्यवाद जिसके लिए उन्हें संक्रमण सरल बनाया गया है), यह है कि डिफ़ॉल्ट रूप से वे अक्षम हैं। अन्यथा, अधिकांश डेवलपर्स C # 8.0 का उपयोग करने से इनकार कर देंगे, क्योंकि इस तरह के संक्रमण से लगभग किसी भी कोड आधार में चेतावनी का कारण होगा। हालाँकि, उन्हीं कारणों से, इस नई सुविधा का उपयोग करने के लिए प्रवेश सीमा अधिक महसूस होती है: यदि कोई नई सुविधा ऐसे नाटकीय परिवर्तन करती है, जो डिफ़ॉल्ट रूप से अक्षम है, तो आप शायद इसके साथ खिलवाड़ नहीं करना चाहते, लेकिन इसमें स्विच करने से जुड़ी समस्याएं हैं हमेशा अनावश्यक परेशानी प्रतीत होगी। लेकिन यह एक शर्म की बात होगी, क्योंकि यह सुविधा बहुत मूल्यवान है। यह उपयोगकर्ताओं को आपके लिए करने से पहले कोड में कीड़े खोजने में मदद करता है।

इसलिए, यदि आप उन प्रकारों को शुरू करने पर विचार कर रहे हैं जो अनुमति देते हैंnull, ध्यान दें कि आप इस सुविधा को चरण दर चरण प्रस्तुत कर सकते हैं।

चेतावनी केवल

एक सरल पर / बंद के बाद पूरे प्रोजेक्ट पर नियंत्रण का सबसे कठोर स्तर है, जो एनोटेशन की परवाह किए बिना चेतावनी को सक्रिय करने की क्षमता है। उदाहरण के लिए, यदि मैं पूरी तरह से Corvus.ContentHandling.Json को हमारे Corvus.ContentHandling रिपॉजिटरी में पूरी तरह से सक्षम करता हूं <Nullablegt;enable</Nullablegt;, तो प्रोजेक्ट फ़ाइल में संपत्तियों के समूह को जोड़ दें, तो इसके वर्तमान में संकलक से 20 चेतावनी तुरंत दिखाई देंगी। हालांकि, अगर मैं इसके बजाय इसका उपयोग करता हूं, तो मुझे <Nullablegt;warnings</Nullablegt;सिर्फ एक चेतावनी मिलेगी।

लेकिन रुकें! मुझे कम चेतावनी क्यों दिखाई जाएगी? अंत में, यहाँ मैंने सिर्फ चेतावनी के लिए कहा। इस सवाल का जवाब पूरी तरह से स्पष्ट नहीं है: तथ्य यह है कि कुछ चर और अभिव्यक्तियां nullअशक्त हो सकती हैं।

नल निष्पक्षता

C # शून्य वैधता की दो व्याख्याओं का समर्थन करती है। सबसे पहले, एक संदर्भ प्रकार के किसी भी चर को स्वीकार करने या स्वीकार नहीं करने के रूप में घोषित किया जा सकता है null, और दूसरी बात, संकलक nullजब भी संभव हो तार्किक रूप से निष्कर्ष निकालेगा कि क्या यह चर कोड में किसी विशेष बिंदु पर हो सकता है या नहीं । यह लेख केवल पहली किस्म की स्वीकार्यता से संबंधित हैnull, यह है कि, एक स्थिर प्रकार के चर के बारे में (वास्तव में, यह न केवल चर और मापदंडों और क्षेत्रों को आत्मा में उनके करीब लागू होता है, दोनों स्थिर और तार्किक रूप से स्वीकार्य स्वीकार्यता nullप्रत्येक अभिव्यक्ति के लिए C # में निर्धारित होती है। वास्तव में, nullइसकी पहली समझ में स्वीकार्यता । , जिस पर हम विचार कर रहे हैं वह टाइप सिस्टम का विस्तार है।

हालांकि, यह पता चला है कि यदि हम केवल एक प्रकार के लिए अशक्तता पर ध्यान केंद्रित करते हैं, तो स्थिति उतनी सुसंगत नहीं होगी जितनी कि कोई मान लेगा। यह "अशक्त वैधता" और "अमान्य" के बीच एक विपरीत नहीं हैnull"। वास्तव में, दो और संभावनाएं हैं। "अज्ञात" की एक श्रेणी है, जो जेनरिक की उपलब्धता के कारण अनिवार्य है; यदि आपके पास असीमित प्रकार का पैरामीटर है, तो इसके लिए वैधता के बारे में कुछ भी पता लगाना संभव नहीं होगा null: उपयुक्त सामान्यीकृत विधि या प्रकार का उपयोग करके कोड उन में एक तर्क स्थानापन्न कर सकता है, या तो अनुमति दे रहा है या अनुमति नहीं दे रहा है null। आप प्रतिबंध जोड़ सकते हैं, लेकिन अक्सर ऐसे प्रतिबंध अवांछनीय होते हैं, क्योंकि वे सामान्यीकृत प्रकार या विधि के दायरे को कम करते हैं। तो, कुछ असीमित प्रकार के मापदंडों के चर या अभिव्यक्तियों के लिए, Tशून्य की गैर-वैधता अज्ञात होनी चाहिए; शायद, प्रत्येक मामले में, स्वीकार्यता का सवालnullयह उनके लिए अलग से तय किया जाएगा, लेकिन हमें पता नहीं है कि जेनेरिक कोड में कौन सा विकल्प दिखाई देगा, क्योंकि यह टाइप तर्क पर निर्भर करेगा।

बाद की श्रेणी को "तटस्थ" कहा जाता है। "तटस्थता" के सिद्धांत से, सी # 8.0 के आगमन से पहले सब कुछ काम किया, और यह काम करेगा यदि आप अशक्त लिंक के साथ काम करने की क्षमता को सक्रिय नहीं करते हैं। (मूल रूप से, यह प्रतिगामीता का एक उदाहरण है । हालांकि, नल तटस्थता के विचार को पहली बार सी # 8.0 में कोड की एक प्राकृतिक अवस्था के रूप में पेश किया गया था, लिंक के लिए अशक्तता को सक्रिय करने से पहले, सी # डिजाइनरों ने जोर देकर कहा कि यह संपत्ति कभी भी सी # के लिए विदेशी नहीं थी।)

शायद आपको यह समझाने की ज़रूरत नहीं है कि इस मामले में "तटस्थता" का क्या मतलब है, क्योंकि यह इस नस में था कि सी # हमेशा काम करता है, इसलिए आप खुद को सब कुछ समझते हैं ... हालांकि, शायद, यह थोड़ा बेईमानी है। तो सुनो: एक ऐसी दुनिया में जहां इसे स्वीकार्यता के बारे में जाना जाता है null, null-उत्तरीय अभिव्यक्तियों की सबसे महत्वपूर्ण विशेषता यह है कि वे अशक्तता के बारे में चेतावनी का कारण नहीं बनती हैं। आप एक अशक्त-अभिव्यक्ति को एक स्वीकार्य nullचर के रूप में असाइन कर सकते हैं , लेकिन स्वीकार्य नहीं। Null-अनुशासनीय चर (साथ ही गुण, क्षेत्र इत्यादि), आप उन अभिव्यक्तियों को निर्दिष्ट कर सकते हैं जो संकलक को "संभव null" या " सही " माना जाता है null।

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

फिर, मुझे चेतावनी क्यों मिलनी चाहिए? एक सामान्य कारण यह है कि दोस्तों को अस्वीकार्य तरीके से कोड के दो टुकड़ों को बनाने की कोशिश के कारण जो खाते में लेते हैं null। उदाहरण के लिए, मान लीजिए कि मेरे पास एक पुस्तकालय है जहां अनुमेय लिंक पूरी तरह से शामिल हैं null, और इस पुस्तकालय में निम्नलिखित गहरी वर्ग है:

public static class NullableAwareClass
	{
	    public static string? GetNullable() => DateTime.Now.Hour > 12 ? null : "morning";
	

	    public static int RequireNonNull(string s) => s.Length;
	}

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

static int UseString(string x) => NullableAwareClass.RequireNonNull(x);

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

इस आवरण के साथ, मैंने वास्तव में इस तथ्य को छिपाया कि कोड वैधता को ध्यान में रखता है null। इसका मतलब है कि अब मैं इस तरह लिख सकता हूं:

	int x = UseString(NullableAwareClass.GetNullable());

कंपाइलर जानता है कि यह क्या GetNullableवापस आ सकता है null, लेकिन चूंकि मैंने एक अशक्त-तटस्थ पैरामीटर के साथ विधि को बुलाया, प्रोग्राम को यह नहीं पता कि यह सही है या गलत। null-Neutral आवरण का उपयोग करके , मैंने संकलक को निरस्त्र कर दिया, जो अब यहां एक समस्या नहीं देखता है। हालाँकि, अगर मैंने इन दोनों विधियों को सीधे जोड़ दिया, तो सब कुछ अलग होगा:

int y = NullableAwareClass.RequireNonNull(NullableAwareClass.GetNullable());

यहां मैं GetNullableसही परिणाम पास करता हूं RequireNonNull। अगर मैंने इसे एक संदर्भ में करने की कोशिश की, जहां अशक्त धारणाएं सक्षम हैं, तो कंपाइलर एक चेतावनी उत्पन्न करेगा, चाहे मैं संबंधित एनोटेशन के संदर्भ को चालू या बंद कर दूं। इस विशेष मामले में, एनोटेशन के संदर्भ में कोई फर्क नहीं पड़ता, क्योंकि एक संदर्भ प्रकार के साथ कोई घोषणाएं नहीं हैं। यदि आप अशक्त की धारणा के बारे में चेतावनी को सक्षम करते हैं, लेकिन संबंधित एनोटेशन को अक्षम करते हैं, तो सभी घोषणाएं nullतटस्थ हो जाएंगी , हालांकि, इसका मतलब यह नहीं है कि सभी अभिव्यक्तियां ऐसी हो जाती हैं। इसलिए, हम जानते हैं कि परिणाम GetNullableशून्य है। इसलिए, हमें एक चेतावनी मिलती है।

सारांश: अक्षम घोषणाओं के संदर्भ में सभी घोषणाएँ जो अनुमति देती nullहैंnull-नेटरल, हमें बहुत सी चेतावनियां नहीं मिलीं, क्योंकि ज्यादातर एक्सप्रेशंस null-ऑनट्रल होंगे। लेकिन कंपाइलर अभी भी nullउन मामलों में धारणा से संबंधित त्रुटियों को पकड़ने में सक्षम होगा, जब अभिव्यक्तियाँ कुछ अशक्त-तटस्थ-तटस्थ से नहीं गुजरती हैं। इसके अलावा, इस मामले में सबसे बड़ा लाभ .उदाहरण के लिए, उपयोग करने के लिए संभावित अशक्त मूल्यों को रोकने के प्रयासों से जुड़ी त्रुटियों का पता लगाने से होगा :

int z = NullableAwareClass.GetNullable().Length;

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

संपूर्ण प्रोजेक्ट का क्रमिक एनोटेशन

जब आप पहला कदम उठाते हैं - बस चेतावनियों को सक्रिय करें, तो आप एनोटेशन के क्रमिक सक्रियण, फ़ाइल द्वारा फ़ाइल के लिए आगे बढ़ सकते हैं। उन्हें पूरी परियोजना में तुरंत शामिल करना सुविधाजनक है, देखें कि कौन सी फाइलें चेतावनी में दिखाई देती हैं - और फिर एक ऐसी फ़ाइल का चयन करें जिसमें अपेक्षाकृत कम चेतावनी हो। फिर से, उन्हें पूरी परियोजना के स्तर पर बंद करें, और आपके द्वारा चुनी गई फ़ाइल के शीर्ष पर लिखें #nullable enable। यह nullपूरी फ़ाइल में धारणा (चेतावनी के लिए और एनोटेशन दोनों के लिए) को पूरी तरह से सक्षम करेगा (जब तक कि आप उन्हें किसी अन्य उद्देश्य के लिए फिर से बंद न करें#nullable) तब आप पूरी फ़ाइल के माध्यम से जा सकते हैं और सुनिश्चित कर सकते हैं कि सभी निकाय जो कि अशक्त होने की संभावना है, को अनुमति के रूप में एनोटेट किया जाता है null(यानी, जोड़ें ?), और फिर इस फ़ाइल में चेतावनी के साथ व्यवहार करें, यदि कोई भी रहता है।

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

ऐसे समय होते हैं जब समस्याओं को इतने सरल तरीके से हल नहीं किया जा सकता है। इसलिए, क्रमांकन से संबंधित कुछ परिदृश्यों में (उदाहरण के लिए, Json.NET या Entity फ्रेमवर्क का उपयोग करते समय), काम अधिक कठिन हो सकता है। मुझे लगता है कि यह समस्या एक अलग लेख की हकदार है।

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

सी # 8 और शून्य वैधता। हम इसके साथ कैसे रहते हैं

More articles: