మేము Revit/AutoCAD యొక్క విభిన్న సంస్కరణల కోసం సంకలనంతో ఒక ప్లగ్ఇన్ ప్రాజెక్ట్‌ను తయారు చేస్తాము

CAD అప్లికేషన్‌ల కోసం ప్లగిన్‌లను అభివృద్ధి చేస్తున్నప్పుడు (నా విషయంలో ఇవి AutoCAD, Revit మరియు Renga) కాలక్రమేణా, ఒక సమస్య కనిపిస్తుంది - ప్రోగ్రామ్‌ల యొక్క కొత్త వెర్షన్‌లు విడుదల చేయబడ్డాయి, వాటి API మార్పులు మరియు ప్లగిన్‌ల యొక్క కొత్త వెర్షన్‌లను తయారు చేయాలి.

మీకు ఒకే ప్లగ్ఇన్ ఉన్నప్పుడు లేదా మీరు ఈ విషయంలో స్వీయ-బోధన అనుభవశూన్యుడు అయితే, మీరు కేవలం ప్రాజెక్ట్ యొక్క కాపీని తయారు చేయవచ్చు, దానిలో అవసరమైన స్థలాలను మార్చవచ్చు మరియు ప్లగ్ఇన్ యొక్క క్రొత్త సంస్కరణను సమీకరించవచ్చు. దీని ప్రకారం, కోడ్‌లో తదుపరి మార్పులు కార్మిక వ్యయాలలో బహుళ పెరుగుదలను కలిగి ఉంటాయి.

మీరు అనుభవం మరియు జ్ఞానాన్ని పొందినప్పుడు, ఈ ప్రక్రియను ఆటోమేట్ చేయడానికి మీరు అనేక మార్గాలను కనుగొంటారు. నేను ఈ మార్గంలో నడిచాను మరియు నేను ఏమి ముగించాను మరియు అది ఎంత సౌకర్యవంతంగా ఉందో నేను మీకు చెప్పాలనుకుంటున్నాను.

మొదట, స్పష్టమైన మరియు నేను చాలా కాలంగా ఉపయోగించిన పద్ధతిని చూద్దాం.

ప్రాజెక్ట్ ఫైల్‌లకు లింక్‌లు

మరియు ప్రతిదీ సరళంగా, దృశ్యమానంగా మరియు అర్థమయ్యేలా చేయడానికి, నేను ప్లగ్ఇన్ అభివృద్ధి యొక్క నైరూప్య ఉదాహరణను ఉపయోగించి ప్రతిదీ వివరిస్తాను.

విజువల్ స్టూడియోని (నా దగ్గర కమ్యూనిటీ 2019 వెర్షన్ ఉంది. అవును - రష్యన్‌లో) తెరవండి మరియు కొత్త పరిష్కారాన్ని సృష్టించండి. అతన్ని పిలుద్దాం MySuperPluginForRevit

మేము 2015-2020 వెర్షన్‌ల కోసం Revit కోసం ప్లగిన్‌ని తయారు చేస్తాము. కాబట్టి, సొల్యూషన్‌లో (నెట్ ఫ్రేమ్‌వర్క్ క్లాస్ లైబ్రరీ) కొత్త ప్రాజెక్ట్‌ని క్రియేట్ చేద్దాం మరియు దానిని కాల్ చేద్దాం MySuperPluginForRevit_2015

మేము Revit APIకి లింక్‌లను జోడించాలి. వాస్తవానికి, మేము స్థానిక ఫైల్‌లకు లింక్‌లను జోడించవచ్చు (మేము అవసరమైన అన్ని SDKలను లేదా Revit యొక్క అన్ని సంస్కరణలను ఇన్‌స్టాల్ చేయాలి), కానీ మేము వెంటనే సరైన మార్గాన్ని అనుసరించి, NuGet ప్యాకేజీని కనెక్ట్ చేస్తాము. మీరు చాలా కొన్ని ప్యాకేజీలను కనుగొనవచ్చు, కానీ నేను నా స్వంతంగా ఉపయోగిస్తాను.

ప్యాకేజీని కనెక్ట్ చేసిన తర్వాత, అంశంపై కుడి క్లిక్ చేయండి "సూచనలు"మరియు అంశాన్ని ఎంచుకోండి"packages.configని PackageReferenceకి తరలించు...»

అకస్మాత్తుగా ఈ సమయంలో మీరు భయపడటం ప్రారంభిస్తే, ప్యాకేజీ లక్షణాల విండోలో ముఖ్యమైన అంశం ఏదీ ఉండదు "స్థానికంగా కాపీ చేయండి", మేము ఖచ్చితంగా విలువకు సెట్ చేయాలి తప్పుడు, అప్పుడు భయపడవద్దు - ప్రాజెక్ట్‌తో ఫోల్డర్‌కి వెళ్లి, మీకు అనుకూలమైన ఎడిటర్‌లో .csproj పొడిగింపుతో ఫైల్‌ను తెరవండి (నేను నోట్‌ప్యాడ్++ని ఉపయోగిస్తాను) మరియు అక్కడ మా ప్యాకేజీ గురించి ఎంట్రీని కనుగొనండి. ఆమె ఇప్పుడు ఇలా కనిపిస్తుంది:

<PackageReference Include="ModPlus.Revit.API.2015">
  <Version>1.0.0</Version>
</PackageReference>

దానికి ఆస్తిని జోడించండి రన్‌టైమ్. ఇది ఇలా మారుతుంది:

<PackageReference Include="ModPlus.Revit.API.2015">
  <Version>1.0.0</Version>
  <ExcludeAssets>runtime</ExcludeAssets>
</PackageReference>

ఇప్పుడు, ప్రాజెక్ట్‌ను నిర్మిస్తున్నప్పుడు, ప్యాకేజీ నుండి ఫైల్‌లు అవుట్‌పుట్ ఫోల్డర్‌కు కాపీ చేయబడవు.
మరింత ముందుకు వెళ్దాం - మా ప్లగ్ఇన్ కొత్త సంస్కరణలు విడుదల చేయబడినప్పుడు కాలక్రమేణా మారిన Revit API నుండి ఏదైనా ఉపయోగిస్తుందని వెంటనే ఊహించుకుందాం. సరే, లేదా మనం ప్లగిన్‌ని తయారు చేస్తున్న Revit వెర్షన్‌ని బట్టి కోడ్‌లో ఏదైనా మార్చాలి. కోడ్‌లో ఇటువంటి తేడాలను పరిష్కరించడానికి, మేము షరతులతో కూడిన సంకలన చిహ్నాలను ఉపయోగిస్తాము. ప్రాజెక్ట్ లక్షణాలను తెరిచి, "కి వెళ్లండిఅసెంబ్లీ"మరియు ఫీల్డ్‌లో"షరతులతో కూడిన సంకలనం సంజ్ఞామానం"రాద్దాం R2015.

డీబగ్ మరియు విడుదల కాన్ఫిగరేషన్‌లు రెండింటికీ గుర్తు తప్పనిసరిగా జోడించబడుతుందని గుర్తుంచుకోండి.

సరే, మనం ప్రాపర్టీస్ విండోలో ఉన్నప్పుడు, వెంటనే "టాబ్‌కి వెళ్తాముఅప్లికేషన్"మరియు ఫీల్డ్‌లో"డిఫాల్ట్ నేమ్‌స్పేస్» ప్రత్యయాన్ని తీసివేయండి _2015తద్వారా మన నేమ్‌స్పేస్ సార్వత్రికమైనది మరియు అసెంబ్లీ పేరు నుండి స్వతంత్రంగా ఉంటుంది:

నా విషయంలో, తుది ఉత్పత్తిలో, అన్ని వెర్షన్‌ల ప్లగిన్‌లు ఒకే ఫోల్డర్‌లో ఉంచబడతాయి, కాబట్టి నా అసెంబ్లీ పేర్లు ఫారమ్ యొక్క ప్రత్యయంతో ఉంటాయి _20xx. ఫైల్‌లు వేర్వేరు ఫోల్డర్‌లలో ఉన్నట్లయితే మీరు అసెంబ్లీ పేరు నుండి ప్రత్యయాన్ని కూడా తీసివేయవచ్చు.

ఫైల్ కోడ్‌కి వెళ్దాం Class1.cs మరియు రివిట్ యొక్క విభిన్న సంస్కరణలను పరిగణనలోకి తీసుకుని, అక్కడ కొంత కోడ్‌ను అనుకరించండి:

namespace MySuperPluginForRevit
{
    using Autodesk.Revit.Attributes;
    using Autodesk.Revit.DB;
    using Autodesk.Revit.UI;

    [Regeneration(RegenerationOption.Manual)]
    [Transaction(TransactionMode.Manual)]
    public class Class1 : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
#if R2015
            TaskDialog.Show("ModPlus", "Hello Revit 2015");
#elif R2016
            TaskDialog.Show("ModPlus", "Hello Revit 2016");
#elif R2017
            TaskDialog.Show("ModPlus", "Hello Revit 2017");
#elif R2018
            TaskDialog.Show("ModPlus", "Hello Revit 2018");
#elif R2019
            TaskDialog.Show("ModPlus", "Hello Revit 2019");
#elif R2020
            TaskDialog.Show("ModPlus", "Hello Revit 2020");
#endif
            return Result.Succeeded;
        }
    }
}

నేను వెంటనే సంస్కరణ 2015 పైన ఉన్న Revit యొక్క అన్ని వెర్షన్‌లను పరిగణనలోకి తీసుకున్నాను (అవి వ్రాసే సమయంలో అందుబాటులో ఉన్నాయి) మరియు అదే టెంప్లేట్ ఉపయోగించి సృష్టించబడిన షరతులతో కూడిన సంకలన చిహ్నాల ఉనికిని వెంటనే పరిగణనలోకి తీసుకున్నాను.

ప్రధాన హైలైట్‌కి వెళ్దాం. రెవిట్ 2016 కోసం ప్లగిన్ వెర్షన్ కోసం మాత్రమే మేము మా పరిష్కారంలో కొత్త ప్రాజెక్ట్‌ను సృష్టిస్తాము. మేము పైన వివరించిన అన్ని దశలను వరుసగా పునరావృతం చేస్తాము, 2015 సంఖ్యను 2016 సంఖ్యతో భర్తీ చేస్తాము. కానీ ఫైల్ Class1.cs కొత్త ప్రాజెక్ట్ నుండి తొలగించండి.

అవసరమైన కోడ్‌తో ఫైల్ - Class1.cs - మా వద్ద ఇది ఇప్పటికే ఉంది మరియు మేము కొత్త ప్రాజెక్ట్‌లో దానికి లింక్‌ను ఇన్సర్ట్ చేయాలి. లింక్‌లను చొప్పించడానికి రెండు మార్గాలు ఉన్నాయి:

1. పొడవు - ప్రాజెక్ట్‌పై కుడి-క్లిక్ చేసి, ఎంచుకోండి "చేర్చు»->«ఇప్పటికే ఉన్న మూలకం", తెరుచుకునే విండోలో, అవసరమైన ఫైల్‌ను కనుగొనండి మరియు ఎంపికకు బదులుగా "చేర్చు"ఐచ్ఛికాన్ని ఎంచుకోండి"కనెక్షన్‌గా జోడించండి»

1. చిన్న - నేరుగా సొల్యూషన్ ఎక్స్‌ప్లోరర్‌లో, కావలసిన ఫైల్‌ను (లేదా ఫైల్‌లు లేదా మొత్తం ఫోల్డర్‌లు కూడా) ఎంచుకుని, Alt కీని నొక్కి ఉంచేటప్పుడు దాన్ని కొత్త ప్రాజెక్ట్‌లోకి లాగండి. మీరు డ్రాగ్ చేస్తున్నప్పుడు, మీరు Alt కీని నొక్కినప్పుడు, మౌస్ కర్సర్ ప్లస్ గుర్తు నుండి బాణంలోకి మారుతుందని మీరు చూస్తారు.
   యుపిడి: నేను ఈ పేరాలో కొంచెం గందరగోళం చేసాను - అనేక ఫైల్‌లను బదిలీ చేయడానికి మీరు నొక్కి ఉంచాలి Shift + Alt!

ప్రక్రియను నిర్వహించిన తర్వాత, మేము రెండవ ప్రాజెక్ట్‌లో ఫైల్‌ను కలిగి ఉంటాము Class1.cs సంబంధిత చిహ్నంతో (నీలం బాణం):

ఎడిటర్ విండోలో కోడ్‌ని ఎడిట్ చేస్తున్నప్పుడు, కోడ్‌ని ఏ ప్రాజెక్ట్ కాంటెక్స్ట్‌లో ప్రదర్శించాలో కూడా మీరు ఎంచుకోవచ్చు, ఇది వివిధ షరతులతో కూడిన సంకలన చిహ్నాల క్రింద కోడ్‌ని సవరించడాన్ని చూడటానికి మిమ్మల్ని అనుమతిస్తుంది:

మేము ఈ పథకాన్ని ఉపయోగించి అన్ని ఇతర ప్రాజెక్ట్‌లను (2017-2020) సృష్టిస్తాము. లైఫ్ హ్యాక్ - మీరు సొల్యూషన్ ఎక్స్‌ప్లోరర్‌లోని ఫైల్‌లను బేస్ ప్రాజెక్ట్ నుండి కాకుండా, అవి ఇప్పటికే లింక్‌గా చొప్పించిన ప్రాజెక్ట్ నుండి లాగితే, మీరు Alt కీని నొక్కి ఉంచాల్సిన అవసరం లేదు!

ప్లగిన్ యొక్క క్రొత్త సంస్కరణను జోడించే క్షణం వరకు లేదా ప్రాజెక్ట్‌కు కొత్త ఫైల్‌లను జోడించే క్షణం వరకు వివరించిన ఎంపిక చాలా మంచిది - ఇవన్నీ చాలా దుర్భరమైనవి. మరియు ఇటీవల నేను అకస్మాత్తుగా ఒక ప్రాజెక్ట్‌తో అన్నింటినీ ఎలా క్రమబద్ధీకరించాలో గ్రహించాను మరియు మేము రెండవ పద్ధతికి వెళుతున్నాము

కాన్ఫిగరేషన్ల మాయాజాలం

ఇక్కడ చదవడం పూర్తి చేసిన తర్వాత, “వ్యాసం వెంటనే రెండవదాని గురించి అయితే, మీరు మొదటి పద్ధతిని ఎందుకు వివరించారు?!” అని మీరు ఆశ్చర్యపోవచ్చు. మరియు మనకు షరతులతో కూడిన సంకలన చిహ్నాలు ఎందుకు అవసరమో మరియు మా ప్రాజెక్ట్‌లు ఏయే ప్రదేశాలలో విభిన్నంగా ఉన్నాయో స్పష్టంగా చెప్పడానికి నేను ప్రతిదీ వివరించాను. మరియు ఇప్పుడు మనం అమలు చేయాల్సిన ప్రాజెక్ట్‌లలో తేడాలు ఏమిటో స్పష్టంగా తెలుస్తుంది, ఒక ప్రాజెక్ట్ మాత్రమే మిగిలి ఉంది.

మరియు ప్రతిదీ మరింత స్పష్టంగా చేయడానికి, మేము కొత్త ప్రాజెక్ట్‌ను సృష్టించము, కానీ మొదటి మార్గంలో సృష్టించబడిన మా ప్రస్తుత ప్రాజెక్ట్‌కు మార్పులు చేస్తాము.

కాబట్టి, అన్నింటిలో మొదటిది, మేము ప్రధానమైన (ఫైళ్లను నేరుగా కలిగి) మినహా పరిష్కారం నుండి అన్ని ప్రాజెక్ట్‌లను తీసివేస్తాము. ఆ. 2016-2020 సంస్కరణల కోసం ప్రాజెక్ట్‌లు. పరిష్కారంతో ఫోల్డర్‌ని తెరిచి, అక్కడ ఈ ప్రాజెక్ట్‌ల ఫోల్డర్‌లను తొలగించండి.

మా నిర్ణయంలో మాకు ఒక ప్రాజెక్ట్ మిగిలి ఉంది - MySuperPluginForRevit_2015. దాని లక్షణాలను తెరవండి మరియు:

1. ట్యాబ్‌లో "అప్లికేషన్"అసెంబ్లీ పేరు నుండి ప్రత్యయాన్ని తీసివేయండి _2015 (ఎందుకు అనేది తర్వాత తెలుస్తుంది)
2. ట్యాబ్‌లో "అసెంబ్లీ» షరతులతో కూడిన సంకలన చిహ్నాన్ని తీసివేయండి R2015 సంబంధిత ఫీల్డ్ నుండి

గమనిక: విజువల్ స్టూడియో యొక్క తాజా వెర్షన్ బగ్‌ని కలిగి ఉంది - షరతులతో కూడిన సంకలన చిహ్నాలు అందుబాటులో ఉన్నప్పటికీ ప్రాజెక్ట్ లక్షణాల విండోలో ప్రదర్శించబడవు. మీరు ఈ లోపాన్ని ఎదుర్కొంటే, మీరు వాటిని .csproj ఫైల్ నుండి మాన్యువల్‌గా తీసివేయాలి. అయితే, మేము ఇంకా దానిలో పని చేయాలి, కాబట్టి చదవండి.

ప్రత్యయాన్ని తీసివేయడం ద్వారా సొల్యూషన్ ఎక్స్‌ప్లోరర్ విండోలో ప్రాజెక్ట్ పేరు మార్చండి _2015 ఆపై పరిష్కారం నుండి ప్రాజెక్ట్ను తీసివేయండి. పరిపూర్ణవాదుల క్రమాన్ని మరియు భావాలను నిర్వహించడానికి ఇది అవసరం! మేము మా పరిష్కారం యొక్క ఫోల్డర్‌ని తెరిచి, ప్రాజెక్ట్ ఫోల్డర్‌ని అదే విధంగా పేరు మార్చాము మరియు ప్రాజెక్ట్‌ను తిరిగి సొల్యూషన్‌లోకి లోడ్ చేస్తాము.

కాన్ఫిగరేషన్ మేనేజర్‌ను తెరవండి. US కాన్ఫిగరేషన్ విడుదల సూత్రప్రాయంగా, ఇది అవసరం లేదు, కాబట్టి మేము దానిని తొలగిస్తాము. మేము ఇప్పటికే మనకు తెలిసిన పేర్లతో కొత్త కాన్ఫిగరేషన్‌లను సృష్టిస్తాము R2015, R2016, ..., R2020. మీరు ఇతర కాన్ఫిగరేషన్‌ల నుండి సెట్టింగ్‌లను కాపీ చేయనవసరం లేదని మరియు మీరు ప్రాజెక్ట్ కాన్ఫిగరేషన్‌లను సృష్టించాల్సిన అవసరం లేదని గుర్తుంచుకోండి:

ప్రాజెక్ట్‌తో ఫోల్డర్‌కి వెళ్లి, మీకు అనుకూలమైన ఎడిటర్‌లో .csproj పొడిగింపుతో ఫైల్‌ను తెరవండి. మార్గం ద్వారా, మీరు దీన్ని విజువల్ స్టూడియోలో కూడా తెరవవచ్చు - మీరు ప్రాజెక్ట్‌ను అన్‌లోడ్ చేయాలి ఆపై కావలసిన అంశం సందర్భ మెనులో ఉంటుంది:

ఎడిటర్ సమలేఖనం మరియు ప్రాంప్ట్ చేయడం వలన విజువల్ స్టూడియోలో ఎడిటింగ్ చేయడం ఉత్తమం.

ఫైల్‌లో మనం ఎలిమెంట్‌లను చూస్తాము ఆస్తి సమూహం - చాలా ఎగువన సాధారణమైనది, ఆపై పరిస్థితులు వస్తాయి. ఈ అంశాలు ప్రాజెక్ట్ నిర్మించబడినప్పుడు దాని లక్షణాలను సెట్ చేస్తాయి. షరతులు లేని మొదటి మూలకం, సాధారణ లక్షణాలను సెట్ చేస్తుంది మరియు షరతులతో కూడిన మూలకాలు, తదనుగుణంగా, కాన్ఫిగరేషన్‌లను బట్టి కొన్ని లక్షణాలను మారుస్తాయి.

సాధారణ (మొదటి) మూలకానికి వెళ్లండి ఆస్తి సమూహం మరియు ఆస్తిని చూడండి అసెంబ్లీ పేరు – ఇది అసెంబ్లీ పేరు మరియు మనం దానిని ప్రత్యయం లేకుండా కలిగి ఉండాలి _2015. ప్రత్యయం ఉంటే, దాన్ని తీసివేయండి.

షరతుతో మూలకాన్ని కనుగొనడం

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

మాకు ఇది అవసరం లేదు - మేము దానిని తొలగిస్తాము.

షరతుతో కూడిన మూలకం

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

కోడ్ అభివృద్ధి మరియు డీబగ్గింగ్ దశలో పని చేయడం అవసరం. మీరు మీ అవసరాలకు అనుగుణంగా దాని లక్షణాలను మార్చవచ్చు - విభిన్న అవుట్‌పుట్ మార్గాలను సెట్ చేయండి, షరతులతో కూడిన సంకలన చిహ్నాలను మార్చండి, మొదలైనవి.

ఇప్పుడు కొత్త ఎలిమెంట్లను క్రియేట్ చేద్దాం ఆస్తి సమూహం మా కాన్ఫిగరేషన్ల కోసం. ఈ అంశాలలో మనం కేవలం నాలుగు లక్షణాలను సెట్ చేయాలి:

• అవుట్‌పుట్‌పాత్ - అవుట్పుట్ ఫోల్డర్. నేను డిఫాల్ట్ విలువను సెట్ చేసాను binR20xx
• నిలకడలను నిర్వచించండి - షరతులతో కూడిన సంకలన చిహ్నాలు. విలువను పేర్కొనాలి ట్రేస్;R20xx
• టార్గెట్‌ఫ్రేమ్‌వర్క్ వెర్షన్ - ప్లాట్‌ఫారమ్ వెర్షన్. Revit API యొక్క విభిన్న సంస్కరణలకు వేర్వేరు ప్లాట్‌ఫారమ్‌లను పేర్కొనడం అవసరం.
• అసెంబ్లీ పేరు - అసెంబ్లీ పేరు (అంటే ఫైల్ పేరు). మీరు అసెంబ్లీ యొక్క ఖచ్చితమైన పేరును వ్రాయవచ్చు, కానీ బహుముఖ ప్రజ్ఞ కోసం నేను విలువను వ్రాయమని సిఫార్సు చేస్తున్నాను $(AsemblyName)_20хх. దీన్ని చేయడానికి, మేము గతంలో అసెంబ్లీ పేరు నుండి ప్రత్యయాన్ని తీసివేసాము

ఈ అంశాలన్నింటి యొక్క అతి ముఖ్యమైన లక్షణం ఏమిటంటే, వాటిని అస్సలు మార్చకుండా ఇతర ప్రాజెక్ట్‌లలోకి కాపీ చేయవచ్చు. తరువాత వ్యాసంలో నేను .csproj ఫైల్‌లోని అన్ని విషయాలను అటాచ్ చేస్తాను.

సరే, మేము ప్రాజెక్ట్ యొక్క లక్షణాలను కనుగొన్నాము - ఇది కష్టం కాదు. కానీ ప్లగ్-ఇన్ లైబ్రరీలతో (NuGet ప్యాకేజీలు) ఏమి చేయాలి. మేము మరింత పరిశీలిస్తే, చేర్చబడిన లైబ్రరీలు మూలకాలలో పేర్కొనబడినట్లు చూస్తాము అంశం సమూహం. కానీ దురదృష్టం - ఈ మూలకం ఒక మూలకం వలె పరిస్థితులను తప్పుగా ప్రాసెస్ చేస్తుంది ఆస్తి సమూహం. బహుశా ఇది విజువల్ స్టూడియో గ్లిచ్ కూడా కావచ్చు, కానీ మీరు అనేక అంశాలను పేర్కొన్నట్లయితే అంశం సమూహం కాన్ఫిగరేషన్ షరతులతో, మరియు లోపల NuGet ప్యాకేజీలకు వేర్వేరు లింక్‌లను చొప్పించండి, ఆపై మీరు కాన్ఫిగరేషన్‌ను మార్చినప్పుడు, పేర్కొన్న అన్ని ప్యాకేజీలు ప్రాజెక్ట్‌కి కనెక్ట్ చేయబడతాయి.

మూలకం మన సహాయానికి వస్తుంది ఎంచుకోండి, ఇది మన సాధారణ తర్కం ప్రకారం పనిచేస్తుంది ఉంటే-అప్పుడు-లేకపోతే.

మూలకాన్ని ఉపయోగించడం ఎంచుకోండి, మేము వేర్వేరు కాన్ఫిగరేషన్‌ల కోసం వేర్వేరు NuGet ప్యాకేజీలను సెట్ చేసాము:

అన్ని విషయాలు csproj

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0"  ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{5AD738D6-4122-4E76-B865-BE7CE0F6B3EB}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>MySuperPluginForRevit</RootNamespace>
    <AssemblyName>MySuperPluginForRevit</AssemblyName>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <Deterministic>true</Deterministic>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>binDebug</OutputPath>
    <DefineConstants>DEBUG;R2015</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2015|AnyCPU' ">
    <OutputPath>binR2015</OutputPath>
    <DefineConstants>TRACE;R2015</DefineConstants>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2015</AssemblyName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2016|AnyCPU' ">
    <OutputPath>binR2016</OutputPath>
    <DefineConstants>TRACE;R2016</DefineConstants>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2016</AssemblyName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2017|AnyCPU' ">
    <OutputPath>binR2017</OutputPath>
    <DefineConstants>TRACE;R2017</DefineConstants>
    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2017</AssemblyName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2018|AnyCPU' ">
    <OutputPath>binR2018</OutputPath>
    <DefineConstants>TRACE;R2018</DefineConstants>
    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2018</AssemblyName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2019|AnyCPU' ">
    <OutputPath>binR2019</OutputPath>
    <DefineConstants>TRACE;R2019</DefineConstants>
    <TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2019</AssemblyName>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'R2020|AnyCPU' ">
    <OutputPath>binR2020</OutputPath>
    <DefineConstants>TRACE;R2020</DefineConstants>
    <TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
    <AssemblyName>$(AssemblyName)_2020</AssemblyName>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Class1.cs" />
    <Compile Include="PropertiesAssemblyInfo.cs" />
  </ItemGroup>
  <Choose>
    <When Condition=" '$(Configuration)'=='R2015' ">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2015">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
    <When Condition=" '$(Configuration)'=='R2016' ">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2016">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
    <When Condition=" '$(Configuration)'=='R2017' ">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2017">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
    <When Condition=" '$(Configuration)'=='R2018' ">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2018">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
    <When Condition=" '$(Configuration)'=='R2019' ">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2019">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
    <When Condition=" '$(Configuration)'=='R2020' or '$(Configuration)'=='Debug'">
      <ItemGroup>
        <PackageReference Include="ModPlus.Revit.API.2020">
          <Version>1.0.0</Version>
          <ExcludeAssets>runtime</ExcludeAssets>
        </PackageReference>
      </ItemGroup>
    </When>
  </Choose>
  <Import Project="$(MSBuildToolsPath)Microsoft.CSharp.targets" />
</Project>

షరతుల్లో ఒకదానిలో నేను రెండు కాన్ఫిగరేషన్‌లను పేర్కొన్నానని దయచేసి గమనించండి లేదా. ఈ విధంగా కాన్ఫిగరేషన్ సమయంలో అవసరమైన ప్యాకేజీ కనెక్ట్ చేయబడుతుంది డీబగ్.

మరియు ఇక్కడ మనకు దాదాపు ప్రతిదీ ఖచ్చితంగా ఉంది. మేము ప్రాజెక్ట్‌ను తిరిగి లోడ్ చేస్తాము, మనకు అవసరమైన కాన్ఫిగరేషన్‌ను ప్రారంభించండి, పరిష్కారం యొక్క సందర్భ మెనులో ఐటెమ్‌ను కాల్ చేయండి (ప్రాజెక్ట్ కాదు)అన్ని NuGet ప్యాకేజీలను పునరుద్ధరించండి"మరియు మా ప్యాకేజీలు ఎలా మారతాయో మేము చూస్తాము.

మరియు ఈ దశలో నేను డెడ్ ఎండ్‌కి వచ్చాను - అన్ని కాన్ఫిగరేషన్‌లను ఒకేసారి సేకరించడానికి, మేము బ్యాచ్ అసెంబ్లీని ఉపయోగించవచ్చు (మెను "అసెంబ్లీ»->«బ్యాచ్ బిల్డ్"), కానీ కాన్ఫిగరేషన్‌లను మార్చేటప్పుడు, ప్యాకేజీలు స్వయంచాలకంగా పునరుద్ధరించబడవు. మరియు ప్రాజెక్ట్‌ను సమీకరించేటప్పుడు, ఇది కూడా జరగదు, అయినప్పటికీ, సిద్ధాంతంలో, ఇది చేయాలి. నేను ప్రామాణిక మార్గాలను ఉపయోగించి ఈ సమస్యకు పరిష్కారం కనుగొనలేదు. మరియు చాలా మటుకు ఇది కూడా విజువల్ స్టూడియో బగ్.

అందువల్ల, బ్యాచ్ అసెంబ్లీ కోసం, ప్రత్యేక ఆటోమేటెడ్ అసెంబ్లీ వ్యవస్థను ఉపయోగించాలని నిర్ణయించారు Nuke. నేను దీన్ని నిజంగా కోరుకోలేదు ఎందుకంటే ఇది ప్లగ్ఇన్ డెవలప్‌మెంట్ పరంగా ఓవర్ కిల్ అని నేను భావిస్తున్నాను, కానీ ప్రస్తుతానికి నాకు వేరే పరిష్కారం కనిపించడం లేదు. మరియు "ఎందుకు న్యూక్?" అనే ప్రశ్నకు సమాధానం సులభం - మేము దానిని పనిలో ఉపయోగిస్తాము.

కాబట్టి, మా పరిష్కారం యొక్క ఫోల్డర్‌కు వెళ్లండి (ప్రాజెక్ట్ కాదు), కీని నొక్కి ఉంచండి మార్పు మరియు ఫోల్డర్‌లోని ఖాళీ స్థలంపై కుడి-క్లిక్ చేయండి - సందర్భ మెనులో ఐటెమ్‌ను ఎంచుకోండి "పవర్‌షెల్ విండోను ఇక్కడ తెరవండి".

మీరు దీన్ని ఇన్‌స్టాల్ చేయకుంటే nuke, అప్పుడు మొదట ఆదేశాన్ని వ్రాయండి

dotnet tool install Nuke.GlobalTool –global

ఇప్పుడు ఆదేశాన్ని వ్రాయండి nuke మరియు మీరు కాన్ఫిగర్ చేయమని ప్రాంప్ట్ చేయబడతారు nuke ప్రస్తుత ప్రాజెక్ట్ కోసం. రష్యన్ భాషలో దీన్ని మరింత సరిగ్గా ఎలా వ్రాయాలో నాకు తెలియదు - ఆంగ్లంలో ఇది వ్రాయబడుతుంది Could not find .nuke file. మీరు బిల్డ్‌ని సెటప్ చేయాలనుకుంటున్నారా? [y/n]

Y కీని నొక్కండి, ఆపై ప్రత్యక్ష సెట్టింగ్‌ల అంశాలు ఉంటాయి. మేము ఉపయోగించి సరళమైన ఎంపిక అవసరం MSBuild, కాబట్టి మేము స్క్రీన్‌షాట్‌లో ఉన్నట్లుగా సమాధానం ఇస్తాము:

విజువల్ స్టూడియోకి వెళ్దాం, దానికి కొత్త ప్రాజెక్ట్ జోడించబడినందున, పరిష్కారాన్ని మళ్లీ లోడ్ చేయమని ఇది మనల్ని ప్రేరేపిస్తుంది. మేము పరిష్కారాన్ని మళ్లీ లోడ్ చేస్తాము మరియు మాకు ప్రాజెక్ట్ ఉందని చూస్తాము నిర్మించడానికి దీనిలో మేము ఒక ఫైల్‌పై మాత్రమే ఆసక్తి కలిగి ఉన్నాము - Build.cs

ఈ ఫైల్‌ని తెరిచి, అన్ని కాన్ఫిగరేషన్‌ల కోసం ప్రాజెక్ట్‌ను రూపొందించడానికి స్క్రిప్ట్‌ను వ్రాయండి. సరే, లేదా నా స్క్రిప్ట్‌ని ఉపయోగించండి, దీన్ని మీరు మీ అవసరాలకు అనుగుణంగా సవరించవచ్చు:

using System.IO;
using Nuke.Common;
using Nuke.Common.Execution;
using Nuke.Common.ProjectModel;
using Nuke.Common.Tools.MSBuild;
using static Nuke.Common.Tools.MSBuild.MSBuildTasks;

[CheckBuildProjectConfigurations]
[UnsetVisualStudioEnvironmentVariables]
class Build : NukeBuild
{
    public static int Main () => Execute<Build>(x => x.Compile);

    [Solution] readonly Solution Solution;

    // If the solution name and the project (plugin) name are different, then indicate the project (plugin) name here
    string PluginName => Solution.Name;

    Target Compile => _ => _
        .Executes(() =>
        {
            var project = Solution.GetProject(PluginName);
            if (project == null)
                throw new FileNotFoundException("Not found!");

            var build = new List<string>();
            foreach (var (_, c) in project.Configurations)
            {
                var configuration = c.Split("|")[0];

                if (configuration == "Debug" || build.Contains(configuration))
                    continue;

                Logger.Normal($"Configuration: {configuration}");

                build.Add(configuration);

                MSBuild(_ => _
                    .SetProjectFile(project.Path)
                    .SetConfiguration(configuration)
                    .SetTargets("Restore"));
                MSBuild(_ => _
                    .SetProjectFile(project.Path)
                    .SetConfiguration(configuration)
                    .SetTargets("Rebuild"));
            }
        });
}

మేము పవర్‌షెల్ విండోకు తిరిగి వెళ్లి ఆదేశాన్ని మళ్లీ వ్రాస్తాము nuke (మీరు ఆదేశాన్ని వ్రాయవచ్చు nuke అవసరాన్ని సూచిస్తుంది టార్గెట్. కానీ మన దగ్గర ఒకటి ఉంది టార్గెట్, ఇది డిఫాల్ట్‌గా నడుస్తుంది). Enter కీని నొక్కిన తర్వాత, మేము నిజమైన హ్యాకర్లుగా భావిస్తాము, ఎందుకంటే, చలనచిత్రంలో వలె, మా ప్రాజెక్ట్ వివిధ కాన్ఫిగరేషన్ల కోసం స్వయంచాలకంగా అసెంబుల్ చేయబడుతుంది.

మార్గం ద్వారా, మీరు నేరుగా Visual Studio నుండి PowerShellని ఉపయోగించవచ్చు (మెనూ "వీక్షణ»->«ఇతర విండోస్»->«ప్యాకేజీ మేనేజర్ కన్సోల్"), కానీ ప్రతిదీ నలుపు మరియు తెలుపులో ఉంటుంది, ఇది చాలా సౌకర్యవంతంగా ఉండదు.

ఇది నా వ్యాసాన్ని ముగించింది. మీరు AutoCAD ఎంపికను మీరే గుర్తించగలరని నేను ఖచ్చితంగా అనుకుంటున్నాను. ఇక్కడ సమర్పించబడిన మెటీరియల్ దాని “క్లయింట్‌లను” కనుగొంటుందని నేను ఆశిస్తున్నాను.

Спасибо!

మూలం: www.habr.com