🗾 ♈️ 🈯️ रोजलिन के साथ सी # का विस्तार। सुरक्षित कॉल 🎦 🤶 🈳

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

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

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

सुरक्षित कॉल और शायद मोनाड

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

शायद मोनाड का उपयोग करके कार्यात्मक प्रोग्रामिंग भाषाओं में इस समस्या को हल किया गया था, जिसका सार यह है कि बॉक्सिंग के बाद, पाइपलाइन कंप्यूटिंग में उपयोग किए जाने वाले प्रकार में कुछ मूल्य, या मूल्य कुछ भी नहीं हो सकता है। यदि पाइपलाइन में पिछली गणना ने कुछ परिणाम दिया है, तो अगली गणना की जाती है, यदि यह कुछ भी नहीं लौटाता है, तो अगली गणना के बजाय कुछ भी नहीं लौटाया जाता है।

सी # में, इस मोनाड के कार्यान्वयन के लिए सभी स्थितियां बनाई गई हैं - अशक्त का उपयोग नथिंग के बजाय किया जाता है, उनके अशक्त <टी> संस्करणों का उपयोग संरचनात्मक प्रकारों के लिए किया जा सकता है। सिद्धांत रूप में, विचार पहले से ही हवा में है, और ऐसे कई लेख थे जिन्होंने LINQ का उपयोग करके C # में इस मोनड को लागू किया। उनमें से एक दिमित्री नेस्टरुक मेज़ेस्टेल से संबंधित है , एक और है ।

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

एक बहुत ही सुरुचिपूर्ण, जैसा कि यह मुझे लग रहा था, इस विचार को लागू करने का तरीका मुझे JDK के लिए कोटलिन भाषा के विनिर्देशन में मिला जो अभी तक मेरे प्रिय JetBrains ( Null-safety ) कंपनी के लोगों द्वारा नहीं बनाया गया है। जैसा कि यह निकला, यह ग्रूवी में पहले से ही है, शायद कहीं और।

तो यह सुरक्षित कॉल स्टेटमेंट क्या है? मान लीजिए कि हमारे पास एक अभिव्यक्ति है:

string text = SomeObject.ToString();

यदि SomeObject अशक्त है, तो हम अनिवार्य रूप से, जैसा कि पहले ही उल्लेख किया गया है, एक NullReferenceException प्राप्त करें। इससे बचने के लिए, हम डायरेक्ट कॉल ऑपरेटर के अलावा परिभाषित करते हैं '।' सुरक्षित कॉल ऑपरेटर '?' जो इस प्रकार है:

 string text = SomeObject?.ToString();

और वास्तव में एक अभिव्यक्ति है:

 string text = SomeObject != null ? SomeObject.ToString() : null;

इस घटना में कि एक सुरक्षित रूप से बुलाया विधि या संपत्ति एक संरचनात्मक प्रकार लौटाती है, यह आवश्यक है कि असाइन किया गया चर प्रकार अशक्त हो।

 int? count = SomeList?.Count;

नियमित कॉल की तरह, इन सुरक्षित कॉल का उपयोग जंजीरों में किया जा सकता है, उदाहरण के लिए:

 int? length = SomeObject?.ToString()?.Length;

जो एक अभिव्यक्ति का अनुवाद करता है:

 int? length = SomeObject != null ? SomeObject.ToString() != null ? SomeObject.ToString().Length : null : null;

यह मेरे द्वारा प्रस्तावित परिवर्तन की कुछ कमियां छिपाता है, क्योंकि यह अतिरिक्त फ़ंक्शन कॉल उत्पन्न करता है। वास्तव में, इसे रूपांतरित करना वांछनीय होगा, उदाहरण के लिए, फ़ॉर्म में:

 var temp = SomeObject; string text = null; if (temp != null) text = temp.ToString();

हालांकि, रोज़लिन की कुछ हद तक प्रकृति के कारण, ताकि उदाहरण बहुत अधिक फूला हुआ और उबाऊ न हो, मैंने रूपांतरण को सरल बनाने का फैसला किया। हालाँकि, यह निम्नलिखित भागों में है।

प्रोजेक्ट रोजलिन

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

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

