रोजलिन के साथ कोड एक्शन लागू करना

रोसलिन सर्विसेज एपीआई विजुअल स्टूडियो में कोड समस्याओं को खोजने और ठीक करने वाले एक्सटेंशन को लागू करना आसान बनाता है। रोसलिन सर्विसेज एपीआई रोसलिन सीटीपी के हिस्से के रूप में उपलब्ध है।

इस पोस्ट में, हम विजुअल स्टूडियो के लिए एक एक्सटेंशन लागू कर रहे हैं, जो गणना योग्य () विधि के लिए कॉल का पता लगाता है, जिसके बाद परिणाम शून्य से अधिक की समानता के लिए जाँच की जाती है, उदाहरण के लिए, someSequence.Count ()> 0. कोड के साथ समस्या यह है कि गणना () परिणाम वापस करने से पहले पूरे अनुक्रम के माध्यम से जाना चाहिए। इस मामले में एक अधिक सही दृष्टिकोण एन्युमेरेबल.एनी () विधि को कॉल करना है।

इसे ठीक करने के लिए, हम CodeIssueProvider को लागू करते हैं, जो समस्या का पता लगाता है, और CodeAction, जो आवश्यकता के अनुसार Enumerable.Any () को कॉल के साथ स्थिति को बदल देता है। यानी हमारे CodeAction कुछ कुछ परिवर्तन की तरह होगा। कुछ ()> 0 से someSequence.Any ()।

कुछ अतिरिक्त शर्तें हैं जिन्हें हम भी पूरा करना चाहेंगे: सबसे पहले, अभिव्यक्ति को उल्टा किया जा सकता है और 0 <someSequence.Count () के रूप में लिखा जा सकता है। अगला मामला> 0 के बजाय टाइप> = 1 का रिकॉर्ड है, जो तार्किक रूप से पहले जैसा है। हमें दोनों मामलों में काम करने के लिए विस्तार की आवश्यकता है।

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

शुरुआत हो रही है

Roslyn CTP आपको अपने एपीआई के साथ आरंभ करने में मदद करने के लिए टेम्पलेट्स का एक सेट के साथ आता है। आरंभ करने के लिए, हम रोसलिन टेम्प्लेट से टाइप कोड इश्यू की एक नई परियोजना बनाएंगे। इस प्रोजेक्ट को रिप्लेसकाउंटविथनी नाम दें।



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



यद्यपि उदाहरण Visual Studio के लिए एक्सटेंशन के रूप में उपयोगी नहीं है, यह आपको अपना स्वयं का एक्सटेंशन लागू करने के लिए आवश्यक सभी चीज़ों को तैयार करता है। हमें केवल उत्पन्न GetIssue विधि की सामग्री को प्रतिस्थापित करना होगा। मैं ध्यान देता हूं कि GetIssues के लिए तीन ओवरलोड हैं। हम ओवरलोडिंग के साथ काम करेंगे, जहां मापदंडों में से एक कॉमनसेंटएक्सनोड टाइप है। शेष दो ओवरलोड हमारे मामले में छोड़े जा सकते हैं।

उत्पन्न CodeIssueProvider वर्ग ICodeIssueProvider इंटरफ़ेस लागू करता है और ExportSyntaxNodeCodeIssueProvide विशेषता से सजाया जाता है। यह Visual Studio को ICodeIssueProvide इंटरफ़ेस द्वारा प्रदान किए गए अनुबंध वाले एक्सटेंशन के रूप में इस प्रकार का आयात करने की अनुमति देता है।

हम GetIssues को लागू करते हैं

प्रत्येक सिंटैक्स निर्माण के लिए हमारी गेटआईसूज़ विधि को बुलाया जाएगा, इसलिए पहली बात यह है कि हमें उन नोड्स को बाहर करना चाहिए, जिनमें हम रुचि नहीं रखते हैं। चूँकि हमें कुछ प्रकार के निर्माण की आवश्यकता है। Count.Count ()> 0, हमें केवल BinaryExpressionSyntax प्रकार के नोड्स की आवश्यकता है। हम ExportSyntaxNodeCodeIssueProvide विशेषता के माध्यम से प्रकारों की एक सूची प्रदान करके केवल विशिष्ट नोड्स के लिए हमारे प्रदाता का उपयोग करने के लिए विजुअल स्टूडियो को बता सकते हैं। इसलिए, नीचे दिखाए अनुसार विशेषता को अपडेट करें:

[ExportSyntaxNodeCodeIssueProvider("ReplaceCountWithAny", LanguageNames.CSharp, typeof(BinaryExpressionSyntax))] class CodeIssueProvider : ICodeIssueProvider ... 

यह आपको GetSssues विधि में बाइनरीExpressionSyntax प्रकार के कॉमनसाइनटैक्स नोड को सुरक्षित रूप से डालने की अनुमति देता है।

उन मामलों को उजागर करने के लिए जिन्हें हम संभालना चाहते हैं, आपको कॉल करने के लिए Enumerable.Count () को अभिव्यक्ति के भाग की जांच करने की आवश्यकता है, और तुलना के लिए एक और। हम सत्यापन डेटा को सहायक विधियों में अलग कर देंगे, ताकि हमारा GetIssues कार्यान्वयन इस तरह दिखाई देगा:

 public IEnumerable<CodeIssue> GetIssues(IDocument document, CommonSyntaxNode node, CancellationToken cancellationToken) { var binaryExpression = (BinaryExpressionSyntax)node; var left = binaryExpression.Left; var right = binaryExpression.Right; var kind = binaryExpression.Kind; if (IsCallToEnumerableCount(document, left, cancellationToken) && IsRelevantRightSideComparison(document, right, kind, cancellationToken) || IsCallToEnumerableCount(document, right, cancellationToken) && IsRelevantLeftSideComparison(document, left, kind, cancellationToken)) { yield return new CodeIssue(CodeIssue.Severity.Info, binaryExpression.Span, string.Format("Change {0} to use Any() instead of Count() to avoid " + "possible enumeration of entire sequence.", binaryExpression)); } } 

CodeIssue क्लास का उदाहरण जो हम लौटते हैं, समस्या के स्तर को इंगित करता है, जो त्रुटि, चेतावनी या जानकारी हो सकती है, कोड के एक हिस्से को उजागर करने के लिए उपयोग किया गया विवरण और उपयोगकर्ता को समस्या का वर्णन करने वाला पाठ।

हेल्पर के तरीके

अब हम अपना ध्यान GetIssues में इस्तेमाल होने वाले सहायक तरीकों की ओर देते हैं। IsCallToEnumerableCount विधि सही है अगर हम जिस विचार पर विचार कर रहे हैं उसका हिस्सा कुछ अनुक्रम पर गणना () विधि के लिए एक कॉल है। मैं आपको फिर से याद दिलाता हूं: हम सबसे पहले अनावश्यक भावों को छानते हैं।

सबसे पहले, अभिव्यक्ति एक विधि कॉल होनी चाहिए। इस मामले में, हमें अभिव्यक्ति संपत्ति से आवश्यक कॉल मिलता है। तो, यदि डिज़ाइन कुछ असमानता की तरह दिखता है ।ाउंट ()> 0, तो हमारे पास गणना () के साथ एक हिस्सा होगा; लेकिन यह जांचने के लिए कैसे कि वह एन्युमरेबल टाइप का है?

इस तरह के सवालों का जवाब देने के लिए, आपको एक सेमैटिक मॉडल का अनुरोध करना होगा। सौभाग्य से, GetIssues विधि के मापदंडों में से एक एक IDocument है, जो एक परियोजना और समाधान में एक दस्तावेज है। हम इसके माध्यम से एक सिमेंटिक मॉडल प्राप्त कर सकते हैं, और पहले से ही यह SymbolInfo से ही है, जो हमें चाहिए।
SymbolInfo की मदद से आप जांच सकते हैं कि हमारी विधि कॉल वांछित [Enumerable.Count ()] की है या नहीं। चूंकि काउंट () एक विस्तार विधि है, इसके साथ काम करना थोड़ा अलग होगा। याद रखें कि C # एक्सटेंशन विधियों को एक प्रकार का हिस्सा कहा जाता है। सिमेंटिक मॉडल मूल प्रकार के संदर्भ में MethodSymbol वर्ग की निर्माण की गई संपत्ति के माध्यम से यह जानकारी प्रदान करता है। इसे थोड़ा आसान बनाने का अवसर है, इसलिए एपीआई नामों के लिए बने रहें।

हमारे लिए यह सब करने के लिए विस्तार विधि के प्रकार को इंगित करना है। यदि यह Enumerable से मेल खाता है, तो हमें Enumerable.Count () में कॉल मिला।

कार्यान्वयन इस प्रकार है:

 private bool IsCallToEnumerableCount(IDocument document, ExpressionSyntax expression, CancellationToken cancellationToken) { var invocation = expression as InvocationExpressionSyntax; if (invocation == null) { return false; } var call = invocation.Expression as MemberAccessExpressionSyntax; if (call == null) { return false; } var semanticModel = document.GetSemanticModel(cancellationToken); var methodSymbol = semanticModel.GetSemanticInfo(call, cancellationToken).Symbol as MethodSymbol; if (methodSymbol == null || methodSymbol.Name != "Count" || methodSymbol.ConstructedFrom == null) { return false; } var enumerable = semanticModel.Compilation.GetTypeByMetadataName( typeof(Enumerable).FullName); if (enumerable == null || !methodSymbol.ConstructedFrom.ContainingType.Equals(enumerable)) { return false; } return true; } 

आगे बढ़ने से पहले, आपको बाइनरी अभिव्यक्ति के दूसरे भाग में तुलना की शुद्धता के लिए अभिव्यक्ति की जांच करनी चाहिए; और यह सहायक विधियों IsRelevantRightSideComparison और IsRelevantLeftSideComparison के लिए काम है।

नीचे उनके कार्यान्वयन हैं:

 private bool IsRelevantRightSideComparison(IDocument document, ExpressionSyntax expression, SyntaxKind kind, CancellationToken cancellationToken) { var semanticInfo = document.GetSemanticModel(cancellationToken). GetSemanticInfo(expression); int? value; if (!semanticInfo.IsCompileTimeConstant || (value = semanticInfo.ConstantValue as int?) == null) { return false; } if (kind == SyntaxKind.GreaterThanExpression && value == 0 || kind == SyntaxKind.GreaterThanOrEqualExpression && value == 1) { return true; } return false; } private bool IsRelevantLeftSideComparison(IDocument document, ExpressionSyntax expression, SyntaxKind kind, CancellationToken cancellationToken) { var semanticInfo = document.GetSemanticModel(cancellationToken). GetSemanticInfo(expression); int? value; if (!semanticInfo.IsCompileTimeConstant || (value = semanticInfo.ConstantValue as int?) == null) { return false; } if (kind == SyntaxKind.LessThanExpression && value == 0 || kind == SyntaxKind.LessThanOrEqualExpression && value == 1) { return true; } return false; } 

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

CodeIssueProvider का परीक्षण करना

फिलहाल, हमारा प्रदाता हमें ब्याज की समस्याओं का पता लगाने में सक्षम है। हम प्रोजेक्ट को विजुअल स्टूडियो के एक नए उदाहरण के साथ संकलित और संकलित करते हैं और साथ में एक्सटेंशन भी शामिल है। Enumerable.Count () को कॉल करने वाले कोड और नोटिस को सही ढंग से रेखांकित किया गया है, जबकि काउंट () के हस्ताक्षर वाले अन्य तरीकों के लिए कॉल नहीं हैं।



अगला कदम समस्या को हल करने के लिए कार्रवाई प्रदान करना है।

CodeAction

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

 public CodeAction(ICodeActionEditFactory editFactory, IDocument document, BinaryExpressionSyntax binaryExpression) { this.editFactory = editFactory; this.document = document; this.binaryExpression = binaryExpression; } 

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

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

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

 public ICodeActionEdit GetEdit(CancellationToken cancellationToken) { var syntaxTree = (SyntaxTree)document.GetSyntaxTree(cancellationToken); var newExpression = GetNewNode(binaryExpression). WithLeadingTrivia(binaryExpression.GetLeadingTrivia()). WithTrailingTrivia(binaryExpression.GetTrailingTrivia()); var newRoot = syntaxTree.Root.ReplaceNode(binaryExpression, newExpression); return editFactory.CreateTreeTransformEdit( document.Project.Solution, syntaxTree, newRoot, cancellationToken: cancellationToken); } private ExpressionSyntax GetNewNode(BinaryExpressionSyntax node) { var invocation = node.DescendentNodes(). OfType<InvocationExpressionSyntax>().Single(); var caller = invocation.DescendentNodes(). OfType<MemberAccessExpressionSyntax>().Single(); return invocation.Update( caller.Update(caller.Expression, caller.OperatorToken, Syntax.IdentifierName("Any")), invocation.ArgumentList); } 

रोज़लिन सिंटैक्स का पेड़ मूल कोड के समान है, इसलिए पेड़ में प्रत्येक नोड में अतिरिक्त स्थान और टिप्पणियां हो सकती हैं। यानी जब हम नोड्स को स्वयं बदलते हैं तो हम टिप्पणियों और कोड संरचना के साथ मूल नोड को बचाते हैं। ऐसा करने के लिए, हम विस्तार विधियों को WithLeadingTrivia और WithTrailingTrivia कहते हैं।

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

संक्षेप में कहना

हमारी कार्रवाई को सक्षम करने के लिए, आपको प्रत्येक CodeIssue के लिए एक CodeAction उदाहरण वापस करने के लिए CodeIssueProvider वर्ग में GetIssues विधि को अपडेट करना होगा। प्रत्येक समस्याग्रस्त अनुभाग में कई क्रियाएं हो सकती हैं, जिससे उपयोगकर्ता को उनके बीच चयन करने की अनुमति मिलती है। इस मामले में, हम नीचे दिखाए गए अनुसार एक क्रिया करते हैं।

GetIssues विधि का अद्यतन हिस्सा निम्नानुसार है:

 yield return new CodeIssue(CodeIssue.Severity.Info, binaryExpression.Span, string.Format("Change {0} to use Any() instead of Count() to avoid " + "possible enumeration of entire sequence.", binaryExpression), new CodeAction(editFactory, document, binaryExpression)); 

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



इस प्रकार, हमने विजुअल स्टूडियो के लिए एक एक्सटेंशन लागू किया, जो हमारे कोड को बेहतर बनाने में मदद करेगा।