विजुअल स्टूडियो 2019 पूर्वावलोकन 2 बाहर है! और इसके साथ, एक और अधिक C # 8.0 विशेषताएं आपके लिए प्रयास करने के लिए तैयार हैं। यह ज्यादातर पैटर्न मिलान के बारे में है, हालांकि मैं कुछ अन्य समाचारों और अंत में परिवर्तन पर स्पर्श करूंगा।

अधिक स्थानों में अधिक पैटर्न

जब C # 7.0 ने पैटर्न मिलान का परिचय दिया, तो हमने कहा कि हमें भविष्य में अधिक स्थानों में और अधिक पैटर्न जोड़ने की उम्मीद है। वह समय आ गया है! हम जोड़ रहे हैं जिसे हम पुनरावर्ती पैटर्न कहते हैं, साथ ही switch स्टेटमेंट का एक और अधिक कॉम्पैक्ट अभिव्यक्ति रूप (जिसे आपने अनुमान लगाया है!) स्विच भाव ।

यहाँ हमें शुरू करने के लिए पैटर्न का एक सरल C # 7.0 उदाहरण है:

 class Point { public int X { get; } public int Y { get; } public Point(int x, int y) => (X, Y) = (x, y); public void Deconstruct(out int x, out int y) => (x, y) = (X, Y); } static string Display(object o) { switch (o) { case Point p when pX == 0 && pY == 0: return "origin"; case Point p: return $"({pX}, {pY})"; default: return "unknown"; } } 

भाव बदलें

पहले, आइए देखें कि कई switch स्टेटमेंट वास्तव में case बॉडी के भीतर ज्यादा दिलचस्प काम नहीं करते हैं। अक्सर वे सभी केवल एक मूल्य का उत्पादन करते हैं, या तो इसे एक चर में निर्दिष्ट करके या इसे वापस करके (जैसा कि ऊपर)। उन सभी स्थितियों में, स्विच स्टेटमेंट स्पष्ट रूप से क्लंकी है। ऐसा लगता है कि 5-दशक पुरानी भाषा की विशेषता है, यह बहुत सारे समारोह है।

हमने फैसला किया कि यह switch का एक अभिव्यक्ति रूप जोड़ने का समय था। यहाँ यह उपरोक्त उदाहरण पर लागू होता है:

 static string Display(object o) { return o switch { Point p when pX == 0 && pY == 0 => "origin", Point p => $"({pX}, {pY})", _ => "unknown" }; } 

यहां कई चीजें हैं जो स्विच स्टेटमेंट से बदल गई हैं। आइए उन्हें सूचीबद्ध करें:

• switch कीवर्ड मामलों के परीक्षण मूल्य और {...} सूची के बीच "infix" है। यह अन्य अभिव्यक्तियों के साथ इसे और अधिक संरचित बनाता है, और स्विच स्टेटमेंट से नेत्रहीन रूप से अलग बताने में भी आसान है।
• case कीवर्ड और : को लैम्बडा एरो => संक्षिप्तता के साथ बदल दिया गया है।
• default को संक्षिप्तता के लिए _ त्याग पैटर्न के साथ बदल दिया गया है।
• शरीर भाव हैं! चयनित निकाय का परिणाम स्विच अभिव्यक्ति का परिणाम बन जाता है।

चूंकि एक अभिव्यक्ति के लिए या तो एक मान होना चाहिए या एक अपवाद फेंकना होगा, एक स्विच अभिव्यक्ति जो एक मैच के बिना अंत तक पहुंचती है वह एक अपवाद फेंक देगी। संकलक आपको चेतावनी देने का एक बड़ा काम करता है जब यह मामला हो सकता है, लेकिन आपको सभी स्विच अभिव्यक्तियों को एक कैच-ऑल के साथ समाप्त करने के लिए मजबूर नहीं करेगा: आप बेहतर जान सकते हैं!

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

  static string Display(object o) => o switch { Point p when pX == 0 && pY == 0 => "origin", Point p => $"({pX}, {pY})", _ => "unknown" }; 

ईमानदार होने के लिए, मुझे यकीन नहीं है कि हम यहां क्या स्वरूपण मार्गदर्शन देंगे, लेकिन यह स्पष्ट होना चाहिए कि यह एक बहुत ही कठिन और स्पष्ट है, खासकर क्योंकि संक्षिप्तता आपको आमतौर पर "सारणीबद्ध" फैशन में स्विच को प्रारूपित करने की अनुमति देती है, जैसा कि ऊपर है , एक ही लाइन पर पैटर्न और निकायों के साथ, और => एक दूसरे के नीचे पंक्तिबद्ध हैं।

वैसे, हम सी # में अन्य सभी "अल्पविराम से अलग की गई सूचियों" को रखने के अंतिम मामले के बाद , एक अनुगामी अल्पविराम की अनुमति देने की योजना बनाते हैं, लेकिन पूर्वावलोकन 2 अभी तक इसकी अनुमति नहीं देता है।

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

संक्षिप्तता की बात करें, तो पैटर्न अचानक स्विच अभिव्यक्ति के सबसे भारी तत्व बन गए हैं! चलिए उसके बारे में कुछ करते हैं।

ध्यान दें कि स्विच अभिव्यक्ति प्रकार पैटर्न Point p (दो बार) का उपयोग करती है, साथ ही when पहली स्थिति के लिए अतिरिक्त शर्तों को जोड़ने के लिए एक खंड।

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

 static string Display(object o) => o switch { Point { X: 0, Y: 0 } p => "origin", Point { X: var x, Y: var y } p => $"({x}, {y})", _ => "unknown" }; 

दोनों मामले अभी भी जांचते हैं कि o एक Point । पहला मामला तब निरंतर पैटर्न 0 को X और Y गुणों के लिए पुन: लागू करता है, यह जाँच कर कि क्या उनका वह मूल्य है। इस प्रकार हम इस और कई सामान्य मामलों में खंड को समाप्त कर सकते हैं।

दूसरा मामला X और Y प्रत्येक के लिए var पैटर्न लागू करता है Y स्मरण करो कि C # 7.0 में var पैटर्न हमेशा सफल होता है, और बस मूल्य को धारण करने के लिए एक नया चर घोषित करता है। इस प्रकार x और y में pX और pY के pX मान pY ।

हम कभी भी p उपयोग नहीं करते हैं, और वास्तव में इसे यहां छोड़ सकते हैं:

  Point { X: 0, Y: 0 } => "origin", Point { X: var x, Y: var y } => $"({x}, {y})", _ => "unknown" 

एक बात जो संपत्ति के पैटर्न सहित सभी प्रकार के पैटर्न के बारे में सही है, वह यह है कि उन्हें गैर-अशक्त होने के लिए मूल्य की आवश्यकता होती है। यह "खाली" संपत्ति पैटर्न {} का उपयोग कॉम्पैक्ट "नॉट-नल" पैटर्न के रूप में किया जा रहा है। उदाहरण के लिए, हम निम्नांकित दो मामलों के साथ कमबैक केस को बदल सकते हैं:

  {} => o.ToString(), null => "null" 

{} शेष नॉनबॉल ऑब्जेक्ट्स के साथ काम करता है, और null को null मिलता है, इसलिए स्विच संपूर्ण है और संकलक के माध्यम से गिरने वाले मूल्यों के बारे में शिकायत नहीं करेगा।

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

प्रॉपर्टी पैटर्न ने दूसरे Point मामले को बिल्कुल ठीक नहीं किया है, और वहाँ परेशानी के लायक नहीं लगता है, लेकिन ऐसा अधिक है जो किया जा सकता है।

ध्यान दें कि Point क्लास में एक Deconstruct विधि है, एक तथाकथित डिकंस्ट्रक्टर । C # 7.0 में, deconstructors ने मान को असाइनमेंट पर deconstructed होने दिया, ताकि आप लिख सकें जैसे:

 (int x, int y) = GetPoint(); // split up the Point according to its deconstructor 

C # 7.0 ने पैटर्न के साथ डिकंस्ट्रक्शन को एकीकृत नहीं किया। यह स्थितिगत पैटर्न के साथ बदलता है जो एक अतिरिक्त तरीका है कि हम C # 8.0 में टाइप पैटर्न का विस्तार कर रहे हैं। यदि मिलान प्रकार टपल प्रकार है या इसमें एक डिकंस्ट्रक्टर है, तो हम नाम गुणों के बिना पुनरावर्ती पैटर्न लागू करने के एक कॉम्पैक्ट तरीके के रूप में स्थितीय पैटर्न का उपयोग कर सकते हैं:

 static string Display(object o) => o switch { Point(0, 0) => "origin", Point(var x, var y) => $"({x}, {y})", _ => "unknown" }; 

एक बार जब ऑब्जेक्ट को एक Point रूप में मिलान किया जाता है, तो डिकंस्ट्रक्टर को लागू किया जाता है, और परिणामी मूल्यों पर नेस्टेड पैटर्न लागू होते हैं।

Deconstructors हमेशा उचित नहीं होते हैं। उन्हें केवल उन प्रकारों में जोड़ा जाना चाहिए जहां यह वास्तव में स्पष्ट है कि मूल्यों में से कौन सा है। उदाहरण के लिए, Point क्लास के लिए, यह मान लेना सुरक्षित और सहज है कि पहला मान X और दूसरा Y , इसलिए उपरोक्त स्विच अभिव्यक्ति सहज और पढ़ने में आसान है।

टपल पैटर्न

स्थिति पैटर्न का एक बहुत ही उपयोगी विशेष मामला तब है जब उन्हें टुपल्स पर लागू किया जाता है। यदि स्विच स्टेटमेंट को सीधे टुपल एक्सप्रेशन पर लागू किया जाता है, तो हम कोष्ठक के अतिरिक्त सेट को छोड़ने की अनुमति भी देते हैं, जैसे switch (x, y, z) बजाय switch ((x, y, z)) ।

एक ही समय में इनपुट के कई टुकड़ों का परीक्षण करने के लिए ट्यूपल पैटर्न महान हैं। यहाँ एक राज्य मशीन का सरल कार्यान्वयन है:

 static State ChangeState(State current, Transition transition, bool hasKey) => (current, transition) switch { (Opened, Close) => Closed, (Closed, Open) => Opened, (Closed, Lock) when hasKey => Locked, (Locked, Unlock) when hasKey => Closed, _ => throw new InvalidOperationException($"Invalid transition") }; 

बेशक जब हम hasKey के उपयोग के बजाय स्विच-ऑन ट्यूपल में hasKey को शामिल करने का विकल्प चुन सकते हैं - यह वास्तव में स्वाद की बात है:

 static State ChangeState(State current, Transition transition, bool hasKey) => (current, transition, hasKey) switch { (Opened, Close, _) => Closed, (Closed, Open, _) => Opened, (Closed, Lock, true) => Locked, (Locked, Unlock, true) => Closed, _ => throw new InvalidOperationException($"Invalid transition") }; 

सभी में मुझे आशा है कि आप देख सकते हैं कि पुनरावर्ती पैटर्न और स्विच अभिव्यक्तियां स्पष्ट और अधिक घोषित कार्यक्रम तर्क को जन्म दे सकती हैं।

अन्य C # 8.0 पूर्वावलोकन 2 में सुविधाएँ

जबकि वीएस 2019 पूर्वावलोकन 2 में ऑनलाइन आने के लिए पैटर्न विशेषताएं प्रमुख हैं, कुछ छोटे हैं जो मुझे आशा है कि आपको उपयोगी और मजेदार भी मिलेंगे। मैं यहाँ विवरण में नहीं जाऊंगा, लेकिन आपको प्रत्येक का संक्षिप्त विवरण दूंगा।

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

सी # में, बयानों using हमेशा घोंसले के शिकार का स्तर होता है, जो अत्यधिक कष्टप्रद और पठनीयता को चोट पहुंचा सकता है। उन साधारण मामलों के लिए जहां आप बस एक संसाधन को एक दायरे के अंत में साफ करना चाहते हैं, अब आप इसके बजाय घोषणाओं का उपयोग कर रहे हैं। घोषणाओं का उपयोग करना सामने वाले कीवर्ड using बस स्थानीय परिवर्तनशील घोषणाएं हैं, और उनकी सामग्री वर्तमान स्टेटमेंट ब्लॉक के अंत में निपटा दी जाती है। इसलिए इसके बजाय:

 static void Main(string[] args) { using (var options = Parse(args)) { if (options["verbose"]) { WriteLine("Logging..."); } ... } // options disposed here } 

आप बस लिख सकते हैं

 static void Main(string[] args) { using var options = Parse(args); if (options["verbose"]) { WriteLine("Logging..."); } } // options disposed here 

डिस्पोजेबल रेफरी संरचना

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

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

यदि आप यह सुनिश्चित करना चाहते हैं कि आपका स्थानीय फ़ंक्शन एन्कोडिंग स्कोप से "कैप्चरिंग" (संदर्भित) चर से जुड़ी रनटाइम लागत को लाइक नहीं करता है, तो आप इसे static घोषित कर सकते हैं। तब कंपाइलर संलग्न कार्यों में घोषित किसी भी चीज़ के संदर्भ को रोक देगा - अन्य स्थिर स्थानीय कार्यों को छोड़कर!

पूर्वावलोकन 1 के बाद से परिवर्तन

पूर्वावलोकन 1 की मुख्य विशेषताएं अशक्त संदर्भ प्रकार और एसिंक्स धाराएँ थीं। दोनों पूर्वावलोकन 2 में थोड़ा विकसित हुए हैं, इसलिए यदि आपने उनका उपयोग करना शुरू कर दिया है, तो निम्नलिखित के बारे में पता होना अच्छा है।

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

हमने स्रोत ( #nullable और #pragma warning निर्देशों) के माध्यम से और परियोजना स्तर पर दोनों को #nullable चेतावनी को नियंत्रित करने के लिए और विकल्प जोड़े हैं। हमने प्रोजेक्ट फ़ाइल ऑप्ट-इन को <NullableContextOptions>enable</NullableContextOptions> भी बदल दिया है।

Async धाराओं

हमने IAsyncEnumerable<T> का आकार बदल दिया IAsyncEnumerable<T> इंटरफ़ेस कंपाइलर की अपेक्षा है! यह .NET कोर 3.0 पूर्वावलोकन 1 में दिए गए इंटरफ़ेस के साथ कंपाइलर को सिंक से बाहर लाता है, जिससे आपको कुछ परेशानी हो सकती है। हालाँकि, .NET Core 3.0 पूर्वावलोकन 2 शीघ्र ही समाप्त होने वाला है, और इससे इंटरफेस सिंक में वापस आ जाता है।

इस पर है!

हमेशा की तरह, हम आपकी प्रतिक्रिया के लिए उत्सुक हैं! कृपया विशेष रूप से नए पैटर्न की विशेषताओं के साथ खेलें। क्या आप ईंट की दीवारों में चलते हैं? कुछ कष्टप्रद है? आपके लिए कुछ शांत और उपयोगी परिदृश्य क्या हैं? प्रतिक्रिया बटन दबाएं और हमें बताएं!

हैप्पी हैकिंग

Mads Torgersen, C # के लिए डिज़ाइन लीड