इसी समय, पहले से ही दो वर्कअराउंड हैं:

आप समान रोसलिन एपीआई का उपयोग करके वर्तमान csc.exe के बजाय अपना खुद का कंपाइलर बना सकते हैं, और अपने स्वयं के एनालॉग के साथ csc.exe को बदलकर अपनी निर्माण प्रणाली को बदल सकते हैं, जिसमें डिफ़ॉल्ट संकलन (वैसे बस प्रोग्राम द्वारा, इसके अलावा) प्रारंभिक परिवर्तन शामिल हैं कोड।
आप अपने कंसोल प्रोग्राम का उपयोग प्री-बिल्ड कार्य के रूप में कर सकते हैं जो स्रोत कोड फ़ाइलों को कनवर्ट करता है और प्राप्त नए स्रोतों को ओब्ज फ़ोल्डर में सहेजता है। वर्तमान में WPF को बहुत ही समान तरीके से संकलित किया जा रहा है, जब पूर्व-निर्मित चरण में xaml फाइलें .g.cs फाइलों में बदल जाती हैं।

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

कार्यान्वयन

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

 public class Example { public const string CODE = @"using System; using System.Linq; using System.Windows; namespace HelloWorld { public class TestClass { public string TestField; public string TestProperty { get; set; } public string TestMethod() { return null; } public string TestMethod2(int k, string p) { return null; } public TestClass ChainTest; } public class OtherClass { public void Test() { TestClass test; string testStr1; testStr1 = test?.TestField; string testStr3 = test?.TestProperty; string testStr4 = test?.TestMethod(); string testStr5 = test?.TestMethod2(100, testStr3); var test3 = test?.ChainTest?.TestField; } } }"; }

सुरक्षित कॉल स्टेटमेंट के अपवाद के साथ यह स्रोत कोड, न केवल वाक्यविन्यास रूप से सही है, बल्कि संकलित भी है, हालांकि यह हमारे रूपांतरण के लिए आवश्यक नहीं है।

सबसे पहले, आपको स्रोत फ़ाइल से एक सार सिंटैक्स ट्री बनाने की आवश्यकता है। यह दो तरीकों से किया जाता है:

 SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE); SyntaxNode root = tree.Root;

सिंटैक्स ट्री को सिंटैक्सट्री क्लास द्वारा परिभाषित किया गया है और, विचित्र रूप से पर्याप्त है, आधार सिंटेक्सनोड प्रकार से प्राप्त नोड्स का एक पेड़ है, जिनमें से प्रत्येक एक निश्चित अभिव्यक्ति का प्रतिनिधित्व करता है - द्विआधारी भाव, सशर्त अभिव्यक्ति, विधि आह्वान अभिव्यक्ति, संपत्ति परिभाषाएं और चर। स्वाभाविक रूप से, बिल्कुल किसी भी C # निर्माण को SyntaxNode वंशज वर्ग के कुछ उदाहरणों द्वारा प्रदर्शित किया जा सकता है। इसके अलावा, SyntaxTree वर्ग में SyntaxToken सेट होते हैं जो न्यूनतम सिंटैक्स ब्लॉकों के स्तर पर स्रोत कोड पार्सिंग को परिभाषित करते हैं - कीवर्ड, शाब्दिक, पहचानकर्ता और विराम चिह्न (घुंघराले और कोष्ठक, अल्पविराम, अर्धविराम)। अंत में, SyntaxTree में SyntaxTrivia तत्व शामिल होते हैं - वे जो कोड द्वारा बड़े और महत्वपूर्ण होते हैं - कोड और स्पेस, कमेंट, प्रीप्रोसेसर निर्देश आदि।

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

सब कुछ सरल हो जाता है: रोसेलिन के दृष्टिकोण से, अभिव्यक्ति परीक्षण?; TestField शर्त के साथ एक सहायक ऑपरेटर है - "परीक्षण", अभिव्यक्ति "जब सत्य" - ".TestField", और खाली अभिव्यक्ति "गलत होने पर"। इस जानकारी के साथ, हम अपने पेड़ को बदल देंगे। यहां हम एक और रोसलिन सुविधा के साथ आते हैं - जो सिंटेक्स ट्री बनाता है वह अपरिवर्तनीय है, अर्थात यह मौजूदा संरचना में सीधे कुछ भी ठीक करने के लिए काम नहीं करेगा। लेकिन इससे कोई फर्क नहीं पड़ता। Roslyn ऐसे ऑपरेशन के लिए SyntaxRewriter क्लास का उपयोग करने का सुझाव देता है, जो SyntaxVisitor क्लास को इनहेरिट करता है, जैसा कि नाम से ही स्पष्ट है, कुख्यात विज़िटर पैटर्न को लागू करता है। इसमें कई आभासी विधियां शामिल हैं जो प्रत्येक विशेष प्रकार के नोड (उदाहरण के लिए, VisitFieldDeclaration, VisitEnumMemberDeclaration, ...) की यात्रा पर जाती हैं ... कुल मिलाकर उनमें से लगभग 180 हैं।

हमें अपना वंशज SyntaxRewriter वर्ग बनाने और VisitConditionalExpression विधि को ओवरराइड करने की आवश्यकता है, जिसे तब कहा जाता है जब आगंतुक अभिव्यक्ति को दरकिनार कर देता है, जो एक टर्नरी ऑपरेटर है। अगला, मैं संपूर्ण कार्यान्वयन कोड दूंगा, खासकर जब से यह छोटा है, और मैं केवल कुछ स्पष्टीकरण जोड़ूंगा:

 //              public class SafeCallRewriter : SyntaxRewriter { //          ?. public bool IsSafeCallRewrited { get; set; } protected override SyntaxNode VisitConditionalExpression(ConditionalExpressionSyntax node) { if (IsSafeCallExpression(node)) { // expression  ,   null string identTxt = node.Condition.GetText(); ExpressionSyntax ident = Syntax.ParseExpression(identTxt); // expression  ,      != null string exprTxt = node.WhenTrue.GetText(); exprTxt = exprTxt.Substring(1, exprTxt.Length - 1);//     exprTxt = identTxt + '.' + exprTxt; ExpressionSyntax expr = Syntax.ParseExpression(exprTxt); ExpressionSyntax synt = Syntax.ConditionalExpression(//  condition: Syntax.BinaryExpression(//  ident != null SyntaxKind.NotEqualsExpression, left: ident, //  -   right: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression)), // null whenTrue: expr, whenFalse: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression)); IsSafeCallRewrited = true; return synt; } return base.VisitConditionalExpression(node); } //          private bool IsSafeCallExpression(ConditionalExpressionSyntax node) { return node.WhenTrue.GetText()[0] == '.'; } }

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

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

यहाँ मुख्य प्रक्रिया के लिए कोड है:

 static void Main(string[] args) { //   SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE); SyntaxNode root = tree.Root; SafeCallRewriter rewriter = new SafeCallRewriter(); do { rewriter.IsSafeCallRewrited = false; // ,           root = rewriter.Visit(root); } while (rewriter.IsSafeCallRewrited);//        1 maybe- root = root.Format();// Ctrl+K, Ctrl+D Console.WriteLine(root.ToString()); }

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

परिणामस्वरूप, हमारे पास निम्नलिखित कोड हैं:

 using System; using System.Linq; using System.Windows; namespace HelloWorld { public class TestClass { public string TestField; public string TestProperty { get; set; } public string TestMethod() { return null; } public string TestMethod2(int k, string p) { return null; } public TestClass ChainTest; } public class OtherClass { public void Test() { TestClass test; string testStr1; testStr1 = test != null ? test.TestField : null; string testStr3 = test != null ? test.TestProperty : null; string testStr4 = test != null ? test.TestMethod() : null; string testStr5 = test != null ? test.TestMethod2(100, testStr3) : null; var test3 = test != null ? test.ChainTest != null ? test.ChainTest.TestField : null : null; } } }

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

PS रोज़लिन के ऐसे उपयोग का एक और उदाहरण, जिसने मुझे बहुत मदद की, यहाँ दिया गया है ।

रोजलिन के साथ सी # का विस्तार। सुरक्षित कॉल

सुरक्षित कॉल और शायद मोनाड

प्रोजेक्ट रोजलिन

कार्यान्वयन

More articles: