दृश्य स्टूडियो 2005-2012 और Atmel स्टूडियो के लिए C # एक्सटेंशन मॉड्यूल विकास गाइड

अमूर्त

लगभग एक साल पहले, हमने अपने ब्लॉग पर C # में Visual Studio के लिए प्लगइन्स विकसित करने पर कई लेख प्रकाशित किए। अब हमने इन सामग्रियों को फिर से काम में लिया है, नए खंड जोड़े हैं और आपको मैनुअल का एक नया संस्करण प्रदान करते हैं।

Microsoft Visual Studio विकास वातावरण के लिए विस्तार मॉड्यूल (या प्लगइन्स) बनाना पहली बार में बहुत सरल लग सकता है। आखिरकार, MSDN, लेख, उदाहरण और कई अतिरिक्त सामग्रियों पर उत्कृष्ट प्रलेखन है। लेकिन यह मुश्किल लग सकता है, जब कुछ क्रियाएं अपेक्षित परिणाम नहीं देंगी। और यद्यपि यह व्यवहार अक्सर किसी भी प्रोग्रामिंग कार्य की विशेषता पाया जाता है, प्लग-इन विकास के विषय का अभी भी पूरी तरह से खुलासा नहीं किया गया है।

हम एक PVS-Studio स्थिर कोड विश्लेषक विकसित कर रहे हैं। और यद्यपि टूल स्वयं C ++ प्रोग्रामर के लिए अभिप्रेत है, लेकिन इसका काफी हिस्सा C # में लिखा गया है। जब हमने अपना प्लगइन विकसित करना शुरू किया, तो विज़ुअल स्टूडियो वर्ल्ड में विजुअल स्टूडियो 2005 के संस्करण को सबसे नया और आधुनिक माना गया। और अब जबकि विजुअल स्टूडियो 2012 पहले ही रिलीज़ हो चुका है, तो कुछ कह सकते हैं कि विज़ुअल स्टूडियो 2005 पूरी तरह से प्रासंगिक नहीं है, फिर भी हम इसका समर्थन करते हैं आपके उपकरण में संस्करण। चूंकि हमने विज़ुअल स्टूडियो के विभिन्न संस्करणों का समर्थन किया और पर्यावरण की विभिन्न विशेषताओं का उपयोग किया, इसलिए हमने प्लगइन्स को सही तरीके से बनाने के लिए (और विशेष रूप से गलत!) पर व्यावहारिक ज्ञान की एक बड़ी मात्रा जमा की है। इस ज्ञान को धारण करने में कोई ताकत नहीं रह गई थी। इसलिए, हमने उन्हें जारी करने और प्रकाशित करने का निर्णय लिया। आखिरकार, कुछ समाधान जो अब स्पष्ट प्रतीत होते हैं, कुछ साल बाद ही पाए गए थे। और जो समस्याएं लंबे समय से हल हो गई हैं, वे अभी भी कुछ प्लगइन डेवलपर्स को पीड़ा दे सकती हैं।

निम्नलिखित मुद्दों पर ध्यान दिया जाएगा:

• MSVS प्लगइन्स बनाने और डिबग करने के साथ-साथ Visual Studio के कई संस्करणों के लिए एक ही कोड बेस में इन एक्सटेंशन प्रोजेक्ट्स के लिए आधारभूत जानकारी;
• स्वचालन ऑब्जेक्ट मॉडल और MPF (प्रबंधित पैकेज फ्रेमवर्क) कक्षाओं का अवलोकन;
• कस्टम मेनू, टूलबार, टूल विंडो और सेटिंग्स संवाद के साथ ऑटोमेशन ऑब्जेक्ट मॉडल एपीआई (एनवीडीटीई) और एमपीएफ (प्रबंधित पैकेज फ्रेमवर्क) कक्षाओं का उपयोग करके विकास पर्यावरण इंटरफ़ेस का विस्तार करना;
• विजुअल स्टूडियो प्रोजेक्ट मॉडल ओवरव्यू, कस्टम प्रोजेक्ट मॉडल के साथ इंटरैक्शन एटम स्टूडियो का उपयोग करते हुए विजुअल स्टूडियो आइसोलेटेड शेल के उदाहरण के रूप में
• बाहरी प्रीप्रोसेसर / कंपाइलर के साथ काम करने के लिए विजुअल C ++ प्रोजेक्ट मॉडल का उपयोग करते हुए सभी आवश्यक डेटा का संग्रह, जैसे विभिन्न मापदंडों और प्लेटफार्मों के लिए संकलन पैरामीटर और सेटिंग्स;

लेख में शामिल विषयों का अधिक विस्तृत और पूर्ण विवरण MSDN लाइब्रेरी की आधिकारिक सामग्रियों और प्रत्येक अनुभाग के अंत में प्रदान किए गए अन्य तृतीय-पक्ष संसाधनों के लिंक पर उपलब्ध है।

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

Microsoft Visual Studio 2005 एक्सटेंशन पैकेज बनाना, डीबग करना और उसकी तैनाती करना

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

विजुअल स्टूडियो और विजुअल स्टूडियो आइसोलेटेड शेल एक्सटेंशन मॉड्यूल के VSPackage बनाना और डिबग करना

Microsoft Visual Studio की कार्यक्षमता का विस्तार करने के कई तरीके हैं। सबसे बुनियादी स्तर पर, आप मैक्रोज़ के साथ सरल दिनचर्या क्रियाओं को स्वचालित कर सकते हैं। पर्यावरण की यूआई वस्तुओं के साथ सरल कार्यों के सॉफ्टवेयर स्वचालन के लिए, मेनू आइटम का हेरफेर, आदि। आप प्लग-इन (ऐड-इन) का उपयोग कर सकते हैं।

MEF (प्रबंधित एक्स्टेंसिबिलिटी फ्रेमवर्क) घटकों (MSVS 2010 के संस्करण से शुरू) के माध्यम से अंतर्निहित पर्यावरण संपादकों का विस्तार संभव है। बड़े स्वतंत्र घटकों के विज़ुअल स्टूडियो में एकीकरण के लिए, एक्सटेंशन पैकेज प्रकार (एक्सटेंशन पैकेज, जिसे वीएसपीकेएज भी कहा जाता है) के विस्तार सबसे उपयुक्त हैं। उसी समय, VSPackage आपको MEF (प्रबंधित एक्स्टेंसिबिलिटी फ्रेमवर्क) और प्रबंधित पैकेज फ्रेमवर्क क्लासेस (जैसे पैकेज) के माध्यम से पर्यावरण का विस्तार करने के साथ ऑटोमेशन ऑब्जेक्ट मॉडल के माध्यम से IDE घटकों के प्रबंधन के स्वचालन को संयोजित करने की अनुमति देता है। वास्तव में, जबकि विज़ुअल स्टूडियो स्वयं केवल सामान्य इंटरफ़ेस घटक और सेवाएं प्रदान करता है, मानक मॉड्यूल जैसे विजुअल C ++ या विज़ुअल C # को पर्यावरण एक्सटेंशन के रूप में लागू किया जाता है।

पीवीएस-स्टूडियो प्लगइन के पहले संस्करण (अधिक सटीक रूप से 1.XX और 2.XX, जब हमारे उत्पाद को अभी भी Viva64 कहा जाता था), हमने एड-इन के रूप में जारी किया। संस्करण पीवीएस-स्टूडियो 3.00 से, हम इसे वीएसपीएकेएज को रीडायरेक्ट करते हैं। संक्रमण का कारण - यह ऐड-इन में "तंग" हो गया और इसे डिबग करना असुविधाजनक था। इसके अलावा, मैं विजुअल स्टूडियो स्क्रीन सेवर पर अपना खुद का आइकन रखना चाहता था!

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

सीधे विजुअल स्टूडियो वातावरण का विस्तार करने के अलावा, VSPackage मॉड्यूल का उपयोग Visual Studio के पृथक \ समन्वित गोले (Visual Studio Isolated \ Integrated Shell) में कार्यक्षमता जोड़ने के लिए भी किया जा सकता है। पृथक \ एकीकृत विज़ुअल स्टूडियो शेल किसी भी तृतीय-पक्ष डेवलपर को अपने स्वयं के प्रोजेक्ट मॉडल और / या पर्यावरण के लिए समर्थन जोड़ते हुए, मानक विज़ुअल स्टूडियो इंटरफ़ेस घटकों और सेवाओं (कोड संपादक, स्व-समापन प्रणाली, आदि) का पुन: उपयोग करने की अनुमति देता है। ऐसी वितरण किट में Microsoft स्वामित्व भाषा घटक (Visual Basic, Visual C ++, आदि) नहीं होंगे, और एंड यूज़र द्वारा Visual Studio IDE के प्रीइंस्टॉल्ड संस्करण के बिना भी सिस्टम पर इंस्टॉल किए जा सकते हैं।

Visual Studio का पृथक शेल स्थापना के बाद भी अलग-थलग रहेगा, यहां तक ​​कि Visual Studio के साथ एक सिस्टम पर भी प्रीइंस्टॉल्ड किया गया है, और एकीकृत शेल को प्रीइंस्टॉल्ड वातावरण में विलय कर दिया जाएगा। यदि पृथक / एकीकृत शेल का डेवलपर अपने विशिष्ट घटकों में इंटरफेस जोड़कर विज़ुअल स्टूडियो स्वचालन मॉडल का विस्तार करता है, तो VSPackage प्लगइन डेवलपर के पास इन इंटरफेस तक पहुंच होगी। विजुअल स्टूडियो आइसोलेटेड शेल का एक उदाहरण एम्बेडेड Atmel स्टूडियो सिस्टम बनाने के लिए वातावरण है। Atmel स्टूडियो अपने स्वयं के प्रोजेक्ट मॉडल का उपयोग करता है, जो MSBuild के लिए मानक Visual Studio प्रोजेक्ट मॉडल का कार्यान्वयन है, और gcciler विकल्प है।

VSPackage प्लग-इन प्रोजेक्ट, एक विस्तार पैक बना रहा है

दृश्य स्टूडियो पैकेज (VSPackage, विस्तार पैक) के प्लग-इन बनाने पर विचार करें। प्लग-इन (ऐड-इन) के विपरीत, पर्यावरण के विस्तार पैक को विकसित करने के लिए विकास के वातावरण के लक्ष्य संस्करण के लिए Microsoft Visual Studio SDK को स्थापित करना होगा। यही है, विजुअल स्टूडियो के प्रत्येक संस्करण के लिए एक विस्तार पैक विकसित करने के लिए, इसे एक अलग एसडीके की स्थापना की आवश्यकता होगी। Visual Studio के लिए एक एक्सटेंशन पैकेज बनाते समय अलग-थलग एकीकृत शेल, आपको Visual Studio के संस्करण के लिए SDK की आवश्यकता होगी, जिस पर यह शेल आधारित है।

भविष्य में, हम पर्यावरण के संस्करणों के लिए 2005, 2008, 2010 और 2012 के एक्सटेंशन और विज़ुअल स्टूडियो 2010 पृथक शेल (उदाहरण के लिए, एटमेल स्टूडियो) के विकास पर विचार करेंगे। Visual Studio SDK को स्थापित करना Visual Studio Package प्रकार की एक परियोजना को मानक पर्यावरण टेम्पलेट्स (अन्य परियोजना प्रकार -> एक्स्टेंसिबिलिटी आइटम) में जोड़ता है। यह टेम्पलेट एक्सटेंशन मॉड्यूल के लिए सबसे सरल MSBuild प्रोजेक्ट उत्पन्न करेगा, जिससे आप कई विशिष्ट घटकों (मेनू आइटम, संपादक, कस्टम विंडो) के लिए विकास भाषा और स्टब्स सेट कर सकते हैं।

हम VSPackage के C # प्रोजेक्ट (csproj) का उपयोग करेंगे, जो एक गतिशील लिंक लाइब्रेरी (dll) का MSBuild प्रोजेक्ट है। हमारे मामले में, यह एक प्रबंधित असेंबली है, जिसमें विज़ुअल स्टूडियो के नवीनतम संस्करणों के लिए कई विज़ुअल स्टूडियो एक्सटेंशन पैकेज-विशिष्ट असेंबली एक्सएमएल नोड्स, जैसे कि वीसीएसटी कंपाइलर और इनक्लूज़िविक्स शामिल हैं।

Visual Studio एक्सटेंशन पैकेज का मुख्य वर्ग Microsoft.VisualStudio.Shell.Package वर्ग से विरासत में मिला होना चाहिए। यह बेस क्लास पूर्ण विज़ुअल स्टूडियो एक्सटेंशन पैकेज द्वारा आवश्यक IDE इंटरफेस के लिए प्रबंधित रैपर प्रदान करता है।

public sealed class MyPackage: Package { public MyPackage () {} ... } 

पैकेज वर्ग आधार प्रारंभिक विधि को ओवरराइड करने की क्षमता प्रदान करता है। प्रारंभिक आईडी आईडीई सत्र के लिए एक्सटेंशन पैकेज को प्रारंभ करने के समय प्रारंभिक विधि नियंत्रण में लेती है।

 protected override void Initialize() { base.Initialize(); ... } 

पहली बार एक्सेस किए जाने पर मॉड्यूल को इनिशियलाइज़ किया जाता है, और इसे स्वचालित रूप से भी कहा जा सकता है, उदाहरण के लिए, जब IDE प्रारंभ होता है, जब उपयोगकर्ता निर्दिष्ट UI संदर्भ (उदाहरण के लिए, एक प्रोजेक्ट खोलना), आदि में प्रवेश करता है।

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

डिबगिंग एक्सपैंशन पैक्स और एक्सपेरिमेंटल इंस्टेंस

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

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

VSPackage पैकेज को विकसित और डीबग करते समय इन समस्याओं को हल करने के लिए, आप विजुअल स्टूडियो (प्रयोगात्मक उदाहरण) के एक प्रयोगात्मक उदाहरण का उपयोग कर सकते हैं। पर्यावरण शुरू करने के लिए तर्कों की पंक्ति में एक विशेष पैरामीटर जोड़कर इसे लॉन्च किया जा सकता है:

 "C:\Program Files (x86)\Microsoft Visual Studio 10.0\ Common7\IDE\devenv.exe" /RootSuffix Exp 

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

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

 CreateExpInstance.exe /Reset /VSInstance=10.0 /RootSuffix=PVSExp 

इस आदेश को चलाने से IDE (विजुअल स्टूडियो 2010) के संस्करण 10 के नाम के प्रत्यय PVSExp के साथ एक नई प्रायोगिक रजिस्ट्री शाखा बन जाएगी, जिसमें डिफ़ॉल्ट मानों के लिए सभी पर्यावरण सेटिंग्स का प्रारंभिक रीसेट होगा। रजिस्ट्री में नई शाखा का रास्ता इस तरह दिखेगा:

 HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0PVSExp 

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

 "C:\Program Files (x86)\Microsoft Visual Studio 10.0\ Common7\IDE\devenv.exe" /RootSuffix PVSExp 

एक ही स्थानीय मशीन पर कई प्रयोगात्मक शाखाओं को बनाने की क्षमता उपयोगी हो सकती है, उदाहरण के लिए, अलग-अलग वातावरण में कई विस्तार पैक के एक साथ विकास के लिए।

एसडीके को स्थापित करने के बाद, प्रोग्राम आईडी को प्रयोगात्मक आईडीई आवृत्ति को उसकी डिफ़ॉल्ट सेटिंग्स पर रीसेट करने के लिए एक लिंक भी जोड़ा जाएगा (उदाहरण के लिए, Microsoft Visual Studio 2010 प्रायोगिक इंस्टेंस को रीसेट करें)।

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

दृश्य स्टूडियो एक्सटेंशन पैकेज रजिस्टर और तैनात करें

एक एक्सटेंशन पैकेज के पंजीकरण के लिए स्वयं पैकेज के पंजीकरण की आवश्यकता होती है, साथ ही सभी घटक इसे IDE (उदाहरण के लिए, मेनू आइटम, सेटिंग्स पृष्ठ, उपयोगकर्ता विंडो, आदि) में एकीकृत करते हैं। विजुअल स्टूडियो सिस्टम रजिस्ट्री की मुख्य शाखा में घटकों के अनुरूप रिकॉर्ड के निर्माण के माध्यम से पंजीकरण किया जाता है।

पंजीकरण के लिए आवश्यक घटकों के बारे में सभी जानकारी मुख्य मॉड्यूल वर्ग (पैकेज उपवर्ग) के विशेष गुणों के आधार पर VSPackage विधानसभा की विधानसभा के दौरान एक विशेष pkgdef फ़ाइल में दर्ज की गई है। Pkgdef फ़ाइल भी CreatePkgDef उपयोगिता का उपयोग करके मैन्युअल रूप से बनाई जा सकती है। यह उपयोगिता पैकेज उपवर्ग की विशेष विशेषताओं के माध्यम से .NET प्रतिबिंब विधि का उपयोग करके एक मॉड्यूल के बारे में पंजीकरण जानकारी एकत्र करती है। इन विशेषताओं पर विचार करें।

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

 [PackageRegistration(UseManagedResourcesOnly = true)] 

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

 [Guid("a0fcf0f3-577e-4c47-9847-5f152c16c02c")] 

InstalledProductRegademy विशेषता आपको मदद -> डायलॉग के बारे में और विजुअल ड्यूल वातावरण की स्प्लैश बूट स्क्रीन पर जानकारी जोड़ने की अनुमति देती है।

 [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)] 

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

 [ProvideAutoLoad("D2567162-F94F-4091-8798-A096E61B8B50")] 

विभिन्न IDE संदर्भों के लिए पहचानकर्ता GUID को Microsoft.VisualStudio.VSConstants.UICONTEXT वर्ग में पाया जा सकता है।

ProvMenuResource विशेषता उपयोगकर्ता आदेशों की संसाधन ID और उन्हें IDE में पंजीकृत करने के लिए मेनू सेट करती है।

 [ProvideMenuResource("Menus.ctmenu", 1)] 

DefaultRegistryRoot विशेषता सिस्टम रजिस्ट्री में पंजीकरण जानकारी दर्ज करने के लिए पथ सेट करती है। विज़ुअल स्टूडियो 2010 के साथ शुरू, इस विशेषता का उपयोग नहीं किया जा सकता है, और इसी पंजीकरण जानकारी को वीएसआईएक्स कंटेनर के प्रदर्शन में दर्ज किया जाना चाहिए। Visual Studio 2008 में किसी मॉड्यूल को पंजीकृत करने के लिए किसी विशेषता का उपयोग करने का एक उदाहरण:

 [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0")] 

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

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

 [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)] public class CustomRegistrationAttribute : RegistrationAttribute { } 

पंजीकरण रजिस्ट्री में पंजीकरण जानकारी को संशोधित करने के लिए उपयोग किए जाने वाले पंजीकरण और अपंजीकृत विधियों को ओवरराइड करने के लिए पंजीकरणआवंटन वंशज विशेषता की आवश्यकता होगी।

रजिस्ट्री में पंजीकरण की जानकारी जोड़ने के लिए, आप RegPkg उपयोगिता का उपयोग कर सकते हैं, जो स्वचालित रूप से pkgdef फ़ाइल में सूचीबद्ध सभी घटकों को / रूट तर्क के माध्यम से निर्दिष्ट रजिस्ट्री शाखा में पंजीकृत करता है। उदाहरण के लिए, RegPkg कॉल डिबगिंग की सुविधा के लिए प्रयोगात्मक रजिस्ट्री शाखा में विकसित किए जा रहे मॉड्यूल को पंजीकृत करने के लिए विजुअल स्टूडियो परियोजनाओं में स्वचालित रूप से पंजीकृत है। सभी पंजीकरण जानकारी को रजिस्ट्री में जोड़ने के बाद, आपको IDE में ही नए घटकों को पंजीकृत करने के लिए / सेटअप पैरामीटर के साथ Visual Studio वातावरण (devenv.exe) शुरू करना होगा।

विकास मशीन और अंतिम उपयोगकर्ता मशीन, पैकेज लोड कुंजी पर प्लगइन की तैनाती

इससे पहले कि आप परिनियोजन प्रक्रिया का वर्णन करना शुरू करें, एक महत्वपूर्ण नियम याद रखें:

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

अब जब पीवीएस-स्टूडियो की पहली रिलीज़ लंबी हो गई है, तो हमें इससे कोई समस्या नहीं है। हालांकि, पहले कई असफल संस्करण उपयोगकर्ताओं के लिए आए थे।

विजुअल स्टूडियो 2005/2008 वातावरण के लिए प्लग-इन तैनात करने के लिए मुख्य आईडीई रजिस्ट्री शाखा के साथ pkgdef फ़ाइल के लिए regpkg शुरू करने या मैन्युअल रूप से सिस्टम रजिस्ट्री में pkgdef फ़ाइल से सभी कुंजियों को जोड़ने की आवश्यकता होगी। Pkgdef फ़ाइल से रजिस्ट्री में स्वचालित रूप से पंजीकरण जानकारी जोड़ने के लिए एक आदेश का एक उदाहरण (एक पंक्ति में):

 RegPkg.exe /root:Software\Microsoft\VisualStudio\9.0Exp "/pkgdeffile:obj\Debug\PVS-Studio-vs2008.pkgdef" "C:\MyPackage\MyPackage.dll" 

रजिस्ट्री में पंजीकरण की जानकारी जोड़ने के बाद, आपको / सेटअप विकल्प के साथ Visual Studio चलाना होगा, आमतौर पर यह एक नए मॉड्यूल की स्थापना का अंतिम चरण है।

 Devenv.exe /setup 

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

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

वीएसआईएक्स पैकेज

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

 VSIXInstaller.exe MyPackage.vsix 

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

 VSIXInstaller.exe /uninstall: 009084B1-6271-4621-A893-6D72F2B67A4D 

VSIX कंटेनर की सामग्री एक विशेष vsixmanifest फ़ाइल के माध्यम से निर्दिष्ट की जाती है, जिसे प्लगइन प्रोजेक्ट में जोड़ा जाना चाहिए। Vsixmanifest आपको निर्दिष्ट करने की अनुमति देता है:

• मॉड्यूल द्वारा समर्थित स्थापना के लिए विज़ुअल स्टूडियो वातावरण का लक्ष्य संस्करण और संस्करण;
• मॉड्यूल का GUID;
• पंजीकरण के लिए आवश्यक घटक (VSPackage, MEF घटक, टूलबॉक्स नियंत्रण, आदि);
• स्थापित मॉड्यूल (विवरण, लाइसेंस, संस्करण, आदि) के बारे में जानकारी।

कंटेनर में प्रोजेक्ट से अतिरिक्त फ़ाइलों को शामिल करने के लिए, आपको MSBuild प्रोजेक्ट में इन फ़ाइलों के लिए इनवेकविक्स नोड निर्दिष्ट करना होगा (आप गुण विंडो के माध्यम से SolutionExplorer में ऐसी फ़ाइलों का चयन भी कर सकते हैं)।

 <Content Include="MyPackage.pdb"> <IncludeInVSIX>true</IncludeInVSIX> </Content> 

वास्तव में, वीएसआईएक्स फ़ाइल नवीनतम विज़ुअल स्टूडियो एक्सटेंशन (20010 और 2012) के लिए एक पूर्ण-इंस्टॉलर है, जो आपको "एक-क्लिक" विधि का उपयोग करके पैकेज को स्थापित करने की अनुमति देता है। IDE एक्सटेंशन विज़ुअल स्टूडियो गैलरी की आधिकारिक वेबसाइट पर VSIX पैकेज का प्रकाशन उपयोगकर्ता को टूल -> एक्सटेंशन मैनेजर वातावरण के संवाद के माध्यम से ऐसे मॉड्यूल को स्थापित करने की अनुमति देगा।

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

VS2010 में दिखाई देने वाले VSIX- आधारित इंस्टॉलेशन ने एक्सटेंशन को स्थापित करने के लिए उपयोगकर्ता (और डेवलपर) के लिए बहुत आसान बना दिया। और इतना है कि कुछ प्लग-इन डेवलपर्स केवल वीएस2010 के लिए इंस्टॉलर बनाते हैं, बस दृश्य स्टूडियो के पुराने संस्करणों के प्लग-इन और इंस्टॉलर के विकास के साथ गड़बड़ करने के लिए नहीं।

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

पैकेज लोड कुंजी

विजुअल स्टूडियो में लोड किए गए प्रत्येक VSPackage मॉड्यूल में एक अद्वितीय PLK (पैकेज लोड की) कुंजी होनी चाहिए। PLK कुंजी IDE संस्करणों 2005 और 2008 के लिए पैकेज वर्ग की ProvLoadKey विशेषता के माध्यम से सेट की गई है।

 [ProvideLoadKey("Standard", "9.99", "MyPackage", "My Company", 100)] 

विज़ुअल स्टूडियो 2010 के साथ शुरुआत, पीएलके की उपस्थिति और, तदनुसार, प्रोव्लाडकेय विशेषता वैकल्पिक है, हालांकि, इसका उपयोग तब किया जा सकता है यदि विकसित मॉड्यूल एमएसवीएस पर्यावरण के कई संस्करणों के उद्देश्य से हो। PLK कुंजी प्राप्त करने के लिए, आपको Visual Studio Industry Partners पोर्टल पर पंजीकरण करना होगा यानी PLK कुंजी यह सुनिश्चित करती है कि विकास परिवेश में केवल Microsoft प्रमाणित पैकेज डाउनलोड किए जाएं। हालाँकि, Visual Studio SDK स्थापित मशीनों के लिए एक अपवाद है। एसडीके के साथ, एक डेवलपर लाइसेंस कुंजी स्थापित है, जो आपको इसकी पीएलके कुंजी की वैधता की परवाह किए बिना, उपयुक्त विज़ुअल स्टूडियो एसडीके में किसी भी विस्तार मॉड्यूल को लोड करने की अनुमति देता है।

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

विजुअल स्टूडियो के कई संस्करणों के समर्थन के साथ एक्सटेंशन दर्ज करने की विशेषताएं

डिफ़ॉल्ट रूप से, VSPackage टेम्पलेट विजुअल स्टूडियो के वर्तमान विकास संस्करण के लिए एक विस्तार परियोजना बनाता है। हालांकि, यह एक आवश्यक आवश्यकता नहीं है, अर्थात्। एक संस्करण का उपयोग करके पर्यावरण के एक संस्करण के लिए एक एक्सटेंशन विकसित करना संभव है। यह याद रखने योग्य है कि यदि प्रोजेक्ट फ़ाइल स्वचालित रूप से devenv / नवीनीकरण के माध्यम से एक नए संस्करण में अपडेट की जाती है, तो IDE का लक्ष्य संस्करण और, तदनुसार, प्रबंधित प्रबंधित रैपर लाइब्रेरी API अपरिवर्तित रहेंगे, अर्थात। Visual Studio के पिछले संस्करण से।

विज़ुअल स्टूडियो के लक्ष्य संस्करण को बदलने के लिए (या पर्यावरण के इस विशेष संस्करण में प्लगइन को पंजीकृत करने के लिए), आपको DefaultRegistryRoot विशेषता के लिए दिए गए मानों को बदलना होगा (संस्करण 2005 और 2008 के लिए, Visual Studio 2010 के संस्करण के साथ शुरू, इस विशेषता की आवश्यकता नहीं है), या फ़ाइल में लक्ष्य संस्करण को बदलें वीएसआईएक्स प्रकट (2008 के बाद के संस्करणों के लिए)।

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

प्लगइन के लिए आईडीई के लक्ष्य संस्करण को बदलने से पैकेज वर्ग की निम्नलिखित विशेषताएं प्रभावित होती हैं:

• Visual Studio 2010 के साथ शुरू, InstalledProductRegademy विशेषता हस्ताक्षर (बूलियन, स्ट्रिंग, स्ट्रिंग, स्ट्रिंग) के साथ ओवरलोडिंग के निर्माण का समर्थन नहीं करता है;
• DefaultRegistryRoot और ProvLoadKey विशेषताओं को केवल विजुअल स्टूडियो संस्करण के लिए विकसित मॉड्यूल की आवश्यकता नहीं है, जो 10 वीं से कम नहीं है (यानी विज़ुअल स्टूडियो 2010 से शुरू), क्योंकि इसी तरह के मूल्य अब वीएसआईएक्स मेनिफ़ेस्ट फ़ाइल में सेट किए गए हैं;

अनुशंसित लिंक

1. MSDN। प्रायोगिक निर्माण।
2. MSDN। कैसे: एक VSPackage रजिस्टर करें।
3. MSDN। वीएसआईएक्स तैनाती।
4. MSDN। कैसे करें: VSPackage के लिए PLK प्राप्त करें।
5. MZ-उपकरण। Visual Studio .NET एक्स्टेंसिबिलिटी के बारे में संसाधन।
6. MSDN। ऐड-इन्स और विजार्ड बनाना।
7. MSDN। एक्सटेंशन रजिस्टर करने के लिए कस्टम पंजीकरण विशेषता का उपयोग करना।
8. MSDN। शैल (एकीकृत या पृथक)।

विजुअल स्टूडियो ऑटोमेशन ऑब्जेक्ट मॉडल, EnvDTE, और विजुअल स्टूडियो शैल इंटरॉप इंटरफेस

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

परिचय

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

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

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

स्वचालन वस्तु मॉडल संरचना

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

• डिजाइन मॉडल (नई प्रकार की परियोजनाओं का कार्यान्वयन, नई भाषाओं के लिए समर्थन);
• दस्तावेज़ मॉडल (नए प्रकार के दस्तावेज़ और दस्तावेज़ संपादकों का कार्यान्वयन);
• कोड संपादक स्तर मॉडल (नई भाषाओं के लिए विशिष्ट निर्माण के लिए कार्यान्वयन समर्थन);
• परियोजनाओं की विधानसभा प्रक्रिया के मॉडल।

स्वचालन मॉडल विस्तार केवल VSPackage मॉड्यूल के लिए उपलब्ध है।

स्वचालन मॉडल के सभी इंटरफेस को 2 बड़े समूहों में विभाजित किया जा सकता है। समूह 1 - एनवीडीटीई और विज़ुअल स्टूडियो इंटरोप नेमस्पेस इंटरफेस, जो विज़ुअल स्टूडियो वातावरण के सामान्य बुनियादी घटकों जैसे कि संपादकों, टूलबार, इवेंट प्रोसेसिंग सेवाओं आदि के साथ बातचीत को प्रभावित करते हैं। दूसरा समूह - ये एक विशिष्ट डिजाइन मॉडल के इंटरफेस हैं। ऊपर दिए गए आंकड़े में, इंटरफेस के इस समूह को देर से बंधी संपत्तियों से संकेत मिलता है, अर्थात्। इन इंटरफेस को एक अलग गतिशील रूप से भरी हुई लाइब्रेरी में लागू किया गया है। प्रत्येक मानक (यानी विज़ुअल स्टूडियो वितरण में डिफ़ॉल्ट रूप से शामिल) डिज़ाइन मॉडल, जैसे विज़ुअल C ++ या विज़ुअल बेसिक, इन इंटरफेस का अपना कार्यान्वयन है। तीसरे पक्ष के डेवलपर्स भी स्वचालन मॉडल का विस्तार कर सकते हैं,अपने स्वयं के डिजाइन मॉडल के लिए समर्थन जोड़ना और स्वचालन इंटरफेस के उनके कार्यान्वयन प्रदान करना।

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

फिर भी, स्वचालन मॉडल की सार्वभौमिकता के बावजूद, यहां प्रस्तुत सभी इंटरफ़ेस समूहों को विभिन्न प्रकार के एक्सटेंशन में समान रूप से उपयोग नहीं किया जा सकता है। विशेष रूप से, मॉडल की कुछ विशेषताएं बाहरी प्रक्रियाओं के लिए उपलब्ध नहीं होंगी, जैसा कि वे ऐड-इन या VSPackage जैसे विशिष्ट प्रकार के एक्सटेंशन मॉड्यूल से बंधे हैं। इसलिए, विकसित किए जा रहे भविष्य के मॉड्यूल के प्रकार को चुनते हुए, आपको मुख्य रूप से आवश्यक कार्यक्षमता पर ध्यान देना चाहिए।

Microsoft.VisualStudio.Shell.Interop नाम स्थान भी COM इंटरफ़ेस की एक संख्या प्रदान करता है जो आपको प्रबंधित कोड से विज़ुअल स्टूडियो के साथ काम करने का विस्तार और स्वचालित करने की अनुमति देता है। MPF (प्रबंधित पैकेज फ्रेमवर्क) कक्षाएं जो हम पहले इस्तेमाल करते थे, विशेष रूप से VSPackage प्लगइन बनाने के लिए, मूल रूप से इन इंटरफेस का भी उपयोग करते हैं। हालांकि इस तरह के स्वचालन इंटरफेस वीवी पैकेज प्लग-इन के लिए ऊपर चर्चा की गई एनवीडीटीई मॉडल का हिस्सा नहीं हैं, लेकिन वे इस मॉडल को अतिरिक्त कार्यक्षमता के साथ पूरक करते हैं जो अन्य प्रकार के प्लग-इन के लिए उपलब्ध नहीं है।

DTE / DTE2 वस्तुओं के संदर्भ प्राप्त करना

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

विजुअल स्टूडियो वातावरण के विकास के दौरान, कुछ स्वचालन वस्तुओं में परिवर्तन हुए और अतिरिक्त कार्यक्षमता प्राप्त हुई। मौजूदा एंज़डे मॉड्यूल्स के साथ पिछड़े संगतता को बनाए रखने के लिए, पुराने EnvDTE इंटरफेस को अपडेट करने के बजाय, नए EnvDTE80, EnvDTE90, EnvDTE100, और इसी तरह नेमस्पेस बनाए गए थे। इन नए इंटरफेस में से अधिकांश का नाम एनवीडीटीई के समान है, लेकिन अंत में एक सीरियल नंबर के साथ, उदाहरण के लिए, समाधान और समाधान 2। नई परियोजना बनाते समय इंटरफेस के नए संस्करणों का उपयोग करने की सिफारिश की जाती है, क्योंकि उनमें सबसे पूर्ण कार्यक्षमता होती है। यह ध्यान देने योग्य है कि DTE2 इंटरफ़ेस के फ़ील्ड और विधियाँ ऑब्जेक्ट को लौटाती हैं, जिनके प्रकार DTE इंटरफ़ेस के अनुरूप हैं, अर्थात। dte2.Solution तक पहुँचते समय, समाधान दिया जाता है, Solution2 नहीं, क्योंकि यह लग सकता है।

इस तथ्य के बावजूद कि नए EnvDTE80, EnvDTE90, EnvDTE100 नेमस्पेस में कुछ नई कार्यक्षमता है, यह EnvDTE में है कि ऑटोमेशन ऑब्जेक्ट्स के थोक अभी भी स्थित हैं। इसलिए, सभी मौजूदा इंटरफेस तक पहुंच प्राप्त करने के लिए, परियोजना के लिए COM इंटरफेस के प्रबंधित रैपर पुस्तकालयों के सभी संस्करणों को कनेक्ट करना आवश्यक है, साथ ही डीटीई और डीटीई 2 दोनों के लिए लिंक प्राप्त करना आवश्यक है।

जिस तरह से आपको शीर्ष EnvDTE ऑब्जेक्ट का संदर्भ मिलता है, वह आपके द्वारा विकसित किए जा रहे Visual Studio एक्सटेंशन के प्रकार पर निर्भर करता है। अगला, हम 3 प्रकार के एक्सटेंशनों पर विचार करते हैं: ऐड-इन, वीएसपीएसीएज, और एमएसवीएस से स्वतंत्र एक बाहरी प्रक्रिया।

विस्तार में जोड़ें

ऐड-इन प्रकार के एक मॉड्यूल को विकसित करने के मामले में, DTE इंटरफ़ेस का उपयोग ऑनकोनेक्शन विधि में प्राप्त किया जा सकता है, जिसे IDTExtensibility इंटरफ़ेस के लिए लागू किया जाना चाहिए , जो पर्यावरण और ऐड-इन मॉड्यूल के बीच संपर्क की घटनाओं तक पहुंच प्रदान करता है। OnConncetion विधि को उस समय कहा जाता है जब मॉड्यूल को IDE में लोड किया जाता है, जो कि पर्यावरण बूट के तुरंत बाद या उसके पहले कॉल के बाद भी हो सकता है। लिंक प्राप्त करना इस प्रकार है:

 public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom) { _dte2 = (DTE2)application; ... } 

मॉड्यूल के ऐड-इन को पर्यावरण को खुद लोड करने के समय, और IDE के वर्तमान सत्र में पहली बार एक्सेस करने के बाद, दोनों को प्रारंभ किया जा सकता है। इसलिए, जब आप OnConnection विधि में लोड करने के लिए निर्धारित करने के लिए ConnectMode पैरामीटर का उपयोग कर सकते हैं ।

 switch(connectMode) { case ext_ConnectMode.ext_cm_UISetup: ... break; case ext_ConnectMode.ext_cm_Startup: ... break; case ext_ConnectMode.ext_cm_AfterStartup: ... break; case ext_ConnectMode.ext_cm_CommandLine: ... break; } 

जैसा कि आप उदाहरण से देख सकते हैं, ऐड-इन को उसी समय लोड किया जा सकता है जब आईडीई खुद लोड हो रहा हो (ऐड-इन मैनेजर में स्टार्टअप के रूप में स्थापित हो), पहली बार इसे एक्सेस किया जाता है, या जब इसे कमांड लाइन से कॉल किया जाता है। Ext_ConnectMode.ext_cm_UISetup संस्करण को प्लगइन के अस्तित्व के दौरान केवल 1 बार कहा जाता है, इसकी पहली लोडिंग पर। यह विकल्प UI परिवेश में एकीकृत तत्वों के प्रारंभिककरण के लिए अभिप्रेत है (जिसे बाद में और अधिक विस्तार से चर्चा की जाएगी)।

यदि ऐड-इन को Visual Studio (ext_ConnectMode.ext_cm_Startup) के प्रारंभ में लोड किया जाता है, तो हो सकता है कि OnConnect विधि द्वारा नियंत्रण प्राप्त करने के क्षण में वातावरण पूरी तरह से आरंभिक न हो। इस मामले में, पर्यावरण की शुरुआत के अंत तक सीधे डीटीई इंटरफेस की शुरुआत को स्थगित करना बेहतर है। ऐसा करने के लिए, आप IDTExtensibility इंटरफ़ेस द्वारा प्रदान किए गए OnStartupComplete हैंडलर का उपयोग कर सकते हैं।

 public void OnStartupComplete(ref Array custom) { ... } 

Vspackage एक्सटेंशन

VSPackage के विस्तार के लिए, DTE इंटरफ़ेस को पैकेज क्लास के गेटस्वेस्ट पद्धति का उपयोग करके एक वैश्विक विज़ुअल स्टूडियो सेवा के रूप में प्राप्त किया जा सकता है:

 DTE dte = MyPackage.GetService(typeof(DTE)) as DTE; 

कृपया ध्यान दें कि यदि दृश्य स्टूडियो पूरी तरह से लोड नहीं किया गया है और आरंभिक नहीं है, तो गेटस्वे विधि भी अशक्त हो सकती है, यह तथाकथित "ज़ोंबी" स्थिति में है। इस स्थिति की सही हैंडलिंग के लिए, आप DTE इंटरफ़ेस का लिंक प्राप्त करना स्थगित कर सकते हैं, जब तक कि इसकी आवश्यकता न हो। यदि आपको आरंभिक विधि के अंदर सीधे डीटीई लिंक तक पहुंचने की आवश्यकता है, तो आप IVsShellPropertyEvents इंटरफ़ेस (इसमें से हमारे उपवर्ग पैकेज को इनहेरिट कर सकते हैं) का उपयोग कर सकते हैं, और फिर लिंक को OnShellPropertyEhange हैंडलर में प्राप्त कर सकते हैं।

 DTE dte; uint cookie; protected override void Initialize() { base.Initialize(); IVsShell shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) ErrorHandler.ThrowOnFailure( shellService.AdviseShellPropertyChanges(this,out cookie)); ... } public int OnShellPropertyChange(int propid, object var) { // when zombie state changes to false, finish package initialization if ((int)__VSSPROPID.VSSPROPID_Zombie == propid) { if ((bool)var == false) { this.dte = GetService(typeof(SDTE)) as DTE; IVsShell shellService = GetService(typeof(SVsShell)) as IVsShell; if (shellService != null) ErrorHandler.ThrowOnFailure( shellService.UnadviseShellPropertyChanges(this.cookie) ); this.cookie = 0; } } return VSConstants.S_OK; } 

यह ध्यान दिया जाना चाहिए कि विज़ुअल स्टूडियो के विभिन्न संस्करणों में, IDE की शुरुआत में VSPackage मॉड्यूल को शुरू करने की प्रक्रिया अलग-अलग तरीकों से हो सकती है। तो VS2005 और VS2008 में, उनके अपेक्षाकृत तेजी से लोड होने के कारण, DTE तक पहुंचने के प्रयास को शून्य वापस करने की गारंटी दी जाएगी। Visual Studio 2010 में, ऐसा लग सकता है कि प्रारंभ में () आप पहले से ही DTE तक पहुँच सकते हैं। हालाँकि, यह धारणा भ्रामक है, क्योंकि DTE के इस तरह के उपयोग से "फ़्लोटिंग" हार्ड-टू-कैच एरर का आभास होता है, और लिंक प्राप्त करने के समय DTE पूरी तरह से इनिशियलाइज़ नहीं होता है। इसलिए, Visual Studio के सभी संस्करणों के लिए ऊपर वर्णित IDE लोड स्थिति को संभालने के लिए सार्वभौमिक विधि की उपेक्षा न करें।

स्वतंत्र बाहरी प्रक्रिया

स्वचालन मॉडल में दृश्य स्टूडियो के लिए DTE एक शीर्ष स्तर का अमूर्त है। बाहरी एप्लिकेशन से इसे लिंक करने के लिए, आपको इसके ProgID COM पहचानकर्ता का उपयोग करने की आवश्यकता है, उदाहरण के लिए, Visual Studio 2010 के लिए VisualStudio.DTE.10.0। यहां एक नए IDE उदाहरण को इनिशियलाइज़ करने और इसके GTE इंटरफ़ेस के लिए लिंक प्राप्त करने का एक उदाहरण है।

 // Get the ProgID for DTE 8.0. System.Type t = System.Type.GetTypeFromProgID( "VisualStudio.DTE.10.0", true); // Create a new instance of the IDE. object obj = System.Activator.CreateInstance(t, true); // Cast the instance to DTE2 and assign to variable dte. EnvDTE80.DTE2 dte = (EnvDTE80.DTE2)obj; // Show IDE Main Window dte.MainWindow.Activate(); 

व्यवहार उदाहरण में, हम वास्तव में CreateInstance पद्धति का उपयोग करके devenv.exe प्रक्रिया शुरू करके एक नई DTE ऑब्जेक्ट बनाते हैं। इस स्थिति में, पर्यावरण के GUI विंडो को एक्टिवेट विधि को कॉल करने के बाद ही प्रदर्शित किया जाएगा। दृश्य स्टूडियो के पहले से चल रहे उदाहरण से DTE का लिंक प्राप्त करने का सबसे सरल तरीका इस तरह दिखेगा:

 EnvDTE80.DTE2 dte2; dte2 = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject( "VisualStudio.DTE.10.0"); 

हालाँकि, यदि IDE के कई उदाहरण लॉन्च किए गए थे, तो GetActiveObject पद्धति केवल इंटरफ़ेस को पर्यावरण के पहले चलने वाले उदाहरण के इंटरफ़ेस पर लौटाएगी। इसकी प्रक्रिया के पीआईडी ​​द्वारा विज़ुअल स्टूडियो के चल रहे उदाहरण से डीटीई इंटरफ़ेस प्राप्त करने के संभावित विकल्पों में से एक पर विचार करें।

 using EnvDTE80; using System.Diagnostics; using System.Runtime.InteropServices; using System.Runtime.InteropServices.ComTypes; [DllImport("ole32.dll")] private static extern void CreateBindCtx(int reserved, out IBindCtx ppbc); [DllImport("ole32.dll")] private static extern void GetRunningObjectTable(int reserved, out IRunningObjectTable prot); public static DTE2 GetByID(int ID) { //rot entry for visual studio running under current process. string rotEntry = String.Format("!VisualStudio.DTE.10.0:{0}", ID); IRunningObjectTable rot; GetRunningObjectTable(0, out rot); IEnumMoniker enumMoniker; rot.EnumRunning(out enumMoniker); enumMoniker.Reset(); IntPtr fetched = IntPtr.Zero; IMoniker[] moniker = new IMoniker[1]; while (enumMoniker.Next(1, moniker, fetched) == 0) { IBindCtx bindCtx; CreateBindCtx(0, out bindCtx); string displayName; moniker[0].GetDisplayName(bindCtx, null, out displayName); if (displayName == rotEntry) { object comObject; rot.GetObject(moniker[0], out comObject); return (EnvDTE80.DTE2)comObject; } } return null; } 

यहां हमें DTE इंटरफ़ेस मिला, पहचानकर्ता द्वारा COM ऑब्जेक्ट्स (ROT, रनिंग ऑब्जेक्ट टेबल) को चलाने की तालिका में हमारे लिए आवश्यक IDE उदाहरण की पहचान करना। अब हम उदाहरण के लिए चल रहे किसी भी Visual Studio उदाहरण के लिए DTE प्राप्त कर सकते हैं:

 Process Devenv; ... //Get DTE by Process ID EnvDTE80.DTE2 dte2 = GetByID(Devenv.Id); 

इसके अतिरिक्त, प्रोजेक्ट-विशिष्ट इंटरफ़ेस (कस्टम मॉडल एक्सटेंशन सहित) प्राप्त करने के लिए, उदाहरण के लिए, CSharpProjects प्रोजेक्ट मॉडल के लिए, मौजूदा DTE ऑब्जेक्ट के माध्यम से, आप GetObject विधि का उपयोग कर सकते हैं:

 Projects projects = (Projects)dte.GetObject("CSharpProjects"); 

GetObject विधि मानक प्रोजेक्ट ऑब्जेक्ट्स की कई परियोजनाओं को हमारे पास लौटाएगी, जिनमें से प्रत्येक, स्वचालन मॉडल के लिए सामान्य गुणों के अलावा, इस मॉडल के लिए एक विशिष्ट प्रकार के लिंक को शामिल करेगा।

विजुअल स्टूडियो टेक्स्ट एडिटर डॉक्युमेंट्स

स्वचालन मॉडल TextDocument पाठ दस्तावेज़ इंटरफ़ेस के माध्यम से विज़ुअल स्टूडियो पाठ दस्तावेज़ों को परिभाषित करता है । स्रोत C / C ++ फ़ाइलें पर्यावरण द्वारा पाठ दस्तावेज़ों के रूप में खोली जाती हैं। TextDocument एक सामान्य स्वचालन मॉडल दस्तावेज़ इंटरफ़ेस ( दस्तावेज़ इंटरफ़ेस ) पर आधारित है, जो विज़ुअल स्टूडियो के संपादक या डिजाइनर में खोली गई किसी भी फ़ाइल का वर्णन करता है। एक टेक्स्ट डॉक्यूमेंट ऑब्जेक्ट का संदर्भ डॉक्यूमेंट ऑब्जेक्ट के ऑब्जेक्ट फ़ील्ड के माध्यम से प्राप्त किया जा सकता है। उदाहरण के लिए, हम एक IDE पाठ संपादक से एक सक्रिय (यानी, खुला और फोकस होने) दस्तावेज़ के लिए एक पाठ दस्तावेज़ प्राप्त करते हैं।

 EnvDTE.TextDocument objTextDoc = (TextDocument)PVSStudio.DTE.ActiveDocument.Object("TextDocument"); 

दस्तावेज़ संपादन

TextSelection इंटरफ़ेस आपको पाठ को संशोधित करने और चयन का प्रबंधन करने की अनुमति देता है। इस इंटरफ़ेस के तरीके दृश्य स्टूडियो पाठ संपादक की कार्यक्षमता को दर्शाते हैं, अर्थात्। आपको UI में दिखाई देने वाले टेक्स्ट के साथ सीधे काम करने की अनुमति देता है।

 EnvDTE.TextDocument Doc = (TextDocument)PVSStudio.DTE.ActiveDocument.Object(string.Empty); Doc.Selection.SelectLine(); TextSelection Sel = Doc.Selection; int CurLine = Sel.TopPoint.Line; String Text = Sel.Text; Sel.Insert("test\r\n"); 

इस उदाहरण में, हम कर्सर के नीचे पाठ की एक पंक्ति का चयन करते हैं, चयनित पाठ को पढ़ते हैं और इसे स्ट्रिंग 'टेस्ट' से बदल देते हैं।

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

यहां EditPoint का उपयोग करके संपादन का एक उदाहरण है, जिसमें संपादन की वर्तमान पंक्ति (एक कर्सर के साथ एक पंक्ति) के अंत में पाठ जोड़ा जाता है।

 objEditPt = objTextDoc.StartPoint.CreateEditPoint(); int lineNumber = objTextDoc.Selection.CurrentLine; objEditPt.LineDown(lineNumber - 1); EditPoint objEditPt2 = objTextDoc.StartPoint.CreateEditPoint(); objEditPt2.LineDown(lineNumber - 1); objEditPt2.CharRight(objEditPt2.LineLength); String line = objEditPt.GetText(objEditPt.LineLength); String newLine = line + "test"; objEditPt.ReplaceText(objEditPt2, newLine, (int)vsEPReplaceTextOptions.vsEPReplaceTextKeepMarkers); 

दस्तावेज़ नेविगेशन

VSPackage जैसे मॉड्यूल के लिए, कई वैश्विक पर्यावरण सेवाएँ उपलब्ध हैं जो आपको दस्तावेज़ खोलने और देखने की अनुमति देती हैं। सेवा डेटा पैकेज के प्रबंधित पैकेज फ्रेमवर्क का उपयोग करके प्राप्त किया जा सकता है। GGGlobalService () विधि। ध्यान दें कि यहाँ उपयोग किए गए इंटरफ़ेस EnvDTE मॉडल का हिस्सा नहीं हैं, केवल पैकेज एक्सटेंशन ऑब्जेक्ट ऑब्जेक्ट के लिए उपलब्ध हैं और इसलिए इसे अन्य प्रकार के Visual Studio एक्सटेंशन में उपयोग नहीं किया जा सकता है। फिर भी, ये सेवाएं उपयोग के लिए सुविधाजनक हैं जब ऊपर वर्णित दस्तावेज़ इंटरफ़ेस के साथ आईडीई दस्तावेजों के साथ काम करते हैं, इसलिए हम इस अनुभाग में उन पर अधिक विस्तार से ध्यान देंगे। IVsUIShellOpenDocument

इंटरफ़ेस आपको खुले पर्यावरण दस्तावेजों की स्थिति की निगरानी करने की अनुमति देता है। यहां एक फ़ाइल खोलने के लिए पथ के माध्यम से एक दस्तावेज खोलने का एक उदाहरण है।

 String path = "C:\Test\test.cpp"; IVsUIShellOpenDocument openDoc = Package.GetGlobalService(typeof(IVsUIShellOpenDocument)) as IVsUIShellOpenDocument; IVsWindowFrame frame; Microsoft.VisualStudio.OLE.Interop.IServiceProvider sp; IVsUIHierarchy hier; uint itemid; Guid logicalView = VSConstants.LOGVIEWID_Code; if (ErrorHandler.Failed( openDoc.OpenDocumentViaProject(path, ref logicalView, out sp, out hier, out itemid, out frame)) || frame == null) { return; } object docData; frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out docData); 

फ़ाइल या तो एक नए संपादक में खोली जाएगी, या उसके संपादक को फ़ोकस प्राप्त होगा यदि वह पहले ही खोला जा चुका हो। इसके बाद, हमें एक ओपन डॉक्यूमेंट से एक टेक्स्ट बफर टाइप VsTextBuffer मिलता है ।

 // Get the VsTextBuffer VsTextBuffer buffer = docData as VsTextBuffer; if (buffer == null) { IVsTextBufferProvider bufferProvider = docData as IVsTextBufferProvider; if (bufferProvider != null) { IVsTextLines lines; ErrorHandler.ThrowOnFailure(bufferProvider.GetTextBuffer( out lines)); buffer = lines as VsTextBuffer; Debug.Assert(buffer != null, "IVsTextLines does not implement IVsTextBuffer"); if (buffer == null) { return; } } } 

IVsTextManager इंटरफ़ेस आपको उन सभी टेक्स्ट बफ़र्स को प्रबंधित करने की अनुमति देता है जो पर्यावरण में सक्रिय हैं। उदाहरण के लिए, आप निम्न के द्वारा प्राप्त बफ़र में NavigateToLineAndColumn पाठ प्रबंधक विधि का उपयोग करके एक पाठ दस्तावेज़ में नेविगेट कर सकते हैं:

 IVsTextManager mgr = Package.GetGlobalService(typeof(VsTextManagerClass)) as IVsTextManager; mgr.NavigateToLineAndColumn(buffer, ref logicalView, line, column, line, column); 

सदस्यता और घटना से निपटने

स्वचालन वस्तु घटनाओं को DTE.Events के मूल तत्व में परिभाषित किया गया है। इसी समय, इस इंटरफ़ेस में उपयोगकर्ता-परिभाषित लोगों सहित मानक (सामान्य) IDE ईवेंट (CommandEvents, SolutionEvents), और विभिन्न पर्यावरण तत्वों (व्यक्तिगत प्रकार की परियोजनाएं, संपादक, उपकरण, आदि) की घटनाओं के लिंक होते हैं। समान स्वचालन ऑब्जेक्ट के लिए लिंक प्राप्त करने के लिए, आप GetObject विधि का उपयोग कर सकते हैं।

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

हम VCProjectEngineEvents इंटरफ़ेस द्वारा परिभाषित Visual C ++ प्रोजेक्ट मॉडल की घटनाओं के लिए एक लिंक प्राप्त करेंगे और समाधान पेड़ से एक तत्व को हटाने के लिए एक हैंडलर असाइन करेंगे:

 VCProjectEngineEvents m_ProjectItemsEvents = PVSStudio.DTE.Events.GetObject("VCProjectEngineEventsObject") as VCProjectEngineEvents; m_ProjectItemsEvents.ItemRemoved += new _dispVCProjectEngineEvents_ItemRemovedEventHandler( m_ProjectItemsEvents_ItemRemoved); 

एमडीआई विंडो इवेंट्स

आप एक पर्यावरण विंडो में मानक MDI घटनाओं को संसाधित करने के लिए Events.WindowEvents इंटरफ़ेस का उपयोग कर सकते हैं। यह इंटरफ़ेस आपको विंडो के लिए एक अलग हैंडलर (EnvDTE.Window इंटरफ़ेस के माध्यम से परिभाषित) और पर्यावरण में सभी विंडो के लिए एक सामान्य हैंडलर को असाइन करने की अनुमति देता है।

पर्यावरण के लिए खिड़कियों के बीच स्विच करने के लिए एक सामान्य हैंडलर असाइन करना:

 WindowEvents WE = PVSStudio.DTE.Events.WindowEvents; WE.WindowActivated += new _dispWindowEvents_WindowActivatedEventHandler( Package.WE_WindowActivated); 

वर्तमान में सक्रिय विंडो के लिए स्विच करने के लिए एक हैंडलर को सौंपना WindowEvents प्रॉपर्टी इंडेक्सर के माध्यम से संभव है:

 WindowEvents WE = m_dte.Events.WindowEvents[MyPackage.DTE.ActiveWindow]; WE.WindowActivated += new _dispWindowEvents_WindowActivatedEventHandler( MyPackage.WE_WindowActivated); 

टीम आईडीई इवेंट्स

टीमों के साथ प्रत्यक्ष काम और स्वचालन मॉडल के माध्यम से उनके विस्तार पर एक अलग अनुभाग में चर्चा की जाती है। यहां हम आदेशों के प्रसंस्करण की घटनाओं (लेकिन आदेशों के निष्पादन नहीं) के मुद्दे को संबोधित करेंगे। ईवेंट्स को हैंडलर असाइन करना ईवेंट्स का उपयोग करना संभव है। MDE विंडो इवेंट्स की प्रोसेसिंग के समान CommandEvents प्रॉपर्टी, आपको सभी IDE कमांड्स और इंडेक्सर का उपयोग करके एक विशिष्ट कमांड दोनों के लिए एक हैंडलर असाइन करने की अनुमति देता है।

कमांड पूरा होने की घटना के लिए एक पर्यावरण कमांड हैंडलर सौंपना:

 CommandEvents CEvents = DTE.Events.CommandEvents; CEvents.AfterExecute += new _dispCommandEvents_AfterExecuteEventHandler(C_AfterExecute); 

किसी विशेष कमांड को हैंडलर देने के लिए, आपको पहले इस कमांड को पहचानना होगा। प्रत्येक पर्यावरण कमांड को GUID: ID की एक जोड़ी से पहचाना जाता है, और उपयोगकर्ता कमांड के लिए, ये मान सीधे सेट किए जाते हैं जब डेवलपर कमांड को एकीकृत करता है, उदाहरण के लिए, कमांड टेबल (वीएससीटी) के माध्यम से। विजुअल स्टूडियो में एक विशेष डिबगिंग मोड है जो आपको किसी भी कमांड के पहचानकर्ताओं को खोजने की अनुमति देता है। इस मोड को सक्रिय करने के लिए, आपको सिस्टम रजिस्ट्री में निम्न कुंजी जोड़ने की आवश्यकता है (उदाहरण के लिए Visual Studio 2010):

 [HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\General] "EnableVSIPLogging"=dword:00000001 

इस कुंजी के साथ पर्यावरण को फिर से शुरू करने के बाद, CTRL + SHIFT कुंजी के साथ आयोजित माउस बॉक्स पर (कभी-कभी यह तुरंत काम नहीं करता है तो तुरंत काम करता है) डायलॉग बॉक्स को कॉल करता है जिसमें कमांड के सभी आंतरिक पहचानकर्ता सूचीबद्ध होते हैं। इनमें से, हम गाइड और CmdID के मूल्यों में रुचि रखते हैं। File.NewFile कमांड के लिए हैंडलर असाइन करने का एक उदाहरण:

 CommandEvents CEvents = DTE.Events.CommandEvents[ "{5EFC7975-14BC-11CF-9B2B-00AA00573819}", 221]; CEvents.AfterExecute += new _dispCommandEvents_AfterExecuteEventHandler(C_AfterExecute); 

इस तरह से असाइन किया गया एक हैंडलर कमांड निष्पादित होने के बाद नियंत्रण लेता है।

 void C_AfterExecute(string Guid, int ID, object CustomIn, object CustomOut) { ... } 

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

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

परियोजनाओं और समाधानों की इवेंट हैंडलिंग (VSPackage मॉड्यूल के लिए)

Microsoft.VisualStudio.Shell.Interop नामस्थान से कई इंटरफेस पर विचार करें जो आपको विजुअल स्टूडियो में परियोजनाओं और समाधानों से सीधे घटनाओं को संसाधित करने की अनुमति देता है। हालांकि ये इंटरफेस सीधे एनवीडीटीई ऑटोमेशन मॉडल से संबंधित नहीं हैं, इन्हें वीएस पैकेज एक्सटेंशन मॉड्यूल के मुख्य वर्ग (यानी, प्रबंधित पैकेज फ्रेमवर्क से पैकेज से विरासत में प्राप्त वर्ग) द्वारा लागू किया जा सकता है। इसलिए, इस प्रकार के प्लग-इन को विकसित करने के मामले में, ये इंटरफेस डीटीई ऑब्जेक्ट द्वारा प्रदान किए गए मूल सेट को आसानी से पूरक करते हैं। यह, वैसे, एमपीएफ का उपयोग करके एक पूर्ण प्लगइन विकसित करने के पक्ष में एक और तर्क है।

इंटरफ़ेस IVsSolutionEventsविजुअल स्टूडियो 2005 से शुरू होने वाले विज़ुअल स्टूडियो के संस्करणों में पैकेज से विरासत में प्राप्त वर्ग द्वारा लागू किया जा सकता है और उन पर आधारित अलग-अलग \ एकीकृत गोले (विजुअल स्टूडियो आइसोलेटेड \ इंटीग्रेटेड शेल)। यह इंटरफ़ेस आपको OnAfterCloseSolution, OnBeforeCloseProject, OnQueryCloseSolution, आदि जैसे इंटरफ़ेस विधियों को लागू करके परियोजनाओं के विकास में लोडिंग, अनलोडिंग, खोलने और बंद करने और विकास के वातावरण में संपूर्ण समाधानों को ट्रैक करने की अनुमति देता है। उदाहरण के लिए:

  public int OnAfterLoadProject(IVsHierarchy pStubHierarchy, IVsHierarchy pRealHierarchy) { //your custom handler code return VSConstants.S_OK; } 

जैसा कि आप देख सकते हैं, इस पद्धति को इनपुट के रूप में लोड किए गए प्रोजेक्ट के अनुरूप IVsHierarchy के पदानुक्रम का ऑब्जेक्ट प्राप्त होता है। विज़ुअल स्टूडियो के डिज़ाइन मॉडल के साथ बातचीत पर इस तरह की वस्तुओं के साथ काम पर अलग से चर्चा की जाएगी।

इंटरफ़ेस IVsSolutionLoadEventsऊपर वर्णित इंटरफ़ेस के समान, पैकेज सबक्लास द्वारा लागू किया जाना चाहिए और विज़ुअल स्टूडियो 2010 से शुरू होने वाले वातावरण के संस्करणों के लिए उपलब्ध है। यह इंटरफ़ेस ऐसे दिलचस्प क्षणों को ट्रैक करने की अनुमति देगा जैसे कि बैच मोड में परियोजनाओं के समूह को लोड करना और समाधान के तरीके को स्थगित करना (पृष्ठभूमि) को लोड करना (तरीके OnBeforeLoadProjectBatch और OnBeforeBackgroundSolutionBadins)। , साथ ही पृष्ठभूमि लोडिंग (OnAfterBackgroundSolutionLoadComplete विधि) के पूरा होने को पकड़ें। ये हैंडलर अपरिहार्य हो सकते हैं यदि आपके प्लग-इन को इसके आरंभ के तुरंत बाद कुछ कोड निष्पादित करने की आवश्यकता होती है, और साथ ही इसमें लोड की गई परियोजनाओं / समाधानों से निर्भरता होती है। लोड करने के लिए एक पूर्ण समाधान की प्रतीक्षा किए बिना इस तरह के कोड के निष्पादन के कारण गलत (अपूर्ण) परिणाम हो सकता हैपरियोजना का पेड़ पूरी तरह से बनाया नहीं गया है, और क्रम अपवादों के लिए।

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

एक बार फिर, हम इस तथ्य पर आपका ध्यान आकर्षित करते हैं कि इन इंटरफेस में वर्णित तरीकों के लिए सही ढंग से काम करने के लिए, आपको अपने मुख्य प्लगइन वर्ग को उनसे प्राप्त करने की आवश्यकता है:

 class MyPackage: Package, IVsSolutionLoadEvents, IVsSolutionEvents { //Implementation of Package, IVsSolutionLoadEvents, IVsSolutionEvents ... } 

विजुअल स्टूडियो कलर स्कीम सपोर्ट

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

"पकड़ने" रंग सेटिंग्स के लिए, आप पर्यावरण विधि GetVSSysColorEx इंटरफ़ेस का उपयोग कर सकते हैं IVsUIShell2 दृश्य स्टूडियो इंटरॉप की। यह इंटरफ़ेस केवल VSPackage मॉड्यूल के लिए उपलब्ध होगा।

 IVsUIShell2 vsshell = this.GetService(typeof(SVsUIShell)) as IVsUIShell2; 

GetVSSysColorEx विधि में पारित __VSSYSCOLOREX और __VSSYSCOLOREX3 गणना का उपयोग करके, आप Visual Studio में स्थापित इसके प्रत्येक इंटरफ़ेस घटक का वर्तमान रंग प्राप्त कर सकते हैं। उदाहरण के लिए, हम संदर्भ मेनू की पृष्ठभूमि के पास ढाल रंगों में से एक प्राप्त करते हैं:

 uint Win32Color; vsshell.GetVSSysColorEx((int)__VSSYSCOLOREX3.VSCOLOR_COMMANDBAR_MENU_BACKGROUND_GRADIENTBEGIN, out Win32Color); Color BackgroundGradient1 = ColorTranslator.FromWin32((int)Win32Color); 

अब आप अपने स्वयं के संदर्भ मेनू को "रंग" करने के लिए परिणामी रंग ऑब्जेक्ट का उपयोग कर सकते हैं। उस क्षण को निर्धारित करने के लिए जब आपके यूआई घटकों की रंग योजना को अद्यतन करना आवश्यक है, आप उदाहरण के लिए, इस खंड में ऊपर वर्णित अनुसार, इसी हैंडलर की सदस्यता लेकर पर्यावरण सेटिंग्स स्क्रीन (टूल -> विकल्प) को खोलने वाली कमांड की घटनाओं का उपयोग कर सकते हैं।

यदि, किसी कारण से, आपके पास IVsUIShell2 ऑब्जेक्ट तक पहुंच नहीं है (उदाहरण के लिए, जब एक प्लगइन जो कि एक VSPackage प्रकार का नहीं है) विकसित कर रहा है, लेकिन आपको अभी भी विज़ुअल स्टूडियो की रंग योजना का समर्थन करने की आवश्यकता है, तो आप अनुकूलन इंटरफेस को दरकिनार करके व्यक्तिगत यूआई घटकों के रंग मूल्यों को ले सकते हैं, सीधे रजिस्ट्री से। इस लेख में हम इस पद्धति पर विस्तार से ध्यान नहीं देंगे, लेकिन आप यहां से डाउनलोड कर सकते हैंविजुअल स्टूडियो एक स्वतंत्र और खुला स्रोत रंग संपादन उपयोगिता है। यह उपयोगिता C # में लिखी गई है और इसमें प्रबंधित अनुप्रयोगों से विजुअल स्टूडियो 2012 कलर थीम को पढ़ने और संशोधित करने के लिए सभी आवश्यक कोड शामिल हैं।

मल्टी-थ्रेडेड एप्लिकेशन में COM इंटरफेस के साथ सहभागिता

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

हालाँकि Visual Studio स्वचालन ऑब्जेक्ट मॉडल थ्रेड सुरक्षित नहीं है, लेकिन यह बहु-थ्रेडेड अनुप्रयोगों के साथ अंतर प्रदान करता है। Visual Studio अनुप्रयोग COM (घटक ऑब्जेक्ट मोड) सर्वर है। COM क्लाइंट (इस मामले में, हमारे एक्सटेंशन मॉड्यूल) को स्ट्रीम-असुरक्षित सर्वर को संबोधित करने के लिए, COM तकनीक एसटीए (एकल-थ्रेडेड अपार्टमेंट) मॉडल के रूप में जाना जाने वाला एक तंत्र प्रदान करता है। COM अपार्टमेंट के संदर्भ में एक तार्किक कंटेनर एक प्रक्रिया के भीतर है जिसमें वस्तुएं और धागे आम क्रॉस-थ्रेड एक्सेस अधिकारों को साझा करते हैं। एसटीए आपको इस तरह के कंटेनर में केवल एक स्ट्रीम शामिल करने की अनुमति देता है, लेकिन असीमित संख्या में ऑब्जेक्ट। एसटीए में ऐसी धारा-असुरक्षित वस्तुओं के लिए अन्य धाराओं से अपील को संदेशों में परिवर्तित किया जाता है और संदेश कतार में रखा जाता है।तब संदेश क्रमिक रूप से इस कतार से पुनर्प्राप्त किए जाते हैं और STA में स्थित थ्रेड द्वारा विधि कॉल में परिवर्तित हो जाते हैं, जिससे केवल एक थ्रेड से इन असुरक्षित वस्तुओं को सर्वर पर एक्सेस करना संभव हो जाता है।

प्रबंधित कोड में अपार्टमेंट तंत्र का उपयोग करना

.NET फ्रेमवर्क स्वयं अपार्टमेंट COM तंत्र का उपयोग नहीं करता है। इसलिए, जब COM की स्थिति में COM ऑब्जेक्ट पर एक प्रबंधित एप्लिकेशन कॉल करता है, तो CLR (सामान्य भाषा रनटाइम) को एक अपार्टमेंट कंटेनर बनाना और प्रारंभ करना होगा। एक प्रबंधित स्ट्रीम एमटीए (बहु-थ्रेडेड अपार्टमेंट, एक कंटेनर, जो एसटीए के विपरीत, एक ही समय में कई धाराएं शामिल कर सकता है) बना सकता है और दर्ज कर सकता है, और एसटीए, और, डिफ़ॉल्ट रूप से, धारा एमटीए में लॉन्च की जाएगी। सीधे धागा शुरू करने से पहले आप थ्रेड सेट कर सकते हैं।

 Thread t = new Thread(ThreadProc); t.SetApartmentState(ApartmentState.STA); ... t.Start(); 

क्योंकि अपार्टमेंट को पहले से चल रहे धागे के लिए नहीं बदला जा सकता है, इसे STA में प्रबंधित अनुप्रयोगों में मुख्य धागे में स्थापित करने के लिए, आपको STAThread विशेषता का उपयोग करने की आवश्यकता है:

 [STAThread] static void Main(string[] args) {...} 

प्रबंधित वातावरण में COM इंटरफेस तक पहुंच के लिए त्रुटि फ़िल्टर का कार्यान्वयन

चूंकि STA में COM सर्वर के सभी कॉल को क्रमबद्ध किया जाता है, कॉलिंग क्लाइंट में से एक को अवरुद्ध या अस्वीकार किया जा सकता है जब सर्वर व्यस्त रहता है, अन्य कॉल को संसाधित करता है, या एक अन्य धागा पहले से ही अपार्टमेंट कंटेनर में है। मामले में जब COM सर्वर क्लाइंट के अनुरोध को अस्वीकार करता है, तो .NET COM Interop सिस्टम के अपवादों को फेंक देता है। System.untime.InteropServices.COMException ("संदेश फ़िल्टर इंगित करता है कि एप्लिकेशन व्यस्त है")।

विजुअल स्टूडियो (VSPackage, Add-In) या एक मैक्रो में निर्मित मॉड्यूल को विकसित करने के मामले में, नियंत्रण आमतौर पर इसे पर्यावरण स्ट्रीम के मुख्य एसटीए यूआई से स्थानांतरित किया जाता है (अवरोधन की घटनाओं, प्रसंस्करण राज्य परिवर्तन आदि)। इस मुख्य सूत्र से COM स्वचालन इंटरफेस तक पहुँच सुरक्षित है। हालांकि, यदि आप अन्य पृष्ठभूमि थ्रेड बनाने और उनसे एनवीडीटीई इंटरफेस को कॉल करने की योजना बनाते हैं (उदाहरण के लिए, लंबी गणना जो कि पर्यावरण इंटरफ़ेस का एक लटका हो सकता है), तो सर्वर द्वारा अस्वीकार किए गए प्रसंस्करण कॉल के लिए एक तंत्र को लागू करना उचित है।

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

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

 [ComImport()] [Guid("00000016-0000-0000-C000-000000000046")] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IMessageFilter { [PreserveSig] int HandleInComingCall( int dwCallType, IntPtr hTaskCaller, int dwTickCount, IntPtr lpInterfaceInfo); [PreserveSig] int RetryRejectedCall( IntPtr hTaskCallee, int dwTickCount, int dwRejectType); [PreserveSig] int MessagePending( IntPtr hTaskCallee, int dwTickCount, int dwPendingType); } class MessageFilter : MarshalByRefObject, IDisposable, IMessageFilter { [DllImport("ole32.dll")] [PreserveSig] private static extern int CoRegisterMessageFilter( IMessageFilter lpMessageFilter, out IMessageFilter lplpMessageFilter); private IMessageFilter oldFilter; private const int SERVERCALL_ISHANDLED = 0; private const int PENDINGMSG_WAITNOPROCESS = 2; private const int SERVERCALL_RETRYLATER = 2; public MessageFilter() { //Starting IMessageFilter for COM objects int hr = MessageFilter.CoRegisterMessageFilter( (IMessageFilter)this, out this.oldFilter); System.Diagnostics.Debug.Assert(hr >= 0, "Registering COM IMessageFilter failed!"); } public void Dispose() { //disabling IMessageFilter IMessageFilter dummy; int hr = MessageFilter.CoRegisterMessageFilter(this.oldFilter, out dummy); System.Diagnostics.Debug.Assert(hr >= 0, "De-Registering COM IMessageFilter failed!") System.GC.SuppressFinalize(this); } int IMessageFilter.HandleInComingCall(int dwCallType, IntPtr threadIdCaller, int dwTickCount, IntPtr lpInterfaceInfo) { // Return the ole default (don't let the call through). return MessageFilter.SERVERCALL_ISHANDLED; } int IMessageFilter.RetryRejectedCall(IntPtr threadIDCallee, int dwTickCount, int dwRejectType) { if (dwRejectType == MessageFilter.SERVERCALL_RETRYLATER) { // Retry the thread call immediately if return >=0 & // <100. return 150; //waiting 150 mseconds until retry } // Too busy; cancel call. SERVERCALL_REJECTED return -1; //Call was rejected by callee. //(Exception from HRESULT: 0x80010001 (RPC_E_CALL_REJECTED)) } int IMessageFilter.MessagePending( IntPtr threadIDCallee, int dwTickCount, int dwPendingType) { // Perform default processing. return MessageFilter.PENDINGMSG_WAITNOPROCESS; } } 

अब हम बैकग्राउंड थ्रेड से COM इंटरफेस के साथ काम करते समय MessageFilter का उपयोग कर सकते हैं:

 using (new MessageFilter()) { //COM-interface dependent code ... } 

अनुशंसित लिंक

1. MSDN। स्वचालन असेंबलियों और DTE2 ऑब्जेक्ट को संदर्भित करना।
2. MSDN। कार्यात्मक स्वचालन समूह।
3. Microsoft Development Network. FAQ — Visual Studio .
4. MZ-Tools. HOWTO: Use correctly the OnConnection method of a Visual Studio add-in.
5. The Code Project. Understanding The COM Single-Threaded Apartment.
6. MZ-Tools. HOWTO: Add an event handler from a Visual Studio add-in .
7. Dr. eX's Blog. Using EnableVSIPLogging to identify menus and commands with VS 2005 + SP1.
8. MSDN. Visual Studio Interop Assemblies.

Visual Studio

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

परिचय

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

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

कमांड का उपयोग करना

कोई भी IDE कमांड, IDE इंटरफ़ेस में इसकी प्रस्तुति (या इसके अभाव) की परवाह किए बिना, कमांड विंडो और तत्काल विंडो के माध्यम से सीधे निष्पादित किया जा सकता है, साथ ही कंसोल से एप्लिकेशन शुरू करते समय कमांड लाइन तर्क devenv.exe / कमांड का उपयोग कर सकता है।

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

कमांड अतिरिक्त तर्क ले सकते हैं, एक अंतरिक्ष में पारित। आइए हम मेनू विंडो के मानक सिस्टम कमांड को कॉल करने का एक उदाहरण देते हैं -> नया -> फाइल, अतिरिक्त विंडो पास करने के साथ, कमांड विंडो के माध्यम से:

 >File.NewFile Mytext /t:"General\Text File" /e:"Source Code (text) Editor" 

कमांड लिखने का सिंटैक्स निम्नलिखित नियमों का पालन करता है:

• टीम का नाम और उसके तर्क एक स्थान से अलग हो जाते हैं
• तर्क मूल्यों वाले रिक्तियाँ उद्धरण चिह्नों में संलग्न हैं।
• सम्मिलित वर्ण (^) का उपयोग वर्णों से बचने के लिए किया जाता है
• तर्क नामों के एकल-वर्ण संक्षिप्ताक्षर संयुक्त किए जा सकते हैं, उदाहरण के लिए / केस (/ c) और / शब्द (/ w) को / ww लिखा जा सकता है

कमांड लॉन्च पैरामीटर का उपयोग करते समय, अपने सभी तर्कों के साथ कमांड नाम को दोहरे उद्धरण चिह्नों में लपेटा जाना चाहिए:

 devenv.exe /command "MyGroup.MyCommandName arg1 arg2" 

त्वरित कॉल के लिए, एक उपनाम अन्य कमांड का उपयोग करके एक कमांड को सौंपा जा सकता है:

 >alias MyAlias File.NewFile MyFile 

पीवीएस-स्टूडियो एक्सटेंशन मॉड्यूल द्वारा आईडीई के मुख्य मेनू में जोड़े गए आदेशों का उपयोग / कमांड कॉल के माध्यम से भी किया जा सकता है, विशेष रूप से, उदाहरण के लिए, एक परियोजना की स्वचालित विधानसभा प्रक्रिया में स्थिर विश्लेषण को एकीकृत करने की समस्या को हल करने के लिए। यहाँ हम ध्यान दें कि PVS-Studio.exe स्टैटिक एनालाइज़र अपने आप में केवल एक कंसोल एप्लीकेशन है जो कंपाइलर के समान सिद्धांत पर काम करता है, अर्थात यह स्रोत कोड और इनपुट के रूप में इस फ़ाइल के संकलन मापदंडों के साथ फ़ाइल को पथ प्राप्त करता है, इसके विश्लेषण के परिणामों को stdout / strerr धाराओं पर लौटाता है। यह भी स्पष्ट है कि विश्लेषक को आसानी से विधानसभा प्रणाली में सीधे एकीकृत किया जा सकता है (उदाहरण के लिए, उसी MSBuild, NMake, या यहां तक ​​कि GNU मेक पर) C / C ++ कंपाइलर के समान स्तर पर।ऐसी प्रणाली स्वयं, परिभाषा के अनुसार, उनमें से प्रत्येक के लिए संकलन मापदंडों के प्रावधान के साथ सभी स्रोत फ़ाइलों का एक ट्रॉलर लागू करेगी, जो वास्तव में विश्लेषक कॉल के साथ कंपाइलर कॉल को बदलने (या पूरक करने) की अनुमति देता है। यद्यपि ऑपरेशन का यह तरीका पूरी तरह से PVS-Studio.exe विश्लेषक द्वारा समर्थित है, लेकिन विधानसभा प्रक्रिया में विश्लेषण के इस तरह के एकीकरण के लिए विधानसभा प्रणाली के साथ सीधे एक करीबी परिचित की आवश्यकता होती है, जैसे कि इस तरह के संशोधन की संभावना, जो मुश्किल हो सकती है या सभी के लिए सुलभ नहीं है। ।विधानसभा प्रक्रिया में विश्लेषण के इस तरह के एकीकरण के लिए सीधे विधानसभा प्रणाली के साथ काफी करीबी परिचित की आवश्यकता होती है, ऐसे संशोधन के लिए वास्तविक संभावनाएं, जो दोनों मुश्किल और सुलभ नहीं हो सकती हैं।विधानसभा प्रक्रिया में विश्लेषण के इस तरह के एकीकरण के लिए सीधे विधानसभा प्रणाली के साथ काफी करीबी परिचित की आवश्यकता होती है, ऐसे संशोधन के लिए वास्तविक संभावनाएं, जो दोनों मुश्किल और सुलभ नहीं हो सकती हैं।

इसलिए, पीवीएस-स्टूडियो स्थैतिक विश्लेषण को एक स्वचालित विधानसभा प्रक्रिया में एकीकृत करने के लिए, आप विज़ुअल स्टूडियो में एक्सटेंशन मॉड्यूल कमांड के लिए कॉल का उपयोग / कमांड के माध्यम से कर सकते हैं, उदाहरण के लिए, पीवीएस- सत्यापन कमांड, एक उच्च स्तर पर (यानी, सीधे एकीकरण सर्वर के स्तर पर) Studio.CheckSolution। बेशक, यह विकल्प केवल तभी संभव है जब देशी डिजाइन समाधान के निर्माण के लिए विजुअल C ++ (vcproj / vcxproj) का उपयोग किया जाए।

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

गैर-संवादात्मक डेस्कटॉप मोड (उदाहरण के लिए, जब विंडोज विंडोज से शुरू हो रहा है) में काम करते समय विजुअल स्टूडियो कमांड / कमांड के माध्यम से सावधानी बरतते समय सावधानी बरती जानी चाहिए। उदाहरण के लिए, Microsoft टीम फाउंडेशन विधानसभा प्रक्रियाओं में PVS-Studio स्थैतिक विश्लेषण को एकीकृत करने की क्षमता का परीक्षण करते हुए, हम कई दिलचस्प बिंदुओं पर आए, जैसे डिफ़ॉल्ट रूप से, टीम फाउंडेशन विंडोज सेवा की तरह ही काम करता है। हमारा प्लगइन स्वयं गैर-संवादात्मक डेस्कटॉप मोड में काम करने के लिए तैयार नहीं था, अनुचित तरीके से अपने बच्चे की खिड़कियों और संवादों का प्रबंधन कर रहा था, जिसके परिणामस्वरूप दुर्घटना हुई। विजुअल स्टूडियो को ऐसी समस्याएं नहीं मिलीं, या बल्कि, लगभग नहीं। पर्यावरण के पहले लॉन्च के बाद, प्रत्येक उपयोगकर्ता के लिए, विजुअल स्टूडियो आपको एक संवाद प्रदर्शित करता है जो आपको मानक इंटरफ़ेस कॉन्फ़िगरेशन में से एक का चयन करने के लिए प्रेरित करता है।उसने लोकल सिस्टम उपयोगकर्ता के लिए वही संवाद जारी किया, जिसके पास टीम फाउंडेशन सेवा थी। यह पता चला कि विजुअल स्टूडियो इस संवाद को गैर-संवादात्मक मोड में उत्पन्न करता है, जब कॉलिंग / कमांड करता है, और सभी निष्पादन को अवरुद्ध करता है। और चूंकि उपयोगकर्ता के पास इंटरैक्टिव डेस्कटॉप नहीं है, इसलिए इस संवाद को बंद करना मुश्किल था। अंत में, हम अभी भी सेट से pecec उपयोगिता का उपयोग करके इंटरनल लोकलसिस्टम के लिए विज़ुअल स्टूडियो चलाकर ऐसा करने में सक्षम थेस्थानीय स्टूडियो सिस्टम के लिए सेट से psexec उपयोगिता का उपयोग करके विजुअल स्टूडियो चला रहा हैस्थानीय स्टूडियो सिस्टम के लिए सेट से psexec उपयोगिता का उपयोग करके विजुअल स्टूडियो चला रहा हैPSTools ।

VSPackage, Vsct फ़ाइलों में कमांड का निर्माण और प्रसंस्करण

VSPackage एकीकृत IDE कमांड बनाने और प्रबंधित करने के लिए कमांड टेबल (विजुअल स्टूडियो कमांड टेबल, विक्टीम फाइल्स) का उपयोग करता है। कमांड टेबल एक्सएमएल कॉन्फ़िगरेशन टेक्स्ट फाइलें हैं जो वीएससीटी कंपाइलर द्वारा बाइनरी कॉटो फाइलों (कमांड टेबल आउटपुट) में संकलित की जाती हैं। CTO फाइलें तब IDE एक्सटेंशन मॉड्यूल की अंतिम असेंबली में एक संसाधन के रूप में शामिल होती हैं। VCST का उपयोग करके, कमांड्स को IDE मुख्य मेनू आइटम या टूलबार बटन को सौंपा जा सकता है। दृश्य स्टूडियो 2005 के बाद से वीएससीटी फ़ाइलों के लिए समर्थन उपलब्ध है, आईडीई सीटीसी (कमांड टेबल कंपाइलर) फ़ाइलों के पिछले संस्करणों में कमांड का वर्णन करने के लिए उपयोग किया गया था, उन्हें इस लेख में नहीं माना जाएगा।

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

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

 <CommandTable"http://schemas.microsoft.com/VisualStudio/2005-10- 18/CommandTable"> <Extern href="stdidcmd.h"/> <Extern href="vsshlids.h"/> <Commands> <Groups> ... </Groups> <Bitmaps> ... </Bitmaps> </Commands> <Commands package="guidMyPackage"> <Menus> ... </Menus> <Buttons> ... </Buttons> </Commands> <KeyBindings> <KeyBinding guid="guidMyPackage" id="cmdidMyCommand1" editor="guidVSStd97" key1="221" mod1="Alt" /> </KeyBindings> <Symbols> <GuidSymbol name="guidMyPackage" value="{B837A59E-5BF0-4190-B8FC- FDC35BE5C342}" /> <GuidSymbol name="guidMyPackageCmdSet" value="{CC8B1E36-FE6B-48C1- B9A9-2CC0EAB4E71F}"> <IDSymbol name="cmdidMyCommand1" value="0x0101" /> </GuidSymbol> </Symbols> </CommandTable> 

बटन तत्व आईडीई कमांड्स को परिभाषित करता है, उनकी उपस्थिति निर्धारित करता है और उन्हें कमांडों के समूहों से जोड़ता है।

 <Button guid="guidMyPackageCmdSet" id="cmdidMyCommand1" priority="0x0102" type="Button"> <Parent guid="guidMyPackageCmdSet" id="MyTopLevelMenuGroup" /> <Icon guid="guidMyPackageCmdSet" id="bmpMyCommand1" /> <CommandFlag>Pict</CommandFlag> <CommandFlag>TextOnly</CommandFlag> <CommandFlag>IconAndText</CommandFlag> <CommandFlag>DefaultDisabled</CommandFlag> <Strings> <ButtonText>My &amp;Command 1</ButtonText> </Strings> </Button> 

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

 <Menu guid=" guidMyPackageCmdSet" id="SubMenu1" priority="0x0000" type="Menu"> <Parent guid="guidMyPackageCmdSet" id="MyTopLevelMenuGroup"/> <Strings> <ButtonText>Sub Menu 1</ButtonText> </Strings> </Menu> <Menu guid="guidMyPackageCmdSet" id="MyToolBar1" priority="0x0010" type="Toolbar"> </Menu> 

समूह तत्व उपयोगकर्ता पर्यावरण कमांड के समूह बनाता है।

 <Group guid="guidMyPackageCmdSet" id="MySubGroup1" priority="0x0020"> <Parent guid="guidMyPackageCmdSet" id="MyGroup1" /> </Group> 

MSBuild को बनाम फ़ाइल जोड़ने के लिए, VSPackage प्रोजेक्ट को पहले csproj फ़ाइल में वीएससीटी संकलक को कॉल करने के लिए निम्न नोड को सम्मिलित करना होगा (VSPackage टेम्पलेट के ऑटो-जेनरेट किए गए SDK प्रोजेक्ट में, vsct फ़ाइल पहले ही प्रोजेक्ट में जुड़ जाएगी):

 <ItemGroup> <VSCTCompile Include="TopLevelMenu.vsct"> <ResourceName>Menus.ctmenu</ResourceName> </VSCTCompile> </ItemGroup> 

उपयोगकर्ता कमांड या कमांड के समूह को मानक विज़ुअल स्टूडियो समूहों में से एक में एकीकृत करने के लिए, आपको अपने समूह के लिए मूल नोड में लक्ष्य मानक समूह के पहचानकर्ता को निर्दिष्ट करना होगा। उदाहरण के लिए, समाधान एक्सप्लोरर विंडो के प्रोजेक्ट संदर्भ मेनू में अपने कमांड के समूह को एकीकृत करने के लिए:

 <Group guid="guidMyCmdSet" id="ProjectNodeContextMenuGroup" priority="0x07A0"> <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_PROJNODE" /> </Group> 

जैसा कि आप देख सकते हैं, मानक पहचानकर्ता IDM_VS_CTXT_PROJNODE का उपयोग यहां किया जाता है। इस लिंक का अनुसरण करके , आप मानक Visual Studio कमांड समूह पहचानकर्ताओं की एक सूची देख सकते हैं।

और फिर पैकेज वर्ग के अपने वंशज पर ProvMenuResource विशेषता का उपयोग करके इसे इंगित करें:

 [ProvideMenuResource("Menus.ctmenu", 1)] ... public sealed class MyPackage : Package 

वीएससीटी फ़ाइल में परिभाषित आदेशों के लिए हैंडलर असाइन करना IMenuCommandService इंटरफ़ेस के माध्यम से उपलब्ध सेवा का उपयोग करना संभव है । आप पैकेज वर्ग के गेटस्वेस्ट पद्धति का उपयोग करके इसे एक लिंक प्राप्त कर सकते हैं:

 OleMenuCommandService MCS = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; 

एक मेनू कमांड को हैंडलर निर्दिष्ट करने का एक उदाहरण यहां दिया गया है (कमांड को अग्रिम में बनाम फ़ाइल में परिभाषित किया जाना चाहिए):

 EventHandler eh = new EventHandler(CMDHandler); CommandID menuCommandID = new CommandID(guidCommand1CmdSet, id); //ID and GUID should be the same as in the VCST file OleMenuCommand menuItem = new OleMenuCommand(eh, menuCommandID); menuItem.ParametersDescription = "$"; MCS.AddCommand(menuItem); 

इसके कॉल के प्रसंस्करण के दौरान कमांड के तर्क प्राप्त करने के लिए, आप हैंडलर द्वारा प्राप्त EventArgs के मूल्य को OleMenuCmdEventArgs में परिवर्तित कर सकते हैं:

 void CMDHandler(object sender, EventArgs e) { OleMenuCmdEventArgs eventArgs = (OleMenuCmdEventArgs)e; if (eventArgs.InValue != null) param = eventArgs.InValue.ToString(); ... } 

EnvDTE.DTE इंटरफ़ेस के माध्यम से टीमों के साथ काम करें

स्वचालन वस्तु EnvDTE.DTE भी dte.Commands इंटरफ़ेस और dte.ExecuteCommand विधि के माध्यम से कमांड के प्रत्यक्ष प्रोग्रामेटिक हेरफेर (निर्माण, संशोधन, निष्पादन) के लिए अवसर प्रदान करती है।

VSPackage के लिए उपलब्ध VSCT तंत्र के विपरीत, IDE कमांड को लागू करने, संशोधित करने और बनाने के लिए ऑटोमेशन ऑब्जेक्ट मॉडल का उपयोग करके, आप Visual Studio ऐड-इन एक्सटेंशन मॉड्यूल से कमांड के साथ बातचीत कर सकते हैं।

DTE ऑटोमेशन ऑब्जेक्ट आपको DTE.Commands इंटरफ़ेस के माध्यम से सीधे कमांड बनाने, संशोधित करने और आदेश देने की अनुमति देता है । Commands.AddNamedCommand विधि आपको IDE (केवल एड-इन मॉड्यूल के लिए) में एक कमांड जोड़ने की अनुमति देती है:

 dte.Commands.AddNamedCommand(add_in, "MyCommand", "My Command", "My Tooltip", true); 

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

 public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom) { switch(connectMode) { case ext_ConnectMode.ext_cm_UISetup: ... break; ... } 

}

EnvDTE.Command इंटरफ़ेस एक अलग IDE कमांड को सार करता है। इसका उपयोग इससे जुड़ी एक कमांड को संशोधित करने के लिए किया जा सकता है। यह इंटरफ़ेस आपको VSPackage और Add-In मॉड्यूल दोनों से पर्यावरण कमांड के साथ काम करने की अनुमति देता है। हमें अपनी उपयोगकर्ता टीम MyCommand1 के लिए स्वचालन वस्तु EnvDTE.Command का लिंक मिलेगा और इस शॉर्टकट का उपयोग करने के लिए इस इंटरफ़ेस का उपयोग करेंगे:

 EnvDTE.Command MyCommand1 = MyPackage.DTE.Commands.Item("MyGroup.MyCommand1", -1); MyCommand1.Bindings = new object[1] { "Global::Alt+1" }; 

MyGroup.MyCommand1 कमांड को असाइन किया गया शॉर्टकट संयोजन अब कीबोर्ड, पर्यावरण संवाद में पर्यावरण सेटिंग्स में दिखाई देगा।

यह याद रखने योग्य है कि विज़ुअल स्टूडियो कमांड डिफ़ॉल्ट आईडीई तत्व नहीं है। Commands.AddCommandBar इंटरफ़ेस विधि आपको मुख्य मेनू आइटम, टूलबार, संदर्भ मेनू के रूप में पर्यावरण के ऐसे UI तत्व बनाने की अनुमति देती है, और उन्हें उपयोगकर्ता कमांड प्रदान करती है।

 CommandBar MyToolbar = dte.Commands.AddCommandBar("MyToolbar1", vsCommandBarType.vsCommandBarTypeToolbar) as CommandBar; CommandBar MyMenu = dte.Commands.AddCommandBar("MyMenu1", vsCommandBarType.vsCommandBarTypeMenu) as CommandBar; CommandBarButton MyButton1 = MyCommand1.AddControl(MyToolbar) as CommandBarButton; MyButton1.Caption = "My Command 1"; 

IDE से कमांड या कमांड पैनल को हटाने के लिए, आप कमांड / कमांडबार इंटरफेस के डिलीट मेथड का उपयोग कर सकते हैं:

 MyCommand1.Delete(); 

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

किसी भी पर्यावरण कमांड (उपयोगकर्ता और अंतर्निहित दोनों) को ExecuteCommand विधि का उपयोग करके बुलाया जा सकता है। यहाँ कस्टम कमांड MyCommand1 को कॉल करने का एक उदाहरण है:

 MyPackage.DTE.ExecuteCommand("MyGroup.MyCommand1", args); 

आदेश को संसाधित करने के लिए, मॉड्यूल का मुख्य ऐड-इन वर्ग IDTCommandTarget इंटरफ़ेस से विरासत में प्राप्त होना चाहिए और Exec प्रसंस्करण विधि को लागू करना चाहिए:

 public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled) { handled = false; if(executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault) { if(commandName == "MyAddin1.Connect.MyCommand1") { ... handled = true; return; } } } 

अनुशंसित लिंक

1. MSDN। विजुअल स्टूडियो कमांड और स्विच।
2. MSDN। विजुअल स्टूडियो कमांड टेबल (.Vsct) फाइलें।
3. MSDN। XML कमांड टेबल डिजाइन (.Vsct) फ़ाइलें।
4. MSDN। वॉकथ्रू: IDE में टूलबार जोड़ना।
5. MSDN। कैसे VSPackages आईडीई में उपयोगकर्ता इंटरफ़ेस तत्व जोड़ें।
6. MZ-उपकरण। HOWTO: ऐड-इन से Visual Studio .NET में बटन, कमांडबार और टूलबार जोड़ना।
7. MSDN। कैसे करें: टूल विंडोज के लिए टूलबार बनाएं।

विजुअल स्टूडियो टूलबार

यह अनुभाग कस्टम टूल विंडो के वातावरण में एकीकरण के माध्यम से विज़ुअल स्टूडियो के विस्तार का वर्णन करता है। VSPackage और Add-In प्रकार के मॉड्यूल में कस्टम विंडो को पंजीकृत करने और आरंभ करने के मुद्दे, विंडो में कस्टम घटकों को प्रदर्शित करना, घटनाओं को संसाधित करना और विंडो की स्थिति की निगरानी करना स्पर्श किया जाएगा।

परिचय

टूल विंडो - जानकारी प्रदर्शित करने के लिए डिज़ाइन किए गए विज़ुअल स्टूडियो इंटरफ़ेस के एमडीआई (मल्टीपल डॉक्यूमेंट इंटरफ़ेस) की चाइल्ड विंडो। सोल्यूशन एक्सप्लोरर और एरर लिस्ट टूल विंडो हैं। आमतौर पर टूल विंडो की सामग्री फ़ाइल से जुड़ी नहीं होती है और इसमें संपादक नहीं होते हैं, इसके लिए विशेष दस्तावेज़ विंडो होती हैं ।

पीवीएस-स्टूडियो एक्सटेंशन मॉड्यूल कई टूल विंडो को आईडीई में एकीकृत करता है, मुख्य एक विश्लेषण आउटपुट विंडो (पीवीएस-स्टूडियो आउटपुट) है। अन्य खिड़कियां पहले से ही इससे खोली जा सकती हैं, उदाहरण के लिए, एक सूची खोज विंडो। पीवीएस-स्टूडियो परिणाम आउटपुट विंडो विजुअल स्टूडियो मुख्य मेनू (पीवीएस-स्टूडियो -> पीवीएस-स्टूडियो आउटपुट विंडो दिखाएं) से सुलभ है और विश्लेषण शुरू होने पर स्वचालित रूप से खुलता है।

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

IDE में टूल विंडो का एकीकरण VSPackage और Add-in एक्सटेंशन मॉड्यूल में समर्थित है (और इन प्रकार के मॉड्यूल अलग-अलग होते हैं), और उन्हें अपने प्रारंभिक मापदंडों को सेट करने और सिस्टम रजिस्ट्री में पंजीकरण की आवश्यकता होती है।

टूल विंडो को रजिस्टर और इनिशियलाइज़ करें

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

VSPackage में विंडो को रजिस्टर, इनिशियलाइज़ और कॉल करें

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

प्रत्यक्ष उपयोगकर्ता के लिए पंजीकरण उपकरण खिड़की VSPackage मॉड्यूल प्रतिक्रिया विशेषता ProvideToolWindow वर्ग पैकेज:

 [ProvideToolWindow(typeof(MyWindowPane), Orientation = ToolWindowOrientation.Right, Style = VsDockStyle.Tabbed, Window = Microsoft.VisualStudio.Shell.Interop.ToolWindowGuids.Outputwindow, MultiInstances = false, Transient = true, Width = 500, Height = 250, PositionX = 300, PositionY = 300)] 

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

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

उदाहरण के लिए, ProvToolWindowVisibility विशेषता का उपयोग करके विंडो के लिए एक डायनामिक स्कोप सेट किया जा सकता है :

 [ProvideToolWindowVisibility(typeof(MyWindowPane), /*UICONTEXT_SolutionExists*/"f1536ef8-92ec-443c-9ed7-fdadf150da82")] 

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

VSPackage से टूल विंडो बनाने और प्रदर्शित करने के लिए, आप पैकेज क्लास के FindToolWindow विधि का उपयोग कर सकते हैं । यह विधि निर्दिष्ट टूलविंडो ऑब्जेक्ट के लिए एक लिंक देता है, यदि आवश्यक हो तो (पहली बार एक एकल-उदाहरण विंडो लॉन्च होने पर)। एकल-उदाहरण विंडो को कॉल करने और प्रदर्शित करने का एक उदाहरण:

 private void ShowMyWindow(object sender, EventArgs e) { ToolWindowPane MyWindow = this.FindToolWindow(typeof(MyToolWindow), 0, true); if ((null == MyWindow) || (null == MyWindow.Frame)) { throw new NotSupportedException(Resources.CanNotCreateWindow); } IVsWindowFrame windowFrame = (IVsWindowFrame) MyWindow.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); } 

उपरोक्त उदाहरण में, खिड़की या तो पहले कॉल पर बनाई जाएगी, या यह दिखाया जाएगा कि क्या यह पहले छिपा हुआ था। इस स्थिति में, टाइप बूल के FindToolWindow विधि का तीसरा पैरामीटर निर्धारित करता है कि क्या विंडो का एक नया उदाहरण बनाया जाएगा यदि यह नहीं मिला।

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

 private void CreateMyWindow(object sender, EventArgs e) { for (int i = 0; ; i++) { // Find existing windows. var currentWindow = this.FindToolWindow(typeof(MyToolWindow), i, false); if (currentWindow == null) { // Create the window with the first free ID. var window = (ToolWindowPane)this.CreateToolWindow(typeof(MyToolWindow), i); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException(Resources.CanNotCreateWindow); } IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame; ErrorHandler.ThrowOnFailure(windowFrame.Show()); break; } } } 

ध्यान दें कि अब झूठी विधि 3 तर्क के रूप में FindToolWindow विधि से पारित की जाती है, अर्थात्। हम खिड़की के नए उदाहरणों को शुरू किए बिना एक मुफ्त सूचकांक की तलाश करते हैं।

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

 Guid gd = Guid.Empty; windowFrame.SetFramePos(VSSETFRAMEPOS.SFP_fDockBottom, ref gd, 20, 20, 200, 200); 

यह याद रखने योग्य है कि शो () विधि के लिए कॉल के बाद SetFramePos () विधि पर कॉल किया जाना चाहिए।

ऐड-इन में विंडो बनाना और कॉल करना

ऐड-इन प्रकार के एक मॉड्यूल के लिए, आप विंडो 2 इंटरफेस के एंडडीडीटीई तरीकों का उपयोग करके एक कस्टम टूल विंडो को इनिशियलाइज़ कर सकते हैं:

 public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom) { _applicationObject = (DTE2)application; _addInInstance = (AddIn)addInInst; EnvDTE80.Windows2 window; AddIn add_in; object ctlobj = null; Window myWindow; // Get the window object add_in = _applicationObject.AddIns.Item(1); window = (Windows2)_applicationObject.Windows; // This section specifies the path and class name of the windows // control that you want to host in the new tool window, as well as // its caption and a unique GUID. string assemblypath = "C:\\MyToolwindow\\MyToolWindowControl.dll"; string classname = " MyToolWindowControl.MyUserControl"; string guidpos = "{E87F0FC8-5330-442C-AF56-4F42B5F1AD11}"; string caption = "My Window"; // Creates the new tool window and inserts the user control into it. myWindow = window.CreateToolWindow2(add_in, assemblypath, classname, caption, guidpos, ref ctlobj); myWindow.Visible = true; } 

उपरोक्त उदाहरण में, एक कस्टम टूल विंडो क्लाइंट क्षेत्र के रूप में MyToolWindowControl.MyUserControl वर्ग का उपयोग करके बनाई गई है। MyToolWindowControl.MyUserControl वर्ग ऐड-इन के रूप में एक ही असेंबली में स्थित हो सकता है जो इसे प्रारंभ करता है, या पूर्ण COM दृश्यता के साथ एक अलग लाइब्रेरी में (उदाहरण के लिए, प्रोजेक्ट सेटिंग्स में COM इंटरॉप विकल्प के लिए रजिस्टर के माध्यम से)। MyUserControl के रूप में, मानक समग्र UserControl उपवर्ग का उपयोग किया जा सकता है।

VSPackage मॉड्यूल में एक कस्टम टूल विंडो लागू करना

टूल विंडो में क्लाइंट-फ्रेम फ्रेमवर्क होता है। खिड़की का फ्रेम पर्यावरण द्वारा प्रदान किया गया है और अन्य इंटरफ़ेस घटकों (डॉकिंग), खिड़की के आकार और स्थिति के साथ डॉकिंग के लिए जिम्मेदार है। क्लाइंट क्षेत्र (फलक) उपयोगकर्ता द्वारा नियंत्रित विंडो की सामग्री को प्रदर्शित करता है। टूल विंडो में कस्टम WinForms और WPF घटक शामिल हो सकते हैं और इस तरह की मानक घटनाओं को ऑनशॉ, ओनमोव आदि को संभालने की क्षमता प्रदान करते हैं।

एक कस्टम टूल विंडो, या इसके क्लाइंट क्षेत्र, को एक क्लास से विरासत में प्राप्त किया जाता है जो मानक खाली IDE विंडो को लागू करता है - ToolWindowPane :

 [Guid("870ab1d8-b434-4e86-a479-e49b3c6797f0")] public class MyToolWindow : ToolWindowPane { public MyToolWindow():base(null) { this.Caption = Resources.ToolWindowTitle; this.BitmapResourceID = 301; this.BitmapIndex = 1; ... } 

}

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

कस्टम घटक होस्टिंग

बेस क्लास टूलविंडोपेन एक खाली पर्यावरण टूल विंडो को लागू करता है। इस वर्ग से विरासत इस विंडो में कस्टम WinForms या WPF घटकों को प्रदर्शित करने की अनुमति देता है।

Visual Studio 2008 से पहले, टूलबार ने कस्टम घटकों के WinForms प्रदर्शन का मूल रूप से समर्थन किया था, और WPF इंटरऑपरेबिलिटी एलिमेंटहोस्ट घटक का उपयोग करके WPF घटकों को भी प्रदर्शित कर सकता था। विज़ुअल स्टूडियो 2010 के साथ शुरू, टूल विंडो WPF तकनीक पर आधारित होना शुरू हुआ, लेकिन अभी भी लोडिंग और संगतता मोड में WinForms घटकों को प्रदर्शित करने का समर्थन किया।

एक विंडो में एक कस्टम WinForms घटक प्रदर्शित करने के लिए, आप टूलविंडो लेन की पुनर्निर्धारित विंडो संपत्ति का उपयोग कर सकते हैं:

 public MyUserControl control; public MyToolWindow():base(null) { this.Caption = Resources.ToolWindowTitle; this.BitmapResourceID = 301; this.BitmapIndex = 1; this.control = new MyUserControl(); } public override IWin32Window Window { get { return (IWin32Window)control; } } 

इसी समय, MyUserControl System.Windows.Forms.UserControl प्रकार का एक नियमित मिश्रित घटक है, जिससे आप किसी अन्य कस्टम घटकों को प्रदर्शित कर सकते हैं। इसमें WPF घटकों को प्रदर्शित करने के लिए, आप मानक घटक WPF ElementHost का उपयोग कर सकते हैं।

दृश्य स्टूडियो 2010 के संस्करण से शुरू होकर, मूल रूप से WPF घटकों को प्रदर्शित करना संभव हो गया। ऐसा करने के लिए, आधार वर्ग के सामग्री क्षेत्र में अपने WPF घटक के लिंक को पास करें:

 public MyToolWindow():base(null) { this.Caption = Resources.ToolWindowTitle; this.BitmapResourceID = 301; this.BitmapIndex = 1; base.Content = new MyWPFUserControl(); } 

ध्यान दें कि एक ही समय में इन दो विधियों का उपयोग करना समर्थित नहीं है। जब एक WPF घटक को आधार पर निर्दिष्ट किया जाता है। कंटेंट, ओवरराइड की गई विंडो प्रॉपर्टी को अनदेखा किया जाएगा।

पीवीएस-स्टूडियो एक्सटेंशन मॉड्यूल के आउटपुट विंडो की मुख्य विंडो में, ओपन-सोर्स प्रोजेक्ट सोर्सग्रिड पर आधारित एक वर्चुअल टेबल है, स्थैतिक विश्लेषण के परिणामों के साथ काम करने के लिए डिज़ाइन किया गया है। तालिका का उपयोग मानक तालिका ADO.NET System.Data.Datatable को प्रदर्शित करने के लिए किया जाता है, जिसका उपयोग विश्लेषक के परिणामों को सीधे संग्रहीत करने के लिए किया जाता है। संस्करण 4.00 से पहले, पीवीएस-स्टूडियो ने विश्लेषण परिणामों को प्रदर्शित करने के लिए मानक आईडीई त्रुटि सूची विंडो का उपयोग किया, हालांकि, जैसे ही विश्लेषक की क्षमताओं का विकास हुआ, इसकी कार्यक्षमता अपर्याप्त हो गई। स्थैतिक विश्लेषक के लिए विशिष्ट नियंत्रण जैसे कि फ़िल्टरिंग तंत्र और झूठी सकारात्मकता को दबाने के साधन, त्रुटि सूची, एक नियमित वास्तविक ग्रिड तत्व होने के कारण, अक्षमता के अलावा, नियमित रूप से संचालित होने के लिए केवल 1-2 हजार संदेशों को पर्याप्त रूप से संचालित करने की अनुमति मिलती है। अधिक संदेश पूरे आईडीई के ध्यान देने योग्य अंतराल के लिए नेतृत्व करने लगे।स्थैतिक विश्लेषण का उपयोग करने की प्रथा से पता चला है कि बड़ी परियोजनाओं के लिए, जैसे क्रोमियम या एलएलवीएम, नैदानिक ​​संदेशों की कुल संख्या (खाते में पहले से ही गलत अलार्म, उपयोगकर्ता निम्न-स्तर और अनुकूलन डायग्नोस्टिक्स को ध्यान में रखते हुए) कई दसियों हज़ार के मूल्यों तक पहुँच सकते हैं।

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

उपकरण खिड़कियों में घटना प्रसंस्करण

टूल विंडो का क्लाइंट क्षेत्र (टूलविंडोवेन क्लास से हमारे वंशज द्वारा प्रतिनिधित्व किया गया) आईडीई विंडो के साथ उपयोगकर्ता इंटरैक्शन घटनाओं को संभाल सकता है। इन घटनाओं के प्रसंस्करण की सदस्यता लेने के लिए, आप IVsWindowFrameNotify3 इंटरफ़ेस का उपयोग कर सकते हैं । यहाँ इस इंटरफ़ेस का एक उदाहरण कार्यान्वयन है:

 public sealed class WindowStatus: IVsWindowFrameNotify3 { // Private fields to keep track of the last known state private int x = 0; private int y = 0; private int width = 0; private int height = 0; private bool dockable = false; #region Public properties // Return the current horizontal position of the window public int X { get { return x; } } // Return the current vertical position of the window public int Y { get { return y; } } // Return the current width of the window public int Width { get { return width; } } // Return the current height of the window public int Height { get { return height; } } // Is the window dockable public bool IsDockable { get { return dockable; } } #endregion public WindowStatus() {} #region IVsWindowFrameNotify3 Members // This is called when the window is being closed public int OnClose(ref uint pgrfSaveOptions) { return Microsoft.VisualStudio.VSConstants.S_OK; } // This is called when a window "dock state" changes. public int OnDockableChange(int fDockable, int x, int y, int w, int h) { this.x = x; this.y = y; this.width = w; this.height = h; this.dockable = (fDockable != 0); return Microsoft.VisualStudio.VSConstants.S_OK; } // This is called when the window is moved public int OnMove(int x, int y, int w, int h) { this.x = x; this.y = y; this.width = w; this.height = h; return Microsoft.VisualStudio.VSConstants.S_OK; } // This is called when the window is shown or hidden public int OnShow(int fShow) { return Microsoft.VisualStudio.VSConstants.S_OK; } /// This is called when the window is resized public int OnSize(int x, int y, int w, int h) { this.x = x; this.y = y; this.width = w; this.height = h; return Microsoft.VisualStudio.VSConstants.S_OK; } #endregion } 

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

 public class MyToolWindow: ToolWindowPane { public override void OnToolWindowCreated() { base.OnToolWindowCreated(); // Register to the window events WindowStatus windowFrameEventsHandler = new WindowStatus(); ErrorHandler.ThrowOnFailure(((IVsWindowFrame)this.Frame).SetProperty( (int)__VSFPROPID.VSFPROPID_ViewHelper, (IVsWindowFrameNotify3)windowFrameEventsHandler)); } ... } 

विंडो स्थिति की निगरानी

IVsWindowFrameNotify3 इंटरफ़ेस के हमारे कार्यान्वयन के घटना संचालकों का उपयोग करके विंडो स्थिति की निगरानी की जा सकती है।

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

OnClose पद्धति बताती है कि विंडो फ़्रेम बंद है, जिससे आप pgrfSaveOptions पैरामीटर का उपयोग करके आवश्यक IDE व्यवहार सेट कर सकते हैं, जो विंडो में खुले दस्तावेज़ को सहेजने के बारे में संवाद के प्रदर्शन को नियंत्रित करता है ( __FRAMECLOSE )।

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

OnMove और OnSize विधियों के पैरामीटर नए निर्देशांक और / या खिड़की के आकार की रिपोर्ट करते हैं जब इसे खींचा और बढ़ाया जाता है।

अनुशंसित लिंक

1. MSDN। विंडोज के प्रकार।
2. MSDN। टूल विंडोज।
3. MSDN। टूल विंडो अनिवार्य है।
4. MSDN। टूल विंडो वॉकथ्रू।
5. MSDN। विजुअल स्टूडियो में विंडोज की व्यवस्था और उपयोग।
6. MZ-उपकरण। HOWTO: विजुअल स्टूडियो में टूलविंडो स्टेट्स को समझना।

दृश्य स्टूडियो सेटिंग्स में एकीकरण

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

परिचय

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

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

कस्टम सेटिंग पेज बनाना और पंजीकृत करना

Visual Studio एक्सटेंशन मॉड्यूल विकसित करते समय, यह टूल -> विकल्प मेनू में एक या एक से अधिक उपयोगकर्ता सेटिंग पृष्ठों पर मैप करने के लिए उपयोगी हो सकता है। एक्सटेंशन को कॉन्फ़िगर करने और प्रबंधित करने का एक समान टूल विकास के वातावरण के UI प्रतिमान के अनुरूप होगा और आईडीई से सीधे एक्सटेंशन के साथ काम करते समय सुविधाजनक है। कस्टम सेटिंग्स पेज को लागू करने के तरीके, आईडीई और पंजीकरण में इसके एकीकरण के प्रकार विकसित किए जा रहे विस्तार मॉड्यूल और उपयोग की जाने वाली तकनीक (स्वचालन मॉडल या एमपीएफ) के आधार पर अलग-अलग होंगे।

MPF कक्षाओं का उपयोग कर एकीकरण

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

इस तरह से कस्टम सेटिंग्स पृष्ठ को लागू करने वाली एक वस्तु को पैकेज उपवर्ग की ProvOptionPage विशेषता के माध्यम से विज़ुअल स्टूडियो एक्सटेंशन पैक (VSPackage) के साथ जोड़ा जाना चाहिए ।

 [ProvideOptionPageAttribute(typeof(OptionsPageRegistration), "MyPackage", "MyOptionsPage", 113, 114, true)] 

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

 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\<VsVersion>\ ToolsOptionsPages 

यहाँ <VsVersion> दृश्य स्टूडियो का संस्करण संख्या है, उदाहरण के लिए 10.0। यह रिकॉर्ड स्वचालित रूप से ProvOptionPage विशेषता का उपयोग करके बनाया जाएगा। यह भी याद रखने योग्य है कि विज़ुअल स्टूडियो से एक्सटेंशन पैकेज को हटाने के लिए, आपको सिस्टम रजिस्ट्री में मौजूद सभी प्रविष्टियों को साफ़ करना होगा, जिसमें उपयोगकर्ता सेटिंग्स पृष्ठों से संबंधित प्रविष्टियाँ शामिल हैं। विजुअल स्टूडियो 2010 के संस्करण से शुरू होकर, वीएसपीएसीएज मॉड्यूल वीएसआईएक्स पैकेजों को उनकी तैनाती और स्थापना रद्द करने के लिए उपयोग कर सकते हैं, जबकि वीएसआईएक्स इंस्टॉलर स्वचालित रूप से रजिस्ट्री में मॉड्यूल प्रविष्टियों को लिखता है या हटाता है। आईडीई के पुराने संस्करणों के लिए, आपको मैन्युअल रूप से रजिस्ट्री को साफ करने की आवश्यकता होगी, उदाहरण के लिए, स्टैंडअलोन इंस्टॉलर में।

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

 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\<Version\Packages\ <PackageGUID>\Automation HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\<Version>\ AutomationProperties 

ProvProfile विशेषता आपको सेटिंग पृष्ठ या किसी अन्य स्वतंत्र ऑब्जेक्ट को पंजीकृत करने की अनुमति देती है जो सेटिंग्स को बचाने के लिए अंतर्निहित IDE तंत्र का उपयोग करने के लिए IProfileManager इंटरफ़ेस को लागू करता है।

एमपीएफ डायलॉगपेज इनहेरिटेंस को लागू करना

कस्टम सेटिंग्स पृष्ठ को लागू करने के लिए डायलॉगपेज उपवर्ग के लिए न्यूनतम आवश्यकता व्युत्पन्न वर्ग में सार्वजनिक गुण हैं। एक समान आधार कार्यान्वयन इस तरह दिखेगा:

 namespace MyPackage { class MyOptionsPage : DialogPage { bool myOption = true; public bool MyOption { get { return this. myOption; } set { this. myOption = value; } } } } 

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

विंडो में उपयोगकर्ता इंटरफ़ेस सेटिंग्स प्रदर्शित करने के लिए, आपको DialogPage क्लास की विंडो प्रॉपर्टी को ओवरराइड करना चाहिए :

 [BrowsableAttribute(false)] protected override IWin32Window Window { get { return MyUserControl; } } 

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

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

 public override void SaveSettingsToStorage() { ... } 

स्वचालन ऑब्जेक्ट्स के रूप में पंजीकृत पृष्ठ, अन्य स्टेट सेटिंग्स पेजों की स्थिति को बचाने के समान, उपकरण -> आयात / निर्यात सेटिंग्स पर्यावरण आदेशों का उपयोग करके SaveSettingsToXml विधि के एक मानक कार्यान्वयन के माध्यम से अपने राज्य को बचा सकते हैं, जो आवश्यक होने पर पुनर्परिभाषित भी किया जा सकता है।

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

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

एड-इन मॉड्यूल के xml विवरण के माध्यम से एकीकरण

एक कस्टम सेटिंग पेज को IDE में एक स्वतंत्र AddIn XML विवरण फ़ाइल का उपयोग करके एकीकृत किया जा सकता है। उसी समय, एकीकृत उपयोगकर्ता पृष्ठ की सामग्री को उपयोगकर्ता घटक के रूप में लागू किया जाना चाहिए, उदाहरण के लिए, System.Windows.Forms.UserControl। यह घटक किसी भी तरह से ऐड-इन मॉड्यूल से सीधे जुड़ा हुआ नहीं है, और इसलिए इसे मॉड्यूल लाइब्रेरी में ही और एक अलग स्वतंत्र लाइब्रेरी के रूप में लागू किया जा सकता है। एक ऐडिन फ़ाइल बनाना संभव है जो केवल ऐसे स्वतंत्र उपयोगकर्ता घटक का वर्णन करता है। यहां उपयोगकर्ता सेटिंग्स पृष्ठ के लिए परिभाषा वाले ऐड-इन विवरण मॉड्यूल का एक उदाहरण xml फ़ाइल है।

 <?xml version="1.0" encoding="UTF-16" standalone="no"?> <Extensibility xmlns="http://schemas.microsoft.com/AutomationExtensibility"> <HostApplication> <Name>Microsoft Visual Studio Macros</Name> <Version>10.0</Version> </HostApplication> <HostApplication> <Name>Microsoft Visual Studio</Name> <Version>10.0</Version> </HostApplication> <Addin> <FriendlyName>My Add in</FriendlyName> <Description>My Addin 1</Description> <Assembly>c:\MyAddIn1\MyAddin1.dll</Assembly> <FullClassName>MyAddin1.Connect</FullClassName> <LoadBehavior>0</LoadBehavior> <CommandPreload>1</CommandPreload> <CommandLineSafe>0</CommandLineSafe> </Addin> <ToolsOptionsPage> <Category Name="MyAddIn1"> <SubCategory Name="My Tools Options Page"> <Assembly> c:\MyAddIn1\MyAddin1.dll</Assembly> <FullClassName>MyAddin1.UserControl1</FullClassName> </SubCategory> </Category> </ToolsOptionsPage> </Extensibility> 

उपयोगकर्ता सेटिंग पृष्ठ का विवरण <ToolsOptionsPage> नोड में स्थित है। यहां, <विधानसभा> नोड कस्टम घटक वाले पुस्तकालय को इंगित करता है जिसका उपयोग सेटिंग्स विंडो के क्लाइंट क्षेत्र को प्रदर्शित करने के लिए किया जाएगा। <FullClassName> नोड Namespace.ClassName प्रारूप में कस्टम घटक के पूरी तरह से योग्य नाम को इंगित करता है। नोड्स <श्रेणी> और <उपश्रेणी> उपकरण के सेटिंग संवाद के ट्री स्ट्रक्चर में यूजर पेज की स्थिति निर्धारित करते हैं -> विकल्प डायलॉग, पेज के समूह और व्यक्तिगत नाम को निर्दिष्ट करते हैं। <श्रेणी> को मौजूदा या नए समूह के रूप में निर्दिष्ट किया जा सकता है। जैसा कि आप उदाहरण से देख सकते हैं, इस मामले में, कस्टम घटक MyAddin1.UserControl1 एक ही पुस्तकालय में मॉड्यूल के रूप में है, लेकिन यह एक आवश्यकता नहीं है।

दृश्य स्टूडियो विकल्प संवाद के माध्यम से पहली पहुँच के बाद सेटिंग्स पृष्ठ को लोड करता है। प्रबंधित पैकेज फ्रेमवर्क के माध्यम से सेटिंग पृष्ठ को एकीकृत करने के विपरीत, पृष्ठ विवरण केवल एडिन xml विवरण फ़ाइल में समाहित है, और, तदनुसार, यदि वातावरण ऐसी फ़ाइल का पता लगाता है तो पृष्ठ लोड किया जाएगा। विजुअल स्टूडियो लोड होने के तुरंत बाद इसमें उपलब्ध एडिन फाइलों को पढ़ता है। Addin फ़ाइलों के लिए खोज पर्यावरण पर निर्दिष्ट निर्देशिकाओं में किया जाता है -> ऐड-इन / मैक्रो सुरक्षा सेटिंग्स पृष्ठ। MPF के माध्यम से लागू की गई सेटिंग पृष्ठों के विपरीत, इस तरह की उच्च-स्तरीय एकीकरण विधि पृष्ठ को स्वचालन वस्तु के रूप में पंजीकृत नहीं करती है, और तदनुसार,यह ऑटोमेशन ऑब्जेक्ट मॉडल के माध्यम से अपनी सामग्री तक पहुंच तंत्र का उपयोग करने और पेज की स्थिति को बचाने के लिए अंतर्निहित आईडीई तंत्र के लिए अवसर प्रदान नहीं करता है।

एक स्वचालन मॉडल का उपयोग करके सेटिंग्स विंडो तक पहुंचें

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

सेटिंग्स प्राप्त करने के लिए, आप EnvDTE.DTE इंटरफ़ेस की get_Properties विधि का उपयोग कर सकते हैं:

 Properties propertiesList = PVSStudio.DTE.get_Properties("MyPackage", "MyOptionsPage"); 

यहाँ सेटिंग्स पृष्ठ को उसके नाम और उसके समूह के नाम से पहचाना जाता है। एक विशिष्ट संपत्ति मूल्य प्राप्त करने के लिए:

 Property MyProp1 = propertiesList.Item("MyOption1"); 

अब संपत्ति का मूल्य MyProp1.Value फ़ील्ड के माध्यम से प्राप्त और संशोधित किया जा सकता है।

विकल्प संवाद में उपयोगकर्ता सेटिंग पृष्ठ को खोलने के लिए, आप पैकेज वर्ग की ShowOptionPage MPF विधि का उपयोग कर सकते हैं:

 MyPackage.ShowOptionPage(typeof(MyOptionsPage)); 

डेटा विधि डायलॉगपेज से वंशज के उपयोगकर्ता वर्ग के प्रकार (टाइपोफ परिणाम) को स्वीकार करता है। यदि आपको विकसित VSPackage के बाहर परिभाषित एक पृष्ठ खोलने की आवश्यकता है (उदाहरण के लिए, एक मानक IDE पृष्ठ या किसी अन्य मॉड्यूल में परिभाषित पृष्ठ), तो आप इसे GUID पहचानकर्ता द्वारा पा सकते हैं जो निम्न रजिस्ट्री शाखा में निर्दिष्ट है:

 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\ ToolsOptionsPages\<OptionsPageNme>\ 

जहाँ Tools में <OptionsPageName> पृष्ठ का नाम है -> विकल्प संवाद। यहाँ मानक IDE TextEditor खोलने का एक उदाहरण है -> वैश्विक IMenuCommandService का उपयोग कर सामान्य पृष्ठ:

 string targetGUID = "734A5DE2-DEBA-11d0-A6D0-00C04FB67F6A"; var command = new CommandID(VSConstants.GUID_VSStandardCommandSet97, VSConstants.cmdidToolsOptions); var mcs = GetService(typeof(IMenuCommandService)) as MenuCommandService; mcs.GlobalInvoke(command, targetGUID); 

वास्तव में, यह कोड वास्तव में Tools.Options पर्यावरण कमांड को निष्पादित करने के बराबर है। इसे EnvDTE.DTE ऑब्जेक्ट की ExecuteCommand विधि का उपयोग करके भी कहा जा सकता है:

 dte.ExecuteCommand("Tools.Options", "734A5DE2-DEBA-11d0-A6D0-00C04FB67F6A"). 

अनुशंसित लिंक

1. MSDN। विकल्प पृष्ठ।
2. MSDN। राज्य की दृढ़ता और विजुअल स्टूडियो आईडीई।
3. MSDN। उपयोगकर्ता सेटिंग्स और विकल्प।
4. MSDN। कस्टम विकल्प पृष्ठ पंजीकृत करना ।
5. MSDN। VSPackages के लिए स्वचालन प्रदान करना।

विजुअल स्टूडियो डिज़ाइन मॉडल

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

परिचय

विज़ुअल स्टूडियो प्रोजेक्ट मॉडल इंटरफेस का एक समूह है जो कंपाइलर, लिंकर और अन्य असेंबली टूल की कार्यक्षमता के साथ-साथ MSVS- संगत प्रोजेक्ट्स की संरचना का वर्णन करता है। यह ऑटोमेशन ऑब्जेक्ट मॉडल से संबंधित है ।VCProjects की देर से बंधी संपत्ति के माध्यम से। Visual C ++ प्रोजेक्ट मॉडल, Visual C ++ (vcrpoj / vcxproj) प्रोजेक्ट्स के लिए विशिष्ट कार्यक्षमता तक पहुँच प्रदान करते हुए, मानक Visual Studio प्रोजेक्ट मॉडल का विस्तार है। विजुअल C ++ प्रोजेक्ट मॉडल एक स्टैंड-अलोन COM घटक है, जो VCProjectEngine.dll फ़ाइल के माध्यम से सुलभ है, जिसे विज़ुअल स्टूडियो के बाहर भी स्वतंत्र रूप से उपयोग किया जा सकता है। तीसरे पक्ष के डेवलपर्स प्रोजेक्ट मॉडल के अपने कार्यान्वयन को बना सकते हैं, इस प्रकार विजुअल स्टूडियो में नए संकलक और प्रोग्रामिंग भाषाओं के लिए समर्थन जोड़ सकते हैं।

डिजाइन मॉडल संरचना

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

 Projects |- Project -- Object(unique for the project type) |- ProjectItems (a collection of ProjectItem) |- ProjectItem (single object) -- ProjectItems (another collection) |- Object(unique for the project type) 

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

 Project proj; ... VCProject vcproj = proj.Object as VCProject; AvrGCCNode AvrGccProject = proj.Object as AvrGCCNode; 

परियोजनाओं का सेट dte.Solution.Projects फ़ील्ड के माध्यम से या DTE.GetObject विधि के माध्यम से केवल एक प्रोजेक्ट मॉडल के लिए परियोजनाओं की IDE में लोड की गई सभी समाधान फ़ाइल के लिए प्राप्त किया जा सकता है। उदाहरण के लिए, दृश्य C ++ प्रोजेक्ट्स के लिए:

 Projects vcprojs = m_dte.GetObject("VCProjects") as Projects; 

सभी प्रकार की परियोजनाओं को प्राप्त करने के लिए, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

 Projects AllProjs = PVSStudio.DTE.Solution.Projects; 

ProjectItems इंटरफ़ेस, ProjectItem के प्रोजेक्ट ट्री के सार तत्वों के संग्रह का प्रतिनिधित्व करता है। प्रोजेक्ट के अनुरूप, ProjectItem किसी भी प्रकार के एक तत्व का वर्णन कर सकता है, जिसमें ProjectItems (ProjectItem.ProjectItems फ़ील्ड के माध्यम से) के समान नेस्टेड संग्रह शामिल है या प्रोजेक्ट प्रोजेक्ट हो सकता है। एक विशिष्ट परियोजना मॉडल के लिए अद्वितीय वस्तु को ProjectItem.Object के माध्यम से सादृश्य द्वारा प्राप्त किया जा सकता है। उदाहरण के लिए, Visual C ++ प्रोजेक्ट मॉडल में, स्रोत फ़ाइल VCFile प्रकार द्वारा दर्शाई गई है, जबकि Atmel स्टूडियो प्रोजेक्ट मॉडल AvrGccFileNode द्वारा दर्शाया गया है:

 ProjectItem projectItem; ... VCFile file = projectItem.Object as VCFile; AvrGccFileNode file = projectItem.Object as AvrGccFileNode; 

नेस्टेड प्रोजेक्ट प्राप्त करना उस स्थिति में समान दिखता है जब पदानुक्रम का यह तत्व प्रोजेक्ट का वर्णन करता है:

 Project proj = projectItem.Object as Project; 

समाधान पेड़ की शाखा के सभी तत्वों का पुनरावर्ती ट्रावेल

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

पदानुक्रम ऑब्जेक्ट को VsShellUtilities.GetHierthyy का उपयोग करके एक व्यक्तिगत परियोजना की शाखा के लिए प्राप्त किया जा सकता है:

 public static IVsHierarchy ToHierarchy(EnvDTE.Project project) { System.IServiceProvider serviceProvider = new ServiceProvider(project.DTE as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); Guid guid = GetProjectGuid(serviceProvider, project); if (guid == Guid.Empty) return null; return VsShellUtilities.GetHierarchy(serviceProvider, guid); } 

यहाँ परियोजना के लिए उसके GUID पहचानकर्ता द्वारा पदानुक्रम प्राप्त किया गया था। यहाँ GetProjectGuid विधि का एक उदाहरण है, जो आपको इस तरह की परियोजना पहचानकर्ता प्राप्त करने की अनुमति देता है:

 private static Guid GetProjectGuid(System.IServiceProvider serviceProvider, Project project) { if (ProjectUnloaded(project)) return Guid.Empty; IVsSolution solution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution; IVsHierarchy hierarchy; solution.GetProjectOfUniqueName(project.FullName, out hierarchy); if (hierarchy != null) { Guid projectGuid; ErrorHandler.ThrowOnFailure( hierarchy.GetGuidProperty( VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out projectGuid)); if (projectGuid != null) { return projectGuid; } } return Guid.Empty; } 

IEnumHierarchies इंटरफ़ेस आपको समाधान पद्धति के माध्यम से तुरंत एक निश्चित, निर्दिष्ट प्रकार की परियोजनाओं के लिए इस तरह के पदानुक्रमों का एक संग्रह प्राप्त करने की अनुमति देता है। GetProjectEnum । समाधान ट्री के सभी विज़ुअल C ++ प्रोजेक्ट्स के लिए पदानुक्रम प्राप्त करने का एक उदाहरण:

 IVsSolution solution = PVSStudio._IVsSolution; if (null != solution) { IEnumHierarchies penum; Guid nullGuid = Guid.Empty; Guid vsppProjectGuid = new Guid("8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942"); //You can ask the solution to enumerate projects based on the //__VSENUMPROJFLAGS flags passed in. For //example if you want to only enumerate C# projects use //EPF_MATCHTYPE and pass C# project guid. See //Common\IDL\vsshell.idl for more details. int hr = solution.GetProjectEnum( (uint)(__VSENUMPROJFLAGS.EPF_LOADEDINSOLUTION | __VSENUMPROJFLAGS.EPF_MATCHTYPE), ref vsppProjectGuid, out penum); ErrorHandler.ThrowOnFailure(hr); if ((VSConstants.S_OK == hr) && (penum != null)) { uint fetched; IVsHierarchy[] rgelt = new IVsHierarchy[1]; PatternsForActiveConfigurations.Clear(); while (penum.Next(1, rgelt, out fetched) == 0 && fetched == 1) { ... } } } 

यहाँ GetProjectEnum विधि आपको GUID के माध्यम से निर्दिष्ट प्रकार पहचानकर्ता की परियोजनाओं की पदानुक्रम प्राप्त करने की अनुमति देती है। मानक विज़ुअल स्टूडियो / MSBuild प्रोजेक्ट प्रकारों के लिए GUIDs को इस लिंक पर देखा जा सकता है । Penum.Next () विधि हमें इस तरह से प्राप्त सभी प्रोजेक्ट पदानुक्रमों को दरकिनार करने की अनुमति देती है (rgelt array)। यह याद रखने योग्य है कि नए प्रकार के प्रोजेक्ट को परिभाषित करने वाले कस्टम प्रोजेक्ट मॉडल का अपना विशिष्ट पहचानकर्ता भी हो सकता है। कस्टम प्रकार की परियोजनाओं के लिए पहचानकर्ताओं को सीधे इन मॉडलों के प्रोजेक्ट डेटा की XML फ़ाइलों में देखा जा सकता है।

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

परियोजना पदानुक्रम का IVsHierarchy ऑब्जेक्ट होने से, हम पदानुक्रम विधि का उपयोग करके समाधान ट्री की इस शाखा के सभी तत्वों को पुन: प्राप्त कर सकते हैं। GetProperty , जो आपको पदानुक्रम में प्रत्येक नोड के निर्दिष्ट गुण प्राप्त करने की अनुमति देता है:

 EnumHierarchyItemsFlat(VSConstants.VSITEMID_ROOT, MyProjectHierarchy, 0, true); ... public void EnumHierarchyItemsFlat(uint itemid, IVsHierarchy hierarchy, int recursionLevel, bool visibleNodesOnly) { if (hierarchy == null) return; int hr; object pVar; hr = hierarchy.GetProperty(itemid, (int)__VSHPROPID.VSHPROPID_ExtObject, out pVar); ProjectItem projectItem = pVar as ProjectItem; if (projectItem != null) { ... } recursionLevel++; //Get the first child node of the current hierarchy being walked hr = hierarchy.GetProperty(itemid, (visibleNodesOnly ? (int)__VSHPROPID.VSHPROPID_FirstVisibleChild :(int)__VSHPROPID.VSHPROPID_FirstChild), out pVar); Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(hr); if (VSConstants.S_OK == hr) { //We are using Depth first search so at each level we recurse //to check if the node has any children // and then look for siblings. uint childId = GetItemId(pVar); while (childId != VSConstants.VSITEMID_NIL) { EnumHierarchyItemsFlat(childId, hierarchy, recursionLevel, visibleNodesOnly); hr = hierarchy.GetProperty(childId, (visibleNodesOnly ? (int)__VSHPROPID.VSHPROPID_NextVisibleSibling : (int)__VSHPROPID.VSHPROPID_NextSibling), out pVar); if (VSConstants.S_OK == hr) { childId = GetItemId(pVar); } else { Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(hr); break; } } } } private uint GetItemId(object pvar) { if (pvar == null) return VSConstants.VSITEMID_NIL; if (pvar is int) return (uint)(int)pvar; if (pvar is uint) return (uint)pvar; if (pvar is short) return (uint)(short)pvar; if (pvar is ushort) return (uint)(ushort)pvar; if (pvar is long) return (uint)(long)pvar; return VSConstants.VSITEMID_NIL; } 

वृक्ष के प्रत्येक नोड के लिए इस उदाहरण में प्राप्त प्रकार ProjectItem की वस्तु हमें ऊपर बताए गए अनुसार अपने ऑब्जेक्ट फ़ील्ड के माध्यम से Visual C ++ (साथ ही किसी अन्य मॉडल) के प्रोजेक्ट मॉडल की संबंधित वस्तु प्राप्त करने की अनुमति देगा।

सभी सॉल्यूशन ट्री प्रोजेक्ट्स की ट्रेवर्सिंग

सभी ट्री प्रोजेक्ट को बायपास करने के लिए, आप DTE.Solution.Projects इंटरफ़ेस का उपयोग कर सकते हैं:

 if (m_DTE.Solution.Projects != null) { try { foreach (object prj in m_DTE.Solution.Projects) { EnvDTE.Project proj = prj as EnvDTE.Project; if (proj != null) WalkSolutionFolders(proj); } } } 

स्वयं प्रोजेक्ट्स के अतिरिक्त, सॉल्यूशन ट्री में फ़ोल्डर नोड्स (सॉल्यूशन फोल्डर्स) भी हो सकते हैं। प्रत्येक परियोजना तत्व का पता लगाते समय उन पर विचार किया जाना चाहिए:

 public void WalkSolutionFolders(Project prj) { VCProject vcprj = prj.Object as VCProject; if (vcprj != null && prj.Kind.Equals(VCCProjectTypeGUID)) { if (!ProjectExcludedFromBuild(prj)) { IVsHierarchy projectHierarchy = ToHierarchy(prj); EnumHierarchyItemsFlat(VSConstants.VSITEMID_ROOT, projectHierarchy, 0, false); } } else if (prj.ProjectItems != null) { foreach (ProjectItem item in prj.ProjectItems) { Project nextlevelprj = item.Object as Project; if (nextlevelprj != null && !ProjectUnloaded(nextlevelprj)) WalkSolutionFolders(nextlevelprj); } } } 

असेंबली से बाहर रखी गई परियोजनाओं के लिए एक अलग चेक जोड़ा जाना चाहिए, जैसा कि उनके तत्वों को स्वचालन मॉडल के माध्यम से उपलब्ध नहीं होने के बाद वे उतारे नहीं जाएंगे:

 public bool ProjectExcludedFromBuild(Project project) { if (project.UniqueName.Equals("<MiscFiles>", StringComparison.InvariantCultureIgnoreCase)) return true; Solution2 solution = m_DTE.Solution as Solution2; SolutionBuild2 solutionBuild = (SolutionBuild2)solution.SolutionBuild; SolutionContexts projectContexts = solutionBuild.ActiveConfiguration.SolutionContexts; //Skip this project if it is excluded from build. bool shouldbuild = projectContexts.Item(project.UniqueName).ShouldBuild; return !shouldbuild; } 

बाईपास चयनित आइटम

समाधान एक्सप्लोरर विंडो के इंटरफ़ेस में उपयोगकर्ता द्वारा चयनित तत्वों को बायपास करने के लिए, आप DTE.SelectedItems इंटरफ़ेस का उपयोग कर सकते हैं।

 foreach (SelectedItem item in items) { VCProject vcproj = null; if (item.Project != null) { vcproj = item.Project.Object as VCProject; if (vcproj != null && item.Project.Kind.Equals("{" + VSProjectTypes.VCpp + "}")) { IVsHierarchy projectHierarchy = ToHierarchy(item.Project); PatternsForActiveConfigurations.Clear(); EnumHierarchyItemsFlat(VSConstants.VSITEMID_ROOT, projectHierarchy, 0, false, files, showProgressDialog); } else if (item.Project.ProjectItems != null) { //solution folder if (!ProjectUnloaded(item.Project)) WalkSolutionFolders(item.Project); } } else if (item.ProjectItem != null) { //walking files ... else if (item.ProjectItem.ProjectItems != null) if (item.ProjectItem.ProjectItems.Count > 0) WalkProjectItemTree(item.ProjectItem); } } private void WalkProjectItemTree(object CurrentItem) { Project CurProject = null; CurProject = CurrentItem as Project; if (CurProject != null) { IVsHierarchy projectHierarchy = ToHierarchy(CurProject); PatternsForActiveConfigurations.Clear(); EnumHierarchyItemsFlat(VSConstants.VSITEMID_ROOT, projectHierarchy, 0, false); return; } ProjectItem item = null; item = CurrentItem as ProjectItem; if (item != null) { ... if (item.ProjectItems != null) if (item.ProjectItems.Count > 0) { foreach (object NextItem in item.ProjectItems) WalkProjectItemTree(NextItem); } } } 

दृश्य C ++ डिज़ाइन मॉडल। प्रोजेक्ट और फ़ाइल कॉन्फ़िगरेशन और गुण

इससे पहले, हमने विज़ुअल स्टूडियो प्रोजेक्ट मॉडल के एक सामान्यीकृत, बाहरी हिस्से पर विचार किया था, जिनके इंटरफेस एनवीडीटीई में परिभाषित किए गए हैं और स्वचालन मॉडल के किसी भी कार्यान्वयन से सुलभ हैं। आइए हम प्रोजेक्ट मॉडल के मूल कार्यान्वयनों में से एक पर ध्यान केंद्रित करें - Microsoft Visual C ++, जिसे Microsoft.VisualStudio.VCProjectEngine नाम स्थान में परिभाषित किया गया है।

Visual C ++ प्रोजेक्ट मॉडल मानक Visual Studio प्रोजेक्ट मॉडल को कार्यान्वित करता है; इसलिए, पहले उपधारा में वर्णित इंटरफेस का उपयोग इस मॉडल की परियोजनाओं के साथ काम करने के लिए भी किया जा सकता है। Visual C ++ मॉडल के लिए विशिष्ट इंटरफ़ेस Microsoft.VisualStudio.VCProjectEngine.dll फ़ाइल में परिभाषित किए गए हैं, जिन्हें विकसित की जा रही विस्तार परियोजना की उपयोग की गई असेंबली की सूची में जोड़ा जाना चाहिए।

Visual C ++ मॉडल भौतिक रूप से असेंबली पैरामीटर (संकलन, लिंकिंग, प्री और पोस्ट-असेंबली स्टेप्स, थर्ड-पार्टी यूटिलिटीज को लॉन्च करने के लिए पैरामीटर आदि) को स्टोर करता है। C / C ++ सोर्स कोड फाइल अपने प्रोजेक्ट xml फाइल (vcproj / vcproproj) में रखता है। ये विकल्प प्रॉपर्टी पेज संवाद बॉक्स इंटरफ़ेस के माध्यम से विजुअल स्टूडियो उपयोगकर्ता के लिए उपलब्ध हैं।

प्रॉपर्टी सेट को प्रोजेक्ट के बिल्ड कॉन्फ़िगरेशन (उदाहरण के लिए, डिबग और रिलीज़) और बिल्ड प्लेटफ़ॉर्म (Win32, x64, IA64, आदि) के प्रत्येक संयोजन के लिए परिभाषित किया गया है। इसके अलावा, संपत्तियों के ऐसे सेट पूरे प्रोजेक्ट के स्तर पर परिभाषित किए गए हैं, और प्रत्येक विशिष्ट फ़ाइल के लिए व्यक्तिगत गुणों को फिर से परिभाषित किया जा सकता है (डिफ़ॉल्ट रूप से, फ़ाइल गुण परियोजना से विरासत में मिले हैं)। किस संपत्तियों को ओवरराइड किया जा सकता है यह फ़ाइल के प्रकार पर निर्भर करता है, उदाहरण के लिए, हेडर फ़ाइलों के लिए, केवल बहिष्कृत फ़र्मबॉडी की संपत्ति को ओवरराइड किया जा सकता है, जबकि एक सीपीपी फ़ाइल के लिए, किसी भी संकलन संपत्ति को ओवरराइड किया जा सकता है।

विन्यास को पुनः प्राप्त करना

दृश्य C ++ प्रोजेक्ट मॉडल में, गुण पृष्ठ VCConfiguration (प्रोजेक्ट के लिए) और VCFileConfiguration (फ़ाइल के लिए) इंटरफ़ेस के माध्यम से प्रस्तुत किए जाते हैं । इन वस्तुओं को प्राप्त करने के लिए, हम ProjectItem ऑब्जेक्ट पर निर्माण करेंगे, जो पर्यावरण के समाधान पेड़ का एक सार तत्व है।

 ProjectItem item; VCFile vcfile = item.Object as VCFile; Project project = item.ContainingProject; String pattern = "Release|x64"; if (String.IsNullOrEmpty(pattern)) return null; VCFileConfiguration fileconfig = null; IVCCollection fileCfgs = (IVCCollection)vcfile.FileConfigurations; fileconfig = fileCfgs.Item(pattern) as VCFileConfiguration; if (fileconfig == null) if (fileCfgs.Count == 1) fileconfig = (VCFileConfiguration)fileCfgs.Item(0); 

इस उदाहरण में, हमें VCFile ऑब्जेक्ट (C / C ++ हैडर या स्रोत फ़ाइल) के लिए फ़ाइल कॉन्फ़िगरेशन मिला आइटम () विधि का उपयोग करके, इसे उस कॉन्फ़िगरेशन के पैटर्न (कॉन्फ़िगरेशन नाम और प्लेटफ़ॉर्म नाम) से गुजरना चाहिए जो हमें चाहिए। पैटर्न असेंबली कॉन्फ़िगरेशन प्रोजेक्ट स्तर पर परिभाषित किया गया है। यहां एक सक्रिय (IDE इंटरफ़ेस में चयनित) प्रोजेक्ट कॉन्फ़िगरेशन प्राप्त करने का एक उदाहरण है।

 ConfigurationManager cm = project.ConfigurationManager; Configuration conf = cm.ActiveConfiguration; String platformName = conf.PlatformName; String configName = conf.ConfigurationName; String pattern = configName + "|" + platformName; return pattern; 

ActiveConfiguration गुण का उपयोग सावधानी के साथ करें क्योंकि बहुत बार, हमें अक्सर PVS-Studio एक्सटेंशन मॉड्यूल के IDE से एक्सेस करने पर अपवादों का सामना करना पड़ा। विशेष रूप से, यह फ़ील्ड उन क्षणों में स्वचालन ऑब्जेक्ट मॉडल के माध्यम से दुर्गम है जब विज़ुअल स्टूडियो उपयोगकर्ता प्रोजेक्ट बनाने के लिए कदम उठाता है या बस पर्यावरण इंटरफेस के साथ इंटरैक्ट करता है। चूंकि उपयोगकर्ता की ओर से इस तरह की कार्रवाइयों को स्पष्ट रूप से अंदाजा लगाना असंभव है, इसलिए स्वचालन मॉडल की वस्तुओं के गुणों तक पहुंचने के लिए तंत्र में ऐसी स्थितियों को अतिरिक्त रूप से संभालने की सिफारिश की जाती है। ध्यान दें कि यह विशेष स्थिति COM अपवादों की उप-प्रजाति नहीं है, जिसके प्रसंस्करण की चर्चा EnvDTE इंटरफेस पर खंड में की गई थी, और सबसे अधिक संभावना स्वचालन मॉडल में खामियों से जुड़ी है।

अब हमें इस फाइल वाले प्रोजेक्ट का विन्यास मिलता है:

 VCConfiguration cfg=(VCConfiguration)fileconfig.ProjectConfiguration; 

प्रत्यक्ष रूप से, कॉन्फ़िगरेशन इंटरफेस में सामान्य टैब के केवल सामान्य गुण होते हैं, और प्रत्येक विशिष्ट असेंबली टूल के गुणों को ऑब्जेक्ट्स में परिभाषित किया जाता है, जिनके लिंक VCConfiguration.Tools या VCFileConfiguration.Tit फ़ील्ड के माध्यम से उपलब्ध होते हैं (केवल एक असेंबली टूल एक फ़ाइल से मेल खाती है)।

उदाहरण के लिए, VCCLCompilerTool कंपाइलर के C ++ मापदंडों का वर्णन करने वाला इंटरफ़ेस :

 ct = ((IVCCollection)cfg.Tools).Item("VCCLCompilerTool") as VCCLCompilerTool; ctf = fileconfig.Tool as VCCLCompilerTool; 

उदाहरण के लिए, हमें इस क्षेत्र में स्थूल मानों की गणना करने के लिए मूल्यांकन पद्धति का उपयोग करते हुए, कंपाइलर सेटिंग्स के अतिरिक्त क्षेत्रों की सामग्री मिलती है।

 String ct_add = fileconfig.Evaluate(ct.AdditionalOptions); String ctf_add = fileconfig.Evaluate(ctf.AdditionalOptions); 

संपत्ति की चादरें

प्रॉपर्टी शीट (संपत्ति की चादरें) प्रॉप्स एक्सटेंशन के साथ एक्सएमएल फाइलें हैं जो आपको परियोजना के विधानसभा गुणों को स्वतंत्र रूप से निर्धारित करने की अनुमति देती हैं (यानी एक कंपाइलर या लिंकर जैसे विभिन्न विधानसभा उपकरणों के लॉन्च पैरामीटर)। संपत्ति पत्रक विरासत का समर्थन करते हैं और एक ही समय में कई परियोजनाओं में विधानसभा कॉन्फ़िगरेशन को परिभाषित करने के लिए इस्तेमाल किया जा सकता है, अर्थात। परियोजना फ़ाइल (vcproj / vcxproj) में परिभाषित कॉन्फ़िगरेशन एक या अधिक समर्थक फ़ाइलों से इसके गुणों का हिस्सा प्राप्त कर सकता है।

संपत्ति फ़ाइलों के साथ काम करने के लिए, विजुअल C ++ प्रोजेक्ट मॉडल VCPropertySheet इंटरफ़ेस प्रदान करता है । आप VCConfiguration फ़ील्ड के माध्यम से VCPropertySheet प्रोजेक्ट की वस्तुओं के सेट तक पहुँच सकते हैं। PropertySheets:

 IVCCollection PSheets_all = fileconfig.PropertySheets; 

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

 private void ProcessAllPropertySheets(VCConfiguration cfg, IVCCollection PSheets) { foreach (VCPropertySheet propertySheet in PSheets) { VCCLCompilerTool ctPS = (VCCLCompilerTool)((IVCCollection)propertySheet.Tools).Item( "VCCLCompilerTool"); if (ctPS != null) { ... IVCCollection InherPSS = propertySheet.PropertySheets; if (InherPSS != null) if (InherPSS.Count != 0) ProcessAllPropertySheets(cfg, InherPSS); } } } 

उपरोक्त उदाहरण में, हमें प्रत्येक स्तर की प्रॉपर्टीशीट के लिए प्रकार VCCLCompilerTool (संकलक गुण) की एक वस्तु मिलती है। इस प्रकार, हम नेस्टेड सहित सभी परियोजना संपत्तियों की फाइलों में परिभाषित सभी संकलन मापदंडों को इकट्ठा करने में सक्षम होंगे।

VCPropertySheet इंटरफ़ेस में इसके क्षेत्रों में मैक्रोज़ की गणना करने के तरीके नहीं हैं, इसलिए इसके लिए आपको प्रोजेक्ट कॉन्फ़िगरेशन के समान मूल्यांकन पद्धति का उपयोग करना होगा। यह अभ्यास, हालांकि, गलत व्यवहार का कारण बन सकता है यदि गणना की गई मैक्रो का मूल्य सीधे प्रॉपर फ़ाइल से संबंधित है। उदाहरण के लिए, कई संस्करण 4 में दिखाई देने वाले MSBuild मैक्रोज़ का उपयोग Visual Studio 2010 से नई vcxproj परियोजनाओं के अंदर भी किया जा सकता है। MSBuildThisFileDirectory मैक्रो, उदाहरण के लिए, वर्तमान फ़ाइल के फ़ोल्डर में पथ में विस्तारित है, और इसलिए, इसे cfg.Evaluate के माध्यम से गणना करके इसे पथ के लिए खोल दिया जाएगा। vcxproj फ़ाइल में, उस प्रॉपर फ़ाइल में नहीं जिसका उपयोग किया गया है।

Visual C ++ प्रोजेक्ट के सभी गुण पृष्ठ को उपयोगकर्ता और सिस्टम फ़ाइलों में विभाजित किया जा सकता है। इसके अलावा, उपयोगकर्ता से हमारा मतलब है कि परियोजना द्वारा सीधे बनाई गई फ़ाइलें और उपयोगकर्ता द्वारा परियोजना में शामिल हैं। हालाँकि, जैसा कि आप देख सकते हैं, यहां तक ​​कि एक खाली MSVC परियोजना में अक्सर डिफ़ॉल्ट रूप से कई सहारा पृष्ठ शामिल होते हैं। इस तरह की सिस्टम प्रॉप्स फाइलें पर्यावरण द्वारा वास्तव में परियोजना के सेटिंग पेज में निर्दिष्ट कई संकलन मापदंडों को निर्धारित करने के लिए उपयोग की जाती हैं। उदाहरण के लिए, यूनिकोड के माध्यम से कैरेक्टरसेट पैरामीटर सेट करने से इस प्रॉजेक्ट की प्रॉपर्टी शीट्स की सूची में एक सिस्टम प्रॉपर फाइल दिखाई देगी, जो प्रीप्रोसेसर (यूनिकोड, _ यूनिकोड) के कई पात्रों को परिभाषित करती है। इसलिए, जब प्रॉप्स फ़ाइलों में संग्रहीत प्रसंस्करण गुण हैं, तो आपको याद रखना चाहिएसिस्टम फ़ाइलों में निर्दिष्ट संकलन प्रतीकों को भी स्वचालन मॉडल एपीआई के माध्यम से सुलभ परियोजना के विन्यास में इसी संपत्ति के माध्यम से परिभाषित किया गया है। जाहिर है, इन दोनों तंत्रों के माध्यम से सेटिंग्स प्राप्त करने से इस तरह के तर्कों का दोहराव होगा।

Atmel स्टूडियो प्रोजेक्ट मॉडल, प्रोजेक्ट असेंबली टूल्स में संकलन सेटिंग्स

इससे पहले, हमने Microsoft Visual C ++ से C / C ++ प्रोजेक्ट के लिए Visual Studio प्रोजेक्ट मॉडल के कार्यान्वयन की जांच की, जो Visual Studio वितरण किट में डिफ़ॉल्ट रूप से शामिल है। हालाँकि, विजुअल स्टूडियो ऑटोमेशन मॉडल एक्स्टेंसिबल है, और इसे थर्ड-पार्टी डेवलपर्स (ऐसे थर्ड-पार्टी मॉडल को VSPackage एक्सटेंशन मॉड्यूल में लागू किया जा सकता है) के डिजाइन मॉडल के साथ बातचीत के लिए इंटरफेस के साथ पूरक किया जा सकता है। इसलिए, यदि किसी तृतीय-पक्ष प्रोजेक्ट मॉडल का डेवलपर इसके लिए इंटरफेस प्रदान करता है, तो हम इसके साथ उसी तरह से बातचीत कर सकते हैं जैसे हमने मानक मॉडल के साथ बातचीत की थी, उदाहरण के लिए, दृश्य C ++ मॉडल के साथ, जैसा कि ऊपर वर्णित है।

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

Atmel डिजाइन मॉडल मानक Visual Studio डिजाइन मॉडल का एक कार्यान्वयन है। विजुअल C ++ प्रोजेक्ट्स के साथ, Atmel स्टूडियो प्रोजेक्ट्स के साथ कॉमन इंटरफेस का इस्तेमाल किया जा सकता है। इस मॉडल के लिए विशिष्ट इंटरफेस AvrGCC.dll, AvrProjectManagement.dll और Atmel.Studio.Toolchain.Interfaces.dll फ़ाइलों में परिभाषित किए गए हैं, जिन्हें विशेष Atmel Studio डेवलपर डेवलपर किट (XDK) डाउनलोड करके प्राप्त किया जा सकता है।

शारीरिक रूप से, Atmel स्टूडियो प्रोजेक्ट मॉडल असेंबली मापदंडों को cproj प्रोजेक्ट फ़ाइलों में संग्रहीत करता है, जो MSBuild असेंबली प्लेटफ़ॉर्म की प्रोजेक्ट फ़ाइलें हैं (जैसा कि वास्तव में, Visual Studio में सभी मानक प्रोजेक्ट प्रकार हैं)। Atmel स्टूडियो परियोजनाएं C / C ++ प्रोग्रामिंग भाषाओं का समर्थन करती हैं और निर्माण के लिए GCC संकलक के एक विशेष संस्करण का उपयोग करती हैं।

परियोजनाओं और विधानसभा उपकरणों के प्रकार

Atmel स्टूडियो 2 प्रकार की परियोजनाएं प्रदान करता है: C और C ++ प्रोजेक्ट। कृपया ध्यान दें कि इन परियोजनाओं में अलग-अलग GUID हैं, जिन्हें परियोजना के पेड़ को पार करते समय विचार किया जाना चाहिए।

Atmel डिजाइन मॉडल असेंबली टूल्स के 2 सेट भी प्रदान करता है - GNU C कंपाइलर और GNU C ++ कंपाइलर, प्रत्येक अपनी अलग सेटिंग्स के साथ। हालाँकि, यह ध्यान देने योग्य है कि जबकि C प्रोजेक्ट्स में केवल C कंपाइलर के लिए सेटिंग्स हो सकती हैं, C ++ प्रोजेक्ट्स में टूलकिट में C और C ++ दोनों सेटिंग्स होती हैं। और संकलन के दौरान, सेटिंग्स का सेट जो फ़ाइल के एकत्र होने से मेल खाता है, अर्थात। "मिश्रित" परियोजना के मामले में, सेटिंग्स को 2 सेटों से लिया जाएगा!

आप ProjectToolchainOptions इंटरफ़ेस का उपयोग करके प्रत्येक विशिष्ट प्रोजेक्ट के लिए उपलब्ध प्रीसेट की जांच कर सकते हैं।

 ProjectItem item; ... AvrGccFileNode file = item.Object as AvrGccFileNode; AvrGCCNode project = file.ProjectMgr as AvrGCCNode; AvrProjectConfigProperties ActiveProps = project.ConfigurationManager.GetActiveConfigProperties(); ProjectToolchainOptions ToolChainOptions = ActiveProps.ToolchainOptions; if (ToolChainOptions.CppCompiler != null) //Toolchain compiler options for C++ compiler if (ToolChainOptions.CCompiler != null) //Toolchain compiler options for C Compiler 

संकलन सेटिंग्स प्राप्त करना

संकलन सेटिंग्स को स्वयं प्राप्त करने के लिए, आप पहले प्राप्त किए गए ऑब्जेक्ट का उपयोग कर सकते हैं जो कि कंपाइलरेशंस प्रकार (CppCompilerOptions और CCompilerOptions के लिए आधार प्रकार) है। कई सेटिंग्स को सीधे ऑब्जेक्ट से लिया जा सकता है, उदाहरण के लिए प्रोजेक्ट पथ शामिल करें:

 CompilerOptions options; ... List<String> Includes = options. IncludePaths; 

ध्यान दें कि सेटिंग्स का हिस्सा सभी सेटों के लिए आम है (यानी, सी और सी ++ सेटिंग्स के लिए)। उदाहरण के लिए, ये सामान्य सिस्टम हैं पथ शामिल करें:

 List<String> SystemIncludes = options. DefaultIncludePaths; 

लेकिन अधिकांश सेटिंग्स डिक्शनरी <स्ट्रिंग, IList <स्ट्रिंग >> अन्य प्रॉपर्टीज़ की संपत्ति के माध्यम से उपलब्ध हैं। जैसा कि आप देख सकते हैं, प्रत्येक संपत्ति (कुंजी) एक या अधिक मूल्यों की सूची के अनुरूप हो सकती है।

यदि आपको MSBuild (और, तदनुसार, संकलक के लिए) परियोजना से पारित एक पूरी लाइन की आवश्यकता है, और अलग-अलग विधानसभा सेटिंग्स नहीं हैं, तो कमांडलाइन संपत्ति का उपयोग करके तुरंत ऐसी लाइन प्राप्त की जा सकती है (VCProjectEngine की तुलना में बहुत आसान!):

 String RawCommandLine = this.compilerOptions.CommandLine; 

हालाँकि, इस तरह से प्राप्त कमांड लाइन में अभी भी सामान्य सेटिंग्स नहीं होंगी, जैसे सिस्टम पथ शामिल करें।

हालांकि, यह याद रखने योग्य है कि इस पद्धति और पूर्ण कमांड लाइन द्वारा प्राप्त की गई दोनों व्यक्तिगत सेटिंग्स में अज्ञात MSBuild मैक्रोज़ हो सकते हैं। उन्हें विस्तारित करने के लिए, हम AvrGCCNode इंटरफ़ेस के GetAllProjectProperties विधि का उपयोग करते हैं:

 AvrGCCNode project; ... Dictionary<string, string> MSBuildProps = new Dictionary<string, string>(); project.GetAllProjectProperties().ForEach(x =>MSBuildProps.Add(x.Key, x.Value)); 

अब हम प्राप्त सेटिंग्स में पाए गए सभी मैक्रोज़ को MSBuildProps संग्रह से संबंधित मानों के साथ बदल सकते हैं।

प्रोजेक्ट की प्रत्येक फ़ाइल के लिए, अतिरिक्त असेंबली पैरामीटर सेट किए जा सकते हैं, या बल्कि, अतिरिक्त झंडे जो केवल इस फ़ाइल के लिए कंपाइलर को दिए जाते हैं। AvrFileNodeProperties इंटरफ़ेस का उपयोग करके इन अतिरिक्त मापदंडों को प्राप्त करें:

 AvrGccFileNode file; ... AvrFileNodeProperties FileProps = file.NodeProperties as AvrFileNodeProperties; String AdditionalFlags = FileProps.CustomCompilationSetting; 

अनुशंसित लिंक

1. MSDN. Visual C++ Project Model.
2. MSDN. Project Modeling.
3. MSDN. Automation Model Overview.