C # 8.0 में पैटर्न के साथ अधिक सुविधाएँ

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

यह लेख अंग्रेजी में है।

हमारे MSP, लेव बुलानोव का अनुवाद करने के लिए धन्यवाद।

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

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

आरंभ करने के लिए, यहाँ 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"; } } 

भाव बदलें

सबसे पहले, ध्यान दें कि कई स्विच अभिव्यक्तियाँ, वास्तव में, मामले निकायों में बहुत दिलचस्प काम नहीं करते हैं। अक्सर वे सभी बस एक मूल्य बनाते हैं, या तो इसे एक चर में निर्दिष्ट करके या इसे वापस करके (जैसा कि ऊपर बताया गया है)। इन सभी स्थितियों में, स्विच जगह से बाहर होने लगता है। यह एक पचास वर्षीय भाषा की विशेषता के समान है।

हमने तय किया कि स्विच स्टेटमेंट फॉर्म जोड़ने का समय आ गया है। यह नीचे दिए गए उदाहरण पर लागू होता है:

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

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

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

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

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

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

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

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

पैटर्न के गुण

संक्षिप्तता की बात करें, तो पैटर्न अचानक पसंद भाव के सबसे कठिन तत्व बन जाते हैं। चलो इसके बारे में कुछ करते हैं।

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

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" }; 

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

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

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

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

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

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

{} शेष गैर-शून्य वस्तुओं के साथ सौदा, और शून्य शून्य हो जाता है, इसलिए स्विच संपूर्ण है, और संकलक लापता मानों के बारे में शिकायत नहीं करेगा।

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

संपत्ति का पैटर्न दूसरे बिंदु के मामले को छोटा नहीं करता है । इस बारे में चिंता करने की कोई जरूरत नहीं है, आप और भी अधिक कर सकते हैं।

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

 (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" }; 

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

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

टपल पैटर्न

स्थैतिक पैटर्न का एक बहुत ही उपयोगी विशेष मामला ट्यूपल्स के लिए उनका आवेदन है। यदि स्विच स्टेटमेंट को सीधे टुपल एक्सप्रेशन पर लागू किया जाता है, तो हम स्विच के बजाय कोष्ठक (x, y, z) में कोष्ठक के अतिरिक्त सेट को छोड़ने की अनुमति देते हैं (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") }; 

बेशक, हम जब क्लॉस का उपयोग करने के बजाय टपल में हैके को शामिल कर सकते हैं - यह स्वाद का मामला है:

 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") }; 

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

पूर्वावलोकन 2 में C # 8.0 की अन्य विशेषताएं

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

विज्ञापनों का उपयोग करना

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

 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 

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

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

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

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

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

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

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

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

अतुल्यकालिक धागे

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