विजुअल स्टूडियो में परियोजनाओं की सुविधाजनक विधानसभा स्थापित करें

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

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

सामग्री की तालिका

* स्तर 1: .vcxproj फ़ाइलों के अंदर चढ़ें
.Props फ़ाइलों के बारे में बात करें
लेकिन क्यों अलग .vcxproj और .props?
प्रोजेक्ट सेटिंग्स को अधिक पठनीय बनाना
हम तीसरे पक्ष के पुस्तकालयों को जोड़ना आसान बनाते हैं
प्रोजेक्ट टेम्प्लेट - परियोजनाओं के निर्माण को स्वचालित
* स्तर 2: कस्टम कस्टम संकलन
पारंपरिक दृष्टिकोण
MSBuild लक्ष्यों को पूरा करें
फ़ाइलों को बनाने के लिए एक लक्ष्य बनाने की कोशिश करते हैं
हम अपने मॉडल उदाहरण को ध्यान में रखते हैं
U2DCheck और फ़ाइलें रोकें
हमारे कस्टम .target को अंतिम रूप दें
CustomBuildStep के बारे में क्या?
उचित फ़ाइल की प्रतिलिपि बनाना
* स्तर 3: दृश्य स्टूडियो से जीयूआई के साथ एकीकृत
हम कॉन्फ़िगरेशन प्रॉपर्टीज में .vcxproj के बॉल्स से सेटिंग्स को बाहर निकालते हैं
स्टूडियो को नई फ़ाइल प्रकारों के बारे में बताएं
अलग-अलग फ़ाइलों के साथ सहयोगी सेटिंग्स
* स्तर 4: MSBuild की कार्यक्षमता का विस्तार

नोट: इस लेख के सभी उदाहरणों का वीएस 2017 में परीक्षण किया गया था। मेरी समझ के अनुसार, उन्हें कम से कम वीएस 2012 के साथ शुरू होने वाले स्टूडियो के पुराने संस्करणों में काम करना चाहिए, लेकिन मैं यह वादा नहीं कर सकता।

स्तर 1: .vcxproj फ़ाइलों के अंदर चढ़ें

आइए एक विशिष्ट .vcxproj के अंदर एक नज़र डालें, जो स्वचालित रूप से विजुअल स्टूडियो उत्पन्न करता है।


बहुत अप्राप्य गड़बड़ है, है ना? और यह अभी भी एक बहुत छोटी और लगभग तुच्छ फ़ाइल है। आइए इसे धारणा के लिए कुछ अधिक पठनीय और आरामदायक बनाने की कोशिश करें।

.Props फ़ाइलों के बारे में बात करें

ऐसा करने के लिए, हम इस तथ्य पर अपना ध्यान आकर्षित करते हैं कि हमने जो फ़ाइल ली है, वह एक सामान्य XML दस्तावेज़ है और इसे तार्किक रूप से दो भागों में विभाजित किया जा सकता है, जिनमें से पहला प्रोजेक्ट सेटिंग्स को सूचीबद्ध करता है, और दूसरे में इसमें शामिल फ़ाइलें हैं। आइए इन पड़ावों को शारीरिक रूप से अलग करें। ऐसा करने के लिए, हमें कोड में पहले से आयात किए गए आयात टैग की आवश्यकता है, जो कि #include का एक एनालॉग है और आपको एक फ़ाइल को दूसरे में शामिल करने की अनुमति देता है। हम अपनी .vcxproj को किसी अन्य फ़ाइल में कॉपी करते हैं और प्रोजेक्ट में शामिल फ़ाइलों से संबंधित सभी घोषणाओं को हटा देते हैं, और .vcxproj से, बदले में, वास्तव में प्रोजेक्ट में शामिल फ़ाइलों से संबंधित घोषणाओं को छोड़कर सब कुछ हटा देते हैं। प्रोजेक्ट सेटिंग्स के साथ परिणामी फ़ाइल, लेकिन विज़ुअल स्टूडियो में फ़ाइलों के बिना आमतौर पर प्रॉपर्टी शीट्स कहा जाता है और एक्सटेंशन के साथ सहेजा जाता है। बदले में, .vcxproj में हम संबंधित आयात की आपूर्ति करेंगे


अनावश्यक XML तत्वों को हटाकर इसे और भी सरल बनाया जा सकता है। उदाहरण के लिए, संपत्ति "PrecompiledHeader" को अब विभिन्न कॉन्फ़िगरेशन विकल्पों (रिलीज़ / डिबग) और प्लेटफ़ॉर्म (win32 / x64) के लिए 4 बार घोषित किया जाता है, लेकिन हर बार यह घोषणा समान होती है। इसके अलावा, यहां कई अलग-अलग आइटमग्राफ का उपयोग किया जाता है, जबकि वास्तव में एक तत्व काफी पर्याप्त है। नतीजतन, हम एक कॉम्पैक्ट और समझने योग्य .vcxproj पर आते हैं जो प्रोजेक्ट में शामिल 1) बस सूचियों को सूचीबद्ध करता है, 2) उनमें से प्रत्येक क्या है (प्लस विशिष्ट व्यक्तिगत फ़ाइलों के लिए विशिष्ट सेटिंग्स) और 3) में अलग से संग्रहीत परियोजना सेटिंग्स का लिंक है।

 <?xml version="1.0" encoding="utf-8"?><Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <Import Project="settings.props" /> <PropertyGroup Label="Globals"> <ProjectGuid>{0D35456E-42DA-418B-87D4-55E32B8E1373}</ProjectGuid> </PropertyGroup> <ItemGroup> <ClInclude Include="pch.h" /> <ClCompile Include="pch.cpp"> <PrecompiledHeader>Create</PrecompiledHeader> </ClCompile> <ClCompile Include="protobuf_test.cpp" /> <Text Include="test.proto" /> </ItemGroup> </Project> 

हम स्टूडियो में प्रोजेक्ट को फिर से लोड करते हैं, विधानसभा की जांच करते हैं - सब कुछ काम करता है।

लेकिन क्यों अलग .vcxproj और .props?

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

लेकिन क्या होगा अगर हमें अभी भी विभिन्न परियोजनाओं के लिए अलग-अलग सेटिंग्स की आवश्यकता है? इस स्थिति में, हम विभिन्न प्रकार की परियोजनाओं के लिए कई अलग-अलग .props फ़ाइलें बना सकते हैं। चूँकि .props फाइलें अन्य .props फ़ाइलों को उसी तरह आयात कर सकती हैं, इसलिए कई .props फ़ाइलों की "पदानुक्रम" का निर्माण करना बहुत आसान और स्वाभाविक है, विशेष प्रोजेक्ट्स के लिए एक विशेष समाधान के लिए सभी परियोजनाओं के लिए सामान्य सेटिंग्स का वर्णन करने वाली फ़ाइलों से लेकर विशेष निर्दिष्ट करने वाले संस्करण। एक समाधान में सिर्फ एक या दो परियोजनाओं के लिए नियम। MSBuild में एक नियम है कि यदि इनपुट फ़ाइल में एक ही सेटिंग को दो बार घोषित किया जाता है (उदाहरण के लिए, इसे पहले base.prop में आयात किया जाता है और फिर व्युत्पन्न में फिर से घोषित कर दिया जाता है। जो आधार के आरंभ में आयात किया जाता है। फिर बाद में घोषित किया गया ओवरराइड पहले ही ओवरराइड हो जाता है । यह आपको आसानी से और आसानी से प्रत्येक की ओवरराइडिंग द्वारा सेटिंग्स की मनमानी पदानुक्रमों को सेट करने की अनुमति देता है। किसी भी .props फ़ाइल के लिए आवश्यक सभी सेटिंग्स को ओवरराइड करके इस तथ्य के बारे में चिंता किए बिना कि वे पहले से ही कहीं और घोषित किए जा सकते थे। अन्य बातों के अलावा, कहीं न कहीं। यह मानक स्टूडियो पर्यावरण सेटिंग्स को आयात करने के लिए बुद्धिमान है जो C ++ प्रोजेक्ट के लिए इस तरह दिखाई देगा:

 <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> 

मैं ध्यान देता हूं कि व्यवहार में .sln फ़ाइल के समान फ़ोल्डर में अपनी स्वयं की .props फ़ाइलों को रखना बहुत सुविधाजनक है

प्रोजेक्ट सेटिंग्स को अधिक पठनीय बनाना

अब जब हमें व्यक्तिगत रूप से प्रत्येक परियोजना के साथ परेशान होने की आवश्यकता नहीं है, तो हम निर्माण प्रक्रिया को अनुकूलित करने पर अधिक ध्यान दे सकते हैं। और शुरुआत के लिए, मैं .props फ़ाइलों का उपयोग करके समाधान से संबंधित फ़ाइल सिस्टम में सबसे दिलचस्प वस्तुओं को साने नाम देने की सलाह देता हूं। ऐसा करने के लिए, हमें UserMacros द्वारा चिह्नित एक संपत्ति समूह टैग बनाना चाहिए:

 <PropertyGroup Label="UserMacros"> <RepositoryRoot>$(SolutionDir)\..</RepositoryRoot> <ProjectsDir>$(RepositoryRoot)\projects</ProjectsDir> <ThirdPartyDir>$(RepositoryRoot)\..\ThirdParty</ThirdPartyDir> <ProtoBufRoot>$(ThirdPartyDir)\protobuf\src</ProtoBufRoot> </PropertyGroup> 

फिर, प्रोजेक्ट सेटिंग में, ".. \ _ \ _ \ _ \ _ \ _ थर्डपार्टी \ प्रोटोबुफ़ \ src \ protoc.exe" के बजाय हम बस "$ (ProtoBufRoot) \ protoc.exe" लिख सकते हैं। अधिक पठनीयता के अलावा, यह कोड को और अधिक मोबाइल बनाता है - हम स्वतंत्र रूप से .vcxproj को बिना किसी डर के स्थानांतरित कर सकते हैं कि इसकी सेटिंग्स बंद हो जाएंगी और हम .props फ़ाइलों में से केवल एक पंक्ति को बदलकर प्रोटोबॉफ़ को स्थानांतरित कर सकते हैं।

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

तीसरे पक्ष के पुस्तकालयों को जोड़ने को सुविधाजनक बनाना

विजुअल स्टूडियो में तीसरे पक्ष के पुस्तकालय पर निर्भरता सहित की सामान्य प्रक्रिया अक्सर कुछ इस तरह दिखती है:



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

 <?xml version="1.0" encoding="utf-8"?> <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <ItemDefinitionGroup> <ClCompile> <AdditionalIncludeDirectories>$(ThirdPartyDir)\libzmq\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <PreprocessorDefinitions>ZMQ_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions> </ClCompile> <Link> <AdditionalDependencies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">libzmq-v120-mt-sgd-4_3_1.lib;Ws2_32.Lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies Condition="'$(Configuration)|$(Platform)'=='Release|x64'">libzmq-v120-mt-s-4_3_1.lib;Ws2_32.Lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalLibraryDirectories>$(ThirdPartyDir)\libzmq\lib\x64\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> </Link> </ItemDefinitionGroup> </Project> 

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

ZeroMQ को जोड़ने के लिए अब केवल दी गई .props फ़ाइल को आयात करना पर्याप्त है।

 <?xml version="1.0" encoding="utf-8"?> <Project DefaultTargets="Build" ...> <Import Project="$(SolutionDir)\settings.props" /> <Import Project="$(SolutionDir)\zeromq.props" /> ... </Project> 

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



यह सच है कि अन्य स्टूडियो टूल्स की तरह, यह GUI एक पठनीय सिंगल-लाइन के बजाय .vcxproj कोड जैसा कुछ जोड़ेगा


इसलिए मैं .vcxproj फ़ाइलों को मैन्युअल रूप से तृतीय-पक्ष पुस्तकालयों के लिए लिंक जोड़ना पसंद करता हूं।

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

प्रोजेक्ट टेम्प्लेट - परियोजनाओं के निर्माण को स्वचालित

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

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

 <VSTemplate Version="3.0.0" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005" Type="Project"> <TemplateData> <Name>C++ console application</Name> <Description>C++ console application for our project</Description> <ProjectType>VC</ProjectType> <ProjectSubType> </ProjectSubType> <SortOrder>1000</SortOrder> <CreateNewFolder>true</CreateNewFolder> ` <DefaultName>OurCppConsoleApp</DefaultName> <ProvideDefaultName>true</ProvideDefaultName> <LocationField>Enabled</LocationField> <EnableLocationBrowseButton>true</EnableLocationBrowseButton> <Icon>ng.ico</Icon> </TemplateData> <TemplateContent> <Project TargetFileName="$projectname$.vcxproj" File="console_app.vcxproj" ReplaceParameters="true"> <ProjectItem ReplaceParameters="false" TargetFileName="$projectname$.vcxproj.filters">console_app.vcxproj.filters</ProjectItem> <ProjectItem ReplaceParameters="false" TargetFileName="main.cpp">main.cpp</ProjectItem> <ProjectItem ReplaceParameters="false" TargetFileName="stdafx.cpp">stdafx.cpp</ProjectItem> <ProjectItem ReplaceParameters="false" TargetFileName="stdafx.h">stdafx.h</ProjectItem> </Project> </TemplateContent> </VSTemplate> 

पैरामीटर रिप्लेसमेटर्स = "सच" पर ध्यान दें। इस स्थिति में, यह केवल vcxproj फ़ाइल पर लागू होता है, जो इस तरह दिखता है:

 <?xml version="1.0" encoding="utf-8"?> <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <Import Project="$(SolutionDir)\console_app.props" /> <PropertyGroup Label="Globals"> <ProjectGuid>{$guid1$}</ProjectGuid> <RootNamespace>$safeprojectname$</RootNamespace> </PropertyGroup> <ItemGroup> <ClCompile Include="main.cpp" /> <ClCompile Include="stdafx.cpp"> <PrecompiledHeader>Create</PrecompiledHeader> </ClCompile> </ItemGroup> <ItemGroup> <ClInclude Include="stdafx.h" /> </ItemGroup> </Project> 

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

टेम्पलेट के साथ परिणामी ज़िप संग्रह को कई तरीकों में से एक में स्टूडियो द्वारा ज्ञात टेम्प्लेट की सूची में जोड़ा जा सकता है। सबसे आसान तरीका यह है कि आप इस फ़ाइल को % USERPROFILE% \ Documents \ Visual Studio XX \ Templates \ ProjectTaper टेम्पलेट्स फ़ोल्डर में कॉपी करें। यह ध्यान देने योग्य है कि इस फ़ोल्डर में होने के बावजूद आपको एक नया प्रोजेक्ट बनाने के लिए विंडो में फ़ोल्डर्स के नाम से मेल खाते कई अलग-अलग सबफ़ोल्डर मिलेंगे, वास्तव में टेम्प्लेट को रूट फ़ोल्डर में रखा जाना चाहिए क्योंकि नए प्रोजेक्ट्स के ट्री में टेम्पलेट की स्थिति ProjectType और ProjectSubType टैग से स्टूडियो द्वारा निर्धारित की जाती है .vstemplate फ़ाइल में। यह विधि केवल आपके लिए "व्यक्तिगत" टेम्पलेट्स बनाने के लिए सबसे उपयुक्त है, और यदि आप निर्यात टेम्पलेट संवाद में "विजुअल स्टूडियो में" स्वचालित रूप से आयात टेम्पलेट "चेकबॉक्स का चयन करते हैं, तो यह वही है जो स्टूडियो इस फ़ोल्डर में निर्यात के दौरान बनाए गए ज़िप संग्रह को रखकर करेगा। टेम्पलेट्स। हालांकि, ऐसे टेम्पलेट्स को सहकर्मियों द्वारा मैन्युअल रूप से कॉपी करके साझा करना निश्चित रूप से बहुत सुविधाजनक नहीं है। तो चलिए थोड़ा और उन्नत विकल्प से परिचित होते हैं - एक विजुअल स्टूडियो एक्सटेंशन (.vsix) बनाएं

VSIX बनाने के लिए, हमें वैकल्पिक स्टूडियो घटक स्थापित करने की आवश्यकता है, जिसे विज़ुअल स्टूडियो एक्सटेंशन डेवलपमेंट टूल कहा जाता है:


उसके बाद, "VSIX प्रोजेक्ट" विकल्प दृश्य C # \ Extensibility अनुभाग में दिखाई देगा। कृपया ध्यान दें कि इसके स्थान (C #) के बावजूद, इसका उपयोग C ++ प्रोजेक्ट टेम्प्लेट के सेट सहित किसी भी एक्सटेंशन को बनाने के लिए किया जाता है।


वीएसआईएक्स द्वारा बनाई गई परियोजना में, आप कई अलग-अलग चीजें कर सकते हैं - उदाहरण के लिए, अपना स्वयं का संवाद बॉक्स बनाएं जिसका उपयोग टेम्पलेट द्वारा बनाई गई परियोजनाओं को कॉन्फ़िगर करने के लिए किया जाएगा। लेकिन यह चर्चा के लिए एक अलग विषय है, जिसे मैं इस लेख में नहीं बताऊंगा। VSIX में टेम्पलेट बनाने के लिए, सब कुछ बहुत सरल है: एक खाली VSIX प्रोजेक्ट बनाएं, .vsixmanifest फ़ाइल खोलें और सीधे प्रोजेक्ट के लिए सभी डेटा को GUI में सेट करें। मेटाडेटा टैब पर मेटाडेटा (एक्सटेंशन नाम, विवरण, लाइसेंस) दर्ज करें। ऊपरी दाएं कोने में स्थित "संस्करण" फ़ील्ड पर ध्यान दें - इसे सही ढंग से निर्दिष्ट करना वांछनीय है, क्योंकि स्टूडियो बाद में इसका उपयोग यह निर्धारित करने के लिए करता है कि कंप्यूटर पर एक्सटेंशन का कौन सा संस्करण स्थापित है। फिर हम एसेट्स टैब पर जाते हैं और "Add new Asset" टाइप के साथ चयन करते हैं: Microsoft.VisualStudio.ProjectTemplate, स्रोत: फाइल सिस्टम पर फ़ाइल, पथ: (टेम्पलेट के साथ ज़िप संग्रह के लिए नाम)। ठीक पर क्लिक करें, प्रक्रिया को तब तक दोहराएं जब तक हम वीएसआईएक्स में सभी वांछित टेम्पलेट नहीं जोड़ते।


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


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

स्तर 2: कस्टम कस्टम संकलन

ठीक है, इस स्तर पर हमने यह पता लगाया कि कैसे vcxproj और props फाइलों को व्यवस्थित किया जाता है और उन्हें व्यवस्थित करने का तरीका सीखा जाता है। आइए अब मान लें कि हम अपनी परियोजना में कुछ जोड़ना चाहते हैं। अद्भुत Google प्रोटोकॉल बफ़र्स लाइब्रेरी पर आधारित वस्तुओं को क्रमबद्ध करने के लिए .proto योजनाओं के लिए। मुझे इस लाइब्रेरी के मुख्य विचार की याद दिलाते हैं: आप एक विशेष प्लेटफ़ॉर्म-स्वतंत्र मेटा-भाषा (.proto फ़ाइल) में ऑब्जेक्ट ("स्कीम") का विवरण लिखते हैं जिसे एक विशेष कंपाइलर (प्रोटोक। Exe) द्वारा .cpp / .cs / .py / .java / .java में संकलित किया जाता है। आदि वांछित प्रोग्रामिंग लैंग्वेज में इस स्कीम के अनुसार ऑब्जेक्ट्स के क्रमांकन / डीरियलाइजेशन को लागू करने वाली फाइलें और जिन्हें आप अपने प्रोजेक्ट में उपयोग कर सकते हैं। इस प्रकार, परियोजना को संकलित करते समय, हमें पहले प्रोटोकोल को कॉल करने की आवश्यकता होती है जो हमारे लिए .cpp फ़ाइलों का एक सेट बनाएगा जिसका उपयोग हम भविष्य में करेंगे।

पारंपरिक दृष्टिकोण

क्लासिक माथे का कार्यान्वयन सीधा होता है और इसमें प्रॉजेक्ट के लिए प्री-बिल्ड स्टेप में प्रोटोकोल जोड़ने की जरूरत होती है। कुछ इस तरह:



लेकिन यह बहुत सुविधाजनक नहीं है:

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

इसके बजाय, हम स्वयं विजुअल स्टूडियो को "समझाने" की कोशिश करते हैं (या इसके बजाय, MSBuild बिल्ड सिस्टम इसका उपयोग करता है) ऐसी .proto फ़ाइलों को कैसे संभालना है।

MSBuild targets

MSBuild, build targets, targets. Clean , Compile , Link Deploy. .vcxproj . nix- make «makefile», : .vcxproj XML- makefile.

लेकिन स्टॉप-स्टॉप को एक भ्रमित पाठक द्वारा कहा जाएगा। वह कैसे है? इससे पहले, हमने .vcxproj को एक साधारण प्रोजेक्ट में देखा और क्लासिक मेकफाइल के साथ कोई लक्ष्य या कोई समानता नहीं थी। फिर किस तरह के लक्ष्य पर चर्चा की जा सकती है? यह पता चला है कि वे इस पंक्ति में केवल "छिपे हुए" हैं, जिसमें C ++ कोड के निर्माण के लिए .vcxproj में मानक लक्ष्य शामिल हैं।

 <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> 

«» - C++- «» Build, Clean Rebuild «» . toolset toolset , , Clang. toolset- toolset . , .

target-. target MSBuild

• (inputs)
• (outputs)
• targets (dependencies)
• target-
• target- (tasks)

ClCompile .cpp cl.exe .obj . ClCompile cl.exe. .vcxproj

 <ClCompile Include="protobuf_test.cpp" /> 

(Include) protobuf_tests.cpp (inputs) ,

 <ItemDefinitionGroup> <ClCompile> <PrecompiledHeader>Use</PrecompiledHeader> </ClCompile> </ItemDefinitionGroup> 

«Use» ClCompile.PrecompiledHeader target /Yu cl.exe.

target .proto

target- target:

 <Target Name="GenerateProtobuf"> ...steps to take... </Target> 

परंपरागत रूप से, लक्ष्य को .targets के साथ एक फ़ाइल में रखा जाता है। ऐसा नहीं है कि यह कड़ाई से आवश्यक था (vcxproj और लक्ष्य और प्रॉप्स फ़ाइलें दोनों समतुल्य XML हैं), लेकिन यह एक मानक नामकरण योजना है और हम इससे चिपके रहेंगे। ताकि .vcxproj फ़ाइल के कोड में अब आप कुछ लिख सकें

 <ItemGroup> <ClInclude Include="cpp.h"/> <ProtobufFile Include="my.proto" /> <ItemGroup> 

हमने जो लक्ष्य बनाया है, उसे उपलब्ध ItItName सूची में जोड़ा जाना चाहिए

 <ItemGroup> <AvailableItemName Include="ProtobufFile"> <Targets>GenerateProtobuf</Targets> </AvailableItemName> </ItemGroup> 

हमें यह भी वर्णन करना होगा कि हम अपनी इनपुट फ़ाइलों के साथ क्या करना चाहते हैं और आउटपुट पर क्या होना चाहिए। ऐसा करने के लिए, MSBuild "कार्य" नामक एक इकाई का उपयोग करता है। टास्क - यह कुछ सरल क्रिया है जो परियोजना की विधानसभा के दौरान किए जाने की आवश्यकता है। उदाहरण के लिए, "एक निर्देशिका बनाएं", "एक फ़ाइल संकलित करें", "एक कमांड चलाएं", "कुछ कॉपी करें"। हमारे मामले में, हम protoc.exe को चलाने के लिए लुकिंग Exec का उपयोग करेंगे और संकलन लॉग में इस चरण को प्रदर्शित करने के लिए लुकिंग संदेश का उपयोग करेंगे। हम यह भी संकेत देते हैं कि इस लक्ष्य का प्रक्षेपण मानक लक्ष्य तैयारफॉरबिल्ड के तुरंत बाद किया जाना चाहिए। नतीजतन, हम इस protobuf.targets फ़ाइल की तरह कुछ मिलता है

 <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <ItemGroup> <AvailableItemName Include="ProtobufSchema"> <Targets>GenerateProtobuf</Targets> </AvailableItemName> </ItemGroup> <Target Name="GenerateProtobuf" Inputs="%(ProtobufSchema.FullPath)" Outputs=".\generated\%(ProtobufSchema.Filename).pb.cc" AfterTargets="PrepareForBuild"> <Message Importance="High" Text="Compiling schema %(ProtobufSchema.Identity)" /> <Exec Command="$(Protoc) --cpp_out=.\generated %(ProtobufSchema.Identity)" /> </Target> </Project> 

हमने यहां गैर-तुच्छ ऑपरेटर "%" ( बैचिंग ऑपरेटर ) का उपयोग किया, जिसका अर्थ है "सूची से प्रत्येक आइटम के लिए" और स्वचालित रूप से मेटाडेटा जोड़ा । यहां विचार यह है: जब हम फॉर्म का कोड लिखते हैं

 <ItemGroup> <ProtobufSchema Include="test.proto"> <AdditionalData>Test</AdditionalData> </ProtobufSchema> </ItemGroup> 

«ProtobufSchema» «test.proto» () AdditionalData «Test». «ProtobufSchema.AdditionalData» «Test». AdditionalData, MSBuild Identity ( ), Filename ( ) FullPath ( ). % MSBuild — .. .proto .

  <Import Project="protobuf.targets" Label="ExtensionTargets"/> 

protobuf.props में, हम .bobxproj-e पर अपने प्रोटॉ-फाइल्स को फिर से लिखते हैं, ProtobufSchema

  <ItemGroup> ... <ProtobufSchema Include="test.proto" /> <ProtobufSchema Include="test2.proto" /> </ItemGroup> 

और विधानसभा की जाँच करें

1>------ Rebuild All started: Project: protobuf_test, Configuration: Debug x64 ------
1>Compiling schema test.proto
1>Compiling schema test2.proto
1>pch.cpp
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

हुर्रे!जीत गए हैं! सही है, हमारी .proto फ़ाइलें अब प्रोजेक्ट में दिखाई नहीं देती हैं। हम .vcxproj.filters में चढ़ते हैं और सादृश्य द्वारा वहां प्रवेश करते हैं

 ... <ItemGroup> <ProtobufSchema Include="test.proto"> <Filter>Resource Files</Filter> </ProtobufSchema> <ProtobufSchema Include="test2.proto"> <Filter>Resource Files</Filter> </ProtobufSchema> </ItemGroup> ... 

हम प्रोजेक्ट को फिर से लोड करते हैं - फाइलें फिर से दिखाई देती हैं।

हम अपने मॉडल उदाहरण को ध्यान में रखते हैं

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

1>...\protobuf_test\protobuf.targets(13,6): error MSB3073: The command "...\ThirdParty\protobuf\bin\protoc.exe --cpp_out=.\generated test.proto" exited with code 1.

इसे ठीक करने के लिए, एक सहायक लक्ष्य जोड़ें जो आवश्यक फ़ोल्डर बनाएगा।

 ... <Target Name="PrepareToGenerateProtobuf" Inputs="@(ProtobufSchema)" Outputs=".\generated"> <MakeDir Directories=".\generated"/> </Target> <Target Name="GenerateProtobuf" DependsOnTargets="PrepareToGenerateProtobuf" ... 

DependsOnTargets GenerateProtobuf PrepareToGenerateProtobuf, @(ProtobufSchema) ProtobufSchema , , .

— ! Rebuild,

1>------ Rebuild All started: Project: protobuf_test, Configuration: Debug x64 ------
1>pch.cpp
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ==========

, ? — MSBuild, . Rebuild Clean .\generated . ,

 <Target Name="CleanProtobuf" AfterTargets="Clean"> <RemoveDir Directories=".\generated"/> </Target> 

— . Clean , Rebuild , Build .

========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

C++ , Build

1>------ Build started: Project: protobuf_test, Configuration: Debug x64 ------
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

.proto- , protoc , . .proto .

========== Build: 0 succeeded, 0 failed, 1 up-to-date, 0 skipped ==========

MSBuild , UI — MSBuild .pp.cc . - .cpp MSBuild , .props

1>------ Build started: Project: protobuf_test, Configuration: Debug x64 ------
1>Compiling schema test.proto
1>protobuf_test.cpp
1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

?

U2DCheck tlog

Visual Studio MSBuild … « » . U2DCheck , MSBuild . U2DCheck «» U2DCheck .

U2DCheck .tlog । वे आसानी से मध्यवर्ती-आउटपुट फ़ोल्डर (प्रोजेक्ट_नाम) में मिल सकते हैं। स्रोत फ़ाइलों में परिवर्तन के लिए सही ढंग से प्रतिक्रिया देने के लिए U2DCheck के लिए .log और के लिए, हमें इस फ़ोल्डर में पढ़ी गई फ़ाइलों में से एक को लिखने की आवश्यकता है, और U2DCheck को आउटपुट फ़ाइलों को हटाने के लिए सही तरीके से जवाब देने के लिए लिखना है। लिखने की tlog फ़ाइलों में से एक में।

शाप देते हुए, हम अपने लक्ष्य के संबंधित संपादन पर लौट आते हैं

 ... <Exec Command="$(Protoc) --cpp_out=.\generated %(ProtobufSchema.Identity)" /> <WriteLinesToFile File="$(TLogLocation)\protobuf.read.1.tlog" Lines="^%(ProtobufSchema.FullPath)" /> 

— : .props , up-to-date. write tlog , target .

Visual Studio 2017 update 15.8 MSBuild GetOutOfDateItems , .target- .tlog .

U2DCheck ProjectCapability

 <ItemGroup> <ProjectCapability Include="NoVCDefaultBuildUpToDateCheckProvider" /> </ItemGroup> 

हालांकि, इस मामले में, स्टूडियो इस परियोजना के लिए MSBuild को ड्राइव करेगा और प्रत्येक बिल्ड के लिए उस पर निर्भर सभी लोग, और हां, U2DCheck को एक कारण के लिए जोड़ा गया था - यह उतनी तेजी से काम नहीं करता जितना मैं चाहूंगा।

हमारे कस्टम .target को अंतिम रूप दें

, . MSBuild « » , . @(SelectedFiles).

. . .

— . #include- protobuf- , :). ClCompile.


PropertyGroup, target ComputeProtobufInput. ( ) python.

 1>------ Rebuild All started: Project: protobuf_test, Configuration: Debug x64 ------ 1>Compiling schema test.proto 1>Compiling schema test2.proto 1>pch.cpp 1>protobuf_test.cpp 1>test.pb.cc 1>test2.pb.cc 1>Generating Code... 1>protobuf_test.vcxproj -> S:\Temp\msbuild\protobuf_msbuild_integration\x64\Debug\protobuf_test.exe 1>Done building project "protobuf_test.vcxproj". ========== Rebuild All: 1 succeeded, 0 failed, 0 skipped ========== 

CustomBuildStep?

, , CustomBuildStep. .props Custom Build Step



Custom Build Step



.vcxproj-

  <ItemDefinitionGroup> <CustomBuildStep> <Command>$(Protoc) --cpp_out=.\generated\%(FileName).pb.cc %(FullPath)</Command> <Message>Generate protobuf files</Message> <Outputs>.\generated\%(FileName).pb.cc</Outputs> </CustomBuildStep> </ItemDefinitionGroup> <ItemGroup> ... <CustomBuild Include="test.proto"/> <CustomBuild Include="test2.proto"/> ... </ItemGroup> 

Microsoft.CppCommon.targets CustomBuildStep , -, . GUI clean tlog- :). , :

• CustomBuildStep
  
  • 1
  • step .props ThirdParty , ..
• CustomBuildStep - ,

build target - . thirdparty DLL . « » xcopy Post-Build Targets. ,



Post-build steps build targets. . , ItemType=Copy



apply . .vcxproj- :

  <ItemGroup> ... <ProtobufSchema Include="test2.proto" /> <CopyFileToFolders Include="resource.txt"> <DestinationFolders>$(OutDir)</DestinationFolders> </CopyFileToFolders> </ItemGroup> 

« », tlog-. « » Custom Build Step , — () .

CopyFilesToFolder wildcards.

 <CopyFileToFolders Include="$(LibFolder)\*.dll"> <DestinationFolders>$(OutDir)</DestinationFolders> </CopyFileToFolders> 

CopyFileToFolders — , .props- thirdparty-. , build target Copy .

 <Target Name="_CopyLog4cppDll" Inputs="$(Log4cppDll)" Outputs="$(Log4cppDllTarget)" AfterTargets="PrepareForBuild"> <Message Text="Copying log4cpp.dll..." importance="high"/> <Copy SourceFiles="$(Log4cppDll)" DestinationFiles="$(Log4cppDllTarget)" SkipUnchangedFiles="true" Retries="10" RetryDelayMilliseconds="500" /> </Target> 

R Copy wildcards .tlog . ,


CopyFileToFolders .

Level 3: GUI Visual Studio

make. XML-, , tlog-… - — - . PropertyPageSchema .

.vcxproj Configuration Properties

$(ProtobufOutputFolder) « protobuf.targets» , IDE. XAML- . , , custom_settings.xml

 <?xml version="1.0" encoding="utf-8"?> <ProjectSchemaDefinitions xmlns="clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework"> <Rule Name="CustomProperties" PageTemplate="generic" DisplayName="My own properties"> <Rule.DataSource> <DataSource Persistence="ProjectFile"/> </Rule.DataSource> <StringProperty Name="ProtobufOutputFolder" DisplayName="Protobuf Output Directory" Description="Directory where Protobuf generated files are created." Subtype="folder"> </StringProperty> </Rule> </ProjectSchemaDefinitions> 

StringProperty «ProtobufOutputFolder» String Subtype=Folder GUI, XML- project file. ProjectFile UserFile — .vcxproj.user ( VCS) . , protobuf.targets PropertyPageSchema

 <ItemGroup> <AvailableItemName Include="ProtobufSchema"> <Targets>GenerateProtobuf</Targets> </AvailableItemName> <PropertyPageSchema Include="custom_settings.xml"/> </ItemGroup> 

, , project properties …



हाँ!हमारी सेटिंग के साथ हमारा पृष्ठ दिखाई दिया और इसका डिफ़ॉल्ट मान स्टूडियो द्वारा सही ढंग से पढ़ा गया। हम इसे बदलने की कोशिश करते हैं, परियोजना को बचाते हैं, देखें ।vcxproj ...

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> <ProtobufOutputFolder>.\generated_custom</ProtobufOutputFolder> </PropertyGroup> 

जैसा कि आप पारंपरिक स्थिति स्थिति द्वारा देख सकते हैं, डिफ़ॉल्ट रूप से सेटिंग्स एक विशिष्ट बिल्ड कॉन्फ़िगरेशन से जुड़ी होती हैं। लेकिन यदि वांछित है, तो यह ध्वज को सेट किया जा सकता है डेटा स्रोत सेट करें HasConfigurationCondition = "false"। सच है, 2017 के स्टूडियो में एक बग है, जिसके कारण परियोजना सेटिंग्स को नहीं दिखाया जा सकता है यदि उनके बीच कुछ कॉन्फ़िगरेशन से जुड़े कम से कम एक सेटिंग नहीं है। सौभाग्य से, यह सेटिंग दिखाई नहीं दे सकती है।


. BoolProperty, StringProperty ( «folder» «file»), StringListProperty, IntProperty, EnumProperty DynamicEnumProperty .vcxproj. . . Bool






, —

 <PropertyGroup> <EnableCommonPCH>true</EnableCommonPCH> </PropertyGroup> <PropertyGroup> <ProtobufOutputFolder>.\generated_ustom</ProtobufOutputFolder> </PropertyGroup> 

protobuf- .vcxproj . .xml

  <ContentType Name="Protobuf" DisplayName="Google Protobuf Schema" ItemType="ProtobufSchema" /> <ItemType Name="ProtobufSchema" DisplayName="Google Protobuf Schema" /> <FileExtension Name="*.proto" ContentType="Protobuf" /> 

, .proto



«Google Protobuf Schema». «Add new item», .proto- ( \ Add \ Existing item… ) . « » Item type:

« » « ». DataSource ItemType.

  <Rule Name="ProtobufProperties" PageTemplate="generic" DisplayName="Protobuf properties"> <Rule.DataSource> <DataSource Persistence="ProjectFile" ItemType="ProtobufSchema" /> </Rule.DataSource> <Rule.Categories> <Category Name="General" DisplayName="General"/> </Rule.Categories> <StringProperty Name="dllexport_decl" DisplayName="dllexport macro" Description="Add dllexport / dllimport statements controlled by #define with this name." Category="General"> </StringProperty> </Rule> 

, .vcxproj

  <ProtobufSchema Include="test2.proto"> <dllexport_decl Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">MYLIB_EXPORT</dllexport_decl> </ProtobufSchema> 

.

Level 4: MSBuild

, , : MSBuild. «» , MSBuild «» UsingTask. MSBuild , DLL- - :

 <UsingTask TaskName="CL" AssemblyFile="$(MSBuildThisFileDirectory)Microsoft.Build.CppTasks.Common.dll" /> 

«» . DLL . UsingTask TaskFactory. TaskFactory « task-» — «-», Task. CodeTaskFactory C# .props-.


- — use-case .

. MSBuild Visual Studio . - , : .props, .targets .vcxproj MSBuild «»



, :).

msbuild — solution .