मैंने C # 8 के साथ गर्मियों को कैसे बिताया

डॉटनेट एंड मोर ब्लेज़र पॉडकास्ट, नेटकोर 3.0 पूर्वावलोकन, सी # 8 की हालिया रिलीज में और न केवल हमने लापरवाही से सी # 8 जैसे ज्वलंत विषय का उल्लेख किया। सी # 8 के साथ अनुभव के बारे में कहानी इतनी बड़ी नहीं थी कि इसके लिए एक अलग मुद्दा समर्पित किया जा सके, इसलिए इसके साथ एपिस्टरी शैली के साधनों को साझा करने का निर्णय लिया गया।

इस लेख में, मैं 4 महीनों के लिए उत्पादन पर C # 8 का उपयोग करके अपने अनुभव के बारे में बात करना चाहूंगा। नीचे आप निम्नलिखित सवालों के जवाब पा सकते हैं:

• नए C # में "स्पेल" कैसे करें
• क्या विशेषताएं वास्तव में उपयोगी थीं
• क्या निराश?

Microsoft की आधिकारिक प्रलेखन में C # 8 सुविधाओं की एक पूरी सूची पाई जा सकती है। इस लेख में, मैं उन अवसरों को छोड़ दूंगा जिन्हें मैं एक कारण या किसी अन्य के लिए प्रयास नहीं कर सका, अर्थात्:

• पढ़े लिखे सदस्य
• डिफ़ॉल्ट इंटरफ़ेस सदस्य
• डिस्पोजेबल रेफरी संरचना
• अतुल्यकालिक धाराएँ
• संकेत और सीमा

मैं सबसे स्वादिष्ट संभावनाओं में से एक के साथ शुरू करने का प्रस्ताव करता हूं, जैसा कि मुझे पहले लगता था।

भाव बदलें

हमारे सपनों में, हम इस कार्य को काफी आकर्षक ढंग से प्रस्तुत करते हैं:

int Exec(Operation operation, int x, int y) => operation switch { Operation.Summ => x + y, Operation.Diff => x - y, Operation.Mult => x * y, Operation.Div => x / y, _ => throw new NotSupportedException() }; 

लेकिन, दुर्भाग्य से, वास्तविकता अपना समायोजन करती है।
सबसे पहले, स्थितियों के संयोजन की कोई संभावना नहीं है:

  string TrafficLights(Signal signal) { switch (signal) { case Signal.Red: case Signal.Yellow: return "stop"; case Signal.Green: return "go"; default: throw new NotSupportedException(); } } 

व्यवहार में, इसका मतलब है कि आधे मामलों में, कॉपी-पेस्ट से बचने के लिए स्विच अभिव्यक्ति को नियमित स्विच में बदलना होगा।

दूसरे, नया वाक्यविन्यास बयानों का समर्थन नहीं करता है, अर्थात्। कोड जो एक मान नहीं लौटाता है। यह प्रतीत होता है, ठीक है, और यह आवश्यक नहीं है, लेकिन मैं खुद आश्चर्यचकित था जब मुझे एहसास हुआ कि परीक्षणों में जोर देने जैसी चीज के लिए स्विच का उपयोग कितनी बार किया जाता है (पैटर्न मिलान के साथ संयोजन के रूप में)।

तीसरा, स्विच अभिव्यक्ति, जो पिछले पैराग्राफ से अनुसरण करता है, मल्टी-लाइन हैंडलर का समर्थन नहीं करता है। लॉग जोड़ने के समय हम कितना डरावना समझते हैं:

  int ExecFull(Operation operation, int x, int y) { switch (operation) { case Operation.Summ: logger.LogTrace("{x} + {y}", x, y); return x + y; case Operation.Diff: logger.LogTrace("{x} - {y}", x, y); return x - y; case Operation.Mult: logger.LogTrace("{x} * {y}", x, y); return x * y; case Operation.Div: logger.LogTrace("{x} / {y}", x, y); return x / y; default: throw new NotSupportedException(); } } 

मैं यह नहीं कहना चाहता कि नया स्विच खराब है। नहीं, वह अच्छा है, बस बहुत अच्छा नहीं है।

संपत्ति और स्थिति पैटर्न

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

टपल पैटर्न

लेकिन नमूने के साथ तुलना की नई संभावनाओं का "छोटा भाई" एक वास्तविक अच्छी तरह से साबित हुआ। बात यह है कि टुपल पैटर्न को हमारे कोड की परिचित वास्तुकला में किसी भी बदलाव की आवश्यकता नहीं है, यह कुछ मामलों को सरल करता है:

  Player? Play(Gesture left, Gesture right) { switch (left, right) { case (Gesture.Rock, Gesture.Rock): case (Gesture.Paper, Gesture.Paper): case (Gesture.Scissors, Gesture.Scissors): return null; case (Gesture.Rock, Gesture.Scissors): case (Gesture.Scissors, Gesture.Paper): case (Gesture.Paper, Gesture.Rock): return Player.Left; case (Gesture.Paper, Gesture.Scissors): case (Gesture.Rock, Gesture.Paper): case (Gesture.Scissors, Gesture.Rock): return Player.Right; default: throw new NotSupportedException(); } } 

लेकिन सबसे अच्छी बात यह है कि यह फीचर, जो काफी प्रेडिक्टेबल है, Deconstruct मेथड के साथ बढ़िया काम करता है। टुपल पैटर्न की क्षमताओं को स्विच और उपयोग करने के लिए बस एक वर्ग को कार्यान्वित Deconstruct के साथ पास करें।

घोषणाओं का उपयोग करना

यह एक मामूली अवसर प्रतीत होता है, लेकिन यह इतना आनंद लाता है। सभी प्रोमो में, Microsoft नेस्टिंग को कम करने जैसे पहलू के बारे में बात करता है। लेकिन चलो ईमानदार होना चाहिए, इतना नहीं कि मायने रखता है। लेकिन क्या वास्तव में गंभीर कोड के एक ब्लॉक को बाहर करने के दुष्प्रभाव हैं:

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

नतीजतन, घोषणाओं का उपयोग करने के रूप में इस तरह की एक साधारण चीज कोडिंग की भावना को इतना बदल देती है कि आप बस सी # 7.3 पर वापस नहीं आना चाहते हैं।

स्थैतिक स्थानीय कार्य

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

अशक्त संदर्भ प्रकार

और मिठाई के लिए, मैं C # 8 की सबसे महत्वपूर्ण विशेषता का उल्लेख करना चाहूंगा। सच में, अशक्त संदर्भ प्रकारों को पार्स करना एक अलग लेख के योग्य है। मैं सिर्फ संवेदनाओं का वर्णन करना चाहता हूं।

• सबसे पहले, यह अद्भुत है। मैं पहले एक क्षेत्र या संपत्ति को अशक्त घोषित करने के अपने स्पष्ट इरादे का वर्णन कर सकता था, लेकिन अब यह फ़ंक्शन भाषा में बनाया गया है।
• दूसरे, यह NullReferenceException से बिल्कुल भी नहीं बचाता है। और मैं चेतावनी पर कुख्यात "क्लॉगिंग" के बारे में बात नहीं कर रहा हूं। यह सिर्फ इतना है कि रनटाइम में कोई भी आपके लिए कोई अशक्त तर्क जांच नहीं करता है, इसलिए नए ArgumentNullException () जैसे कोड को फेंकने के लिए जल्दी मत करो।
• तीसरा, डीटीओ के साथ एक गंभीर समस्या है। उदाहरण के लिए, आप आवश्यक विशेषता के साथ एक संपत्ति एनोटेट करते हैं। तदनुसार, 100% शून्य संपत्ति वाला कोई ऑब्जेक्ट आपके WebAPI नियंत्रक में नहीं मिलेगा। हालांकि, इस विशेषता और सभी समान विशेषताओं को अशक्त संदर्भ प्रकार की जांच के साथ जोड़ना संभव नहीं है। बात यह है कि यदि आप मानक MyProperty { घोषित करें ; सेट;} एक नोटनुअल प्रकार के साथ एक संपत्ति, आपको एक चेतावनी मिलेगी: "[CS8618] गैर-अशक्त संपत्ति 'MyProperty' असंवैधानिक है। संपत्ति को अशक्त घोषित करने पर विचार करें" । यह काफी उचित है, क्योंकि आप प्रारंभिक प्रक्रिया के दौरान शून्य शब्दार्थ की गारंटी नहीं दे सकते। इस विशेषता का एकमात्र परिणाम किसी भी डीटीओ में अशक्त गुणों का उपयोग करने में असमर्थता है। लेकिन अच्छी खबर है, एक सरल उपाय है - बस अपने क्षेत्र को डिफ़ॉल्ट मान के साथ आरंभ करें:
  

   public string MyProperty { get; set; } = ""; 

• चौथा, ऐसे गुण जो जटिल मामलों को संभालते हैं, जैसे कि ट्राइगेट वेल, खुद काफी जटिल हैं। नतीजतन, यह अत्यधिक संभावना है कि बहुत जागरूक डेवलपर्स ऑपरेटरों (!) का दुरुपयोग नहीं करेंगे, जिससे अशक्त संदर्भ प्रकारों की क्षमताओं को समतल किया जा सकेगा। विश्लेषकों के लिए एक उम्मीद।
• पांचवीं, और सबसे महत्वपूर्ण बात, व्यक्तिगत रूप से इस अवसर ने मुझे NullReferenceException त्रुटियों से पहले ही कई बार बचाया है। यह एक समय की बचत को दर्शाता है - संकलन चरण में बहुत सारी त्रुटियां पकड़ी जाती हैं, और परीक्षण या डिबगिंग नहीं। यह न केवल जटिल व्यावसायिक तर्क को विकसित करने की प्रक्रिया में सच है, बल्कि बाहरी पुस्तकालयों, डीटीओ और अन्य निर्भरताओं के साथ तुच्छ काम के मामले में भी संभवत: अशक्त है।

सारांश

बेशक, प्रस्तुत अवसर एक पूर्ण क्रांति तक नहीं पहुंचते हैं, लेकिन सी # और एफ # स्केल के बीच कम और कम अंतर है। चाहे वह अच्छा हो या बुरा, समय बताएगा।

इस लेख के जारी होने के समय, C # 8 आपके प्रोजेक्ट में पहले ही आ गया होगा, इसलिए मुझे आश्चर्य होगा कि हमारी पसंदीदा भाषा के नए संस्करण के बारे में आपकी क्या भावनाएं हैं?