🥇Մենք պատրաստում ենք մեկ փլագին նախագիծ Revit/AutoCAD-ի տարբեր տարբերակների կոմպիլյացիայով

CAD հավելվածների համար պլագիններ մշակելիս (Իմ դեպքում սրանք AutoCAD-ը, Revit-ը և Renga-ն են) ժամանակի ընթացքում մեկ խնդիր է առաջանում՝ թողարկվում են ծրագրերի նոր տարբերակներ, դրանց API-ի փոփոխությունները և պլագինների նոր տարբերակները պետք է պատրաստվեն:

Երբ ունես միայն մեկ փլագին կամ դեռ ինքնուս սկսնակ ես այս հարցում, կարող ես ուղղակի պատճենել նախագծին, փոխել դրա անհրաժեշտ տեղերը և հավաքել փլագինի նոր տարբերակը։ Համապատասխանաբար, օրենսգրքի հետագա փոփոխությունները կհանգեցնեն աշխատուժի ծախսերի բազմակի աճ:

Փորձ և գիտելիքներ ձեռք բերելով, դուք կգտնեք այս գործընթացը ավտոմատացնելու մի քանի եղանակ: Ես քայլեցի այս ճանապարհով և ուզում եմ պատմել, թե ինչով եմ վերջացել և որքանով է դա հարմար։

Նախ, եկեք տեսնենք մի մեթոդ, որն ակնհայտ է և որը ես երկար ժամանակ օգտագործել եմ:

Հղումներ նախագծի ֆայլերին

Եվ ամեն ինչ պարզ, տեսողական և հասկանալի դարձնելու համար ես կնկարագրեմ ամեն ինչ՝ օգտագործելով plugin-ի մշակման վերացական օրինակ:

Եկեք բացենք Visual Studio-ն (ես ունեմ Համայնքի 2019 տարբերակ: Եվ այո, ռուսերեն) և ստեղծենք նոր լուծում: Եկեք զանգենք նրան MySuperPluginForRevit

Մենք կպատրաստենք Revit-ի համար հավելված 2015-2020 տարբերակների համար: Հետևաբար, եկեք լուծումում ստեղծենք նոր նախագիծ (Net Framework Class Library) և կոչենք այն MySuperPluginForRevit_2015

Մենք պետք է հղումներ ավելացնենք Revit API-ին: Իհարկե, մենք կարող ենք հղումներ ավելացնել տեղական ֆայլերին (մեզ անհրաժեշտ կլինի տեղադրել բոլոր անհրաժեշտ SDK-ները կամ Revit-ի բոլոր տարբերակները), բայց մենք անմիջապես կգնանք ճիշտ ճանապարհով և կմիացնենք NuGet փաթեթը։ Դուք կարող եք գտնել բավականին շատ փաթեթներ, բայց ես կօգտագործեմ իմը:

Փաթեթը միացնելուց հետո աջ սեղմեք կետի վրա «Սայլակ«Եվ ընտրեք տարրը»Տեղափոխեք packages.config-ը PackageReference...»

Եթե հանկարծ այս պահին դուք սկսեք խուճապի մատնվել, քանի որ փաթեթի հատկությունների պատուհանում որևէ կարևոր կետ չի լինի:Պատճենեք տեղայնորեն», որը մենք անպայման պետք է սահմանենք արժեքի վրա սուտ, ապա խուճապի մի մատնվեք. գնացեք նախագծի հետ կապված թղթապանակ, բացեք ֆայլը .csproj ընդլայնմամբ ձեզ հարմար խմբագրում (ես օգտագործում եմ Notepad++) և այնտեղ գտեք մեր փաթեթի մասին գրառումը։ Նա այժմ այսպիսի տեսք ունի.

<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>

Այժմ, նախագիծ կառուցելիս, փաթեթից ֆայլերը չեն պատճենվի ելքային թղթապանակում:
Եկեք գնանք ավելի հեռու. եկեք անմիջապես պատկերացնենք, որ մեր plugin-ը կօգտագործի Revit API-ից ինչ-որ բան, որը ժամանակի ընթացքում փոխվել է, երբ թողարկվել են նոր տարբերակներ: Դե, կամ մենք պարզապես պետք է ինչ-որ բան փոխենք կոդի մեջ՝ կախված Revit-ի տարբերակից, որի համար մենք պատրաստում ենք plugin-ը: Կոդի նման տարբերությունները լուծելու համար մենք կօգտագործենք պայմանական կոմպիլյացիայի նշաններ: Բացեք նախագծի հատկությունները, անցեք « ներդիրԱսամբլեան«և դաշտում»Պայմանական կազմման նշում«գրենք R2015.

Նկատի ունեցեք, որ խորհրդանիշը պետք է ավելացվի ինչպես Debug, այնպես էլ Release կոնֆիգուրացիաների համար:

Դե, մինչ մենք հատկությունների պատուհանում ենք, մենք անմիջապես գնում ենք « ներդիրApp«և դաշտում»Կանխադրված անվանատարածք» հեռացնել վերջածանցը _2015այնպես որ մեր անվանատարածքը համընդհանուր է և անկախ ժողովի անունից.

Իմ դեպքում, վերջնական արտադրանքում, բոլոր տարբերակների պլագինները տեղադրվում են մեկ թղթապանակում, այնպես որ իմ հավաքների անունները մնում են ձևի վերջածանցով _20хх. Բայց դուք կարող եք նաև հեռացնել վերջածանցը հավաքման անունից, եթե ենթադրվում է, որ ֆայլերը գտնվում են տարբեր թղթապանակներում:

Եկեք անցնենք ֆայլի կոդը Class1.cs և այնտեղ որոշ կոդ մոդելավորեք՝ հաշվի առնելով Revit-ի տարբեր տարբերակները.

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;
        }
    }
}

Ես անմիջապես հաշվի առա Revit-ի 2015-ի վերևի տարբերակի բոլոր տարբերակները (որոնք հասանելի էին գրելու պահին) և անմիջապես հաշվի առա պայմանական կոմպիլյացիայի նշանների առկայությունը, որոնք ստեղծվում են նույն ձևանմուշով:

Անցնենք գլխավոր շեշտադրմանը: Մենք ստեղծում ենք նոր նախագիծ մեր լուծման մեջ, միայն Revit 2016-ի հավելյալ տարբերակի համար: Մենք կրկնում ենք վերը նկարագրված բոլոր քայլերը, համապատասխանաբար, փոխարինելով 2015 թիվը 2016 թվով: Բայց ֆայլը Class1.cs ջնջել նոր նախագծից:

Պահանջվող կոդով ֆայլ - Class1.cs – մենք արդեն ունենք այն, և մենք պարզապես պետք է դրա հղումը տեղադրենք նոր նախագծում: Հղումներ տեղադրելու երկու եղանակ կա.

Երկար - աջ սեղմեք նախագծի վրա և ընտրեք «Ավելացնել»->«Առկա տարր", բացվող պատուհանում գտեք անհրաժեշտ ֆայլը և ընտրանքի փոխարեն"Ավելացնել«ընտրիր տարբերակը»Ավելացնել որպես կապ»

Կարճ – անմիջապես լուծումների որոնման մեջ ընտրեք ցանկալի ֆայլը (կամ նույնիսկ ֆայլերը կամ նույնիսկ ամբողջ թղթապանակները) և քաշեք այն նոր նախագծի մեջ՝ սեղմած Alt ստեղնը պահելով: Քաշելիս կտեսնեք, որ երբ սեղմում եք Alt ստեղնը, մկնիկի կուրսորը գումարած նշանից կվերածվի սլաքի:
UPS: Ես մի փոքր շփոթեցի այս պարբերությունում. մի քանի ֆայլեր փոխանցելու համար դուք պետք է սեղմած պահեք Shift + Alt!

Ընթացակարգն իրականացնելուց հետո երկրորդ նախագծում կունենանք ֆայլ Class1.cs համապատասխան պատկերակով (կապույտ սլաք).

Խմբագրի պատուհանում կոդը խմբագրելիս կարող եք նաև ընտրել, թե որ նախագծի համատեքստում կցուցադրվի կոդը, ինչը թույլ կտա ձեզ տեսնել, որ կոդը խմբագրվում է տարբեր պայմանական կոմպիլյացիայի նշանների ներքո.

Մենք ստեղծում ենք բոլոր մյուս նախագծերը (2017-2020) օգտագործելով այս սխեմա: Life hack. Եթե Solution Explorer-ում ֆայլերը քաշում եք ոչ թե բազային նախագծից, այլ այն նախագծից, որտեղ դրանք արդեն տեղադրված են որպես հղում, ապա պետք չէ սեղմած պահել Alt ստեղնը:

Նկարագրված տարբերակը բավականին լավ է մինչև հավելվածի նոր տարբերակ ավելացնելու պահը կամ մինչև նախագծում նոր ֆայլեր ավելացնելու պահը. այս ամենը դառնում է շատ հոգնեցուցիչ: Եվ վերջերս ես հանկարծ հանկարծ հասկացա, թե ինչպես կարելի է ամեն ինչ դասավորել մեկ նախագծով, և մենք անցնում ենք երկրորդ մեթոդին

Կոնֆիգուրացիաների կախարդանք

Այստեղ կարդալն ավարտելուց հետո դուք կարող եք բացականչել. «Ինչու՞ նկարագրեցիք առաջին մեթոդը, եթե հոդվածը անմիջապես վերաբերում է երկրորդին»: Եվ ես նկարագրեցի ամեն ինչ, որպեսզի ավելի պարզ լինի, թե ինչու են մեզ անհրաժեշտ պայմանական կոմպիլյացիոն սիմվոլներ և ինչ տեղերում են տարբերվում մեր նախագծերը։ Եվ հիմա մեզ համար ավելի պարզ է դառնում, թե նախագծերի ինչ տարբերություններ պետք է իրականացնենք՝ թողնելով միայն մեկ նախագիծ։

Եվ որպեսզի ամեն ինչ ավելի ակնհայտ լինի, մենք ոչ թե նոր նախագիծ կստեղծենք, այլ փոփոխություններ կանենք առաջին ձևով ստեղծված մեր ներկայիս նախագծի մեջ։

Այսպիսով, առաջին հերթին մենք լուծումից հեռացնում ենք բոլոր նախագծերը, բացառությամբ հիմնականի (ուղղակիորեն պարունակող ֆայլերը): Նրանք. նախագծեր 2016-2020 տարբերակների համար։ Բացեք թղթապանակը լուծումով և այնտեղ ջնջեք այս նախագծերի թղթապանակները:

Մեր որոշման մեջ մնացել է մեկ նախագիծ. MySuperPluginForRevit_2015. Բացեք դրա հատկությունները և.

Ներդիրում «App«հեռացնել վերջածանցը ժողովի անունից _2015 (թե ինչու, պարզ կդառնա ավելի ուշ)
Ներդիրում «Ասամբլեան» հանել պայմանական կազմման նշանը R2015 համապատասխան դաշտից

Նշում. Visual Studio-ի վերջին տարբերակն ունի վրիպակ. պայմանական կոմպիլյացիայի նշանները չեն ցուցադրվում նախագծի հատկությունների պատուհանում, թեև դրանք հասանելի են: Եթե դուք զգում եք այս անսարքությունը, ապա դուք պետք է դրանք ձեռքով հեռացնեք .csproj ֆայլից: Այնուամենայնիվ, մենք դեռ պետք է աշխատենք դրա վրա, այնպես որ կարդացեք:

Վերանվանեք նախագիծը Solution Explorer պատուհանում՝ հեռացնելով վերջածանցը _2015 և ապա հեռացնել նախագիծը լուծումից: Սա անհրաժեշտ է պերֆեկցիոնիստների կարգուկանոնն ու զգացմունքները պահպանելու համար: Մենք բացում ենք մեր լուծման թղթապանակը, նույն կերպ վերանվանում նախագծի թղթապանակը և նորից բեռնում նախագիծը լուծման մեջ։

Բացեք կազմաձևման կառավարիչը: ԱՄՆ կոնֆիգուրացիա Ազատ սկզբունքորեն դա պետք չի լինի, ուստի ջնջում ենք։ Մենք ստեղծում ենք նոր կոնֆիգուրացիաներ մեզ արդեն ծանոթ անուններով R2015, R2016, ..., R2020. Նկատի ունեցեք, որ ձեզ հարկավոր չէ պատճենել կարգավորումները այլ կոնֆիգուրացիաներից և ձեզ հարկավոր չէ ստեղծել նախագծի կազմաձևեր.

Գնացեք նախագծի հետ կապված թղթապանակ և բացեք ֆայլը .csproj ընդլայնմամբ ձեզ հարմար խմբագրիչով: Ի դեպ, դուք կարող եք նաև բացել այն Visual Studio-ում, դուք պետք է բեռնաթափեք նախագիծը և այնուհետև ցանկալի տարրը կլինի համատեքստի ընտրացանկում.

Visual Studio-ում խմբագրումը նույնիսկ նախընտրելի է, քանի որ խմբագրիչը և՛ հարթեցնում է, և՛ հուշում:

Ֆայլում մենք կտեսնենք տարրերը PropertyGroup – ամենավերևում ընդհանուրն է, իսկ հետո՝ պայմանները։ Այս տարրերը սահմանում են նախագծի հատկությունները, երբ այն կառուցվում է: Առաջին տարրը, որն առանց պայմանների է, սահմանում է ընդհանուր հատկություններ, իսկ պայմաններով տարրերը, համապատասխանաբար, փոխում են որոշ հատկություններ՝ կախված կոնֆիգուրացիաներից։

Անցեք ընդհանուր (առաջին) տարրին PropertyGroup և նայեք գույքին Ասամբլեայի անվանումը – սա ժողովի անունն է և այն պետք է ունենանք առանց վերջածանցի _2015. Եթե կա վերջածանց, ապա հեռացրեք այն։

Պայմանով տարր գտնելը

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

Մեզ դա պետք չէ, մենք այն ջնջում ենք:

Տարր պայմանով

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

կպահանջվի կոդի մշակման և վրիպազերծման փուլում աշխատելու համար։ Դուք կարող եք փոխել դրա հատկությունները ձեր կարիքներին համապատասխան՝ սահմանել տարբեր ելքային ուղիներ, փոխել պայմանական կոմպիլյացիայի նշանները և այլն:

Հիմա եկեք ստեղծենք նոր տարրեր PropertyGroup մեր կոնֆիգուրացիաների համար: Այս տարրերում մենք պարզապես պետք է սահմանենք չորս հատկություն.

OutputPath - ելքային թղթապանակ: Ես սահմանել եմ լռելյայն արժեքը binR20xx
Սահմանել հաստատունները - պայմանական կոմպիլյացիայի նշաններ: Արժեքը պետք է նշվի ՀԵՏՔ;R20хх
TargetFrameworkVersion - հարթակի տարբերակ: Revit API-ի տարբեր տարբերակները պահանջում են տարբեր հարթակներ նշել:
Ասամբլեայի անվանումը - հավաքի անվանումը (այսինքն ֆայլի անունը): Դուք կարող եք գրել հավաքի ճշգրիտ անունը, բայց բազմակողմանիության համար խորհուրդ եմ տալիս գրել արժեքը $(AssemblyName)_20хх. Դա անելու համար մենք նախկինում հանել ենք վերջածանցը ժողովի անունից

Այս բոլոր տարրերի ամենակարևոր առանձնահատկությունն այն է, որ դրանք պարզապես կարող են պատճենվել այլ նախագծերում՝ առանց դրանք փոխելու: Հետագայում հոդվածում ես կցեմ .csproj ֆայլի ամբողջ բովանդակությունը։

Լավ, մենք պարզեցինք նախագծի հատկությունները. դա դժվար չէ: Բայց ինչ անել plug-in գրադարանների հետ (NuGet փաթեթներ): Եթե ավելի հեռուն նայենք, կտեսնենք, որ ներառված գրադարանները նշված են տարրերում Նյութերի խումբ. Բայց վատ բախտը - այս տարրը սխալ է մշակում պայմանները որպես տարր PropertyGroup. Հնարավոր է, սա նույնիսկ Visual Studio-ի անսարքություն է, բայց եթե նշեք մի քանի տարրեր Նյութերի խումբ կոնֆիգուրացիայի պայմաններով և ներսում տեղադրեք 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>

Խնդրում ենք նկատի ունենալ, որ պայմաններից մեկում ես նշել եմ երկու կոնֆիգուրացիա միջոցով ԿԱՄ. Այս կերպ անհրաժեշտ փաթեթը կմիացվի կազմաձևման ժամանակ Debug.

Եվ այստեղ մենք ունենք գրեթե ամեն ինչ կատարյալ: Մենք հետ ենք բեռնում նախագիծը, միացնում ենք մեզ անհրաժեշտ կոնֆիգուրացիան, անվանում ենք կետը «լուծման համատեքստի ընտրացանկում (ոչ թե նախագիծը)Վերականգնել բոլոր NuGet փաթեթները«Եվ մենք տեսնում ենք, թե ինչպես են փոխվում մեր փաթեթները։

Եվ այս փուլում ես մտա փակուղի. բոլոր կոնֆիգուրացիաները միանգամից հավաքելու համար մենք կարող էինք օգտագործել խմբաքանակի հավաքում (մենյու "Ասամբլեան»->«Խմբաքանակի կառուցում"), բայց կոնֆիգուրացիաները փոխելու ժամանակ փաթեթները ավտոմատ կերպով չեն վերականգնվում: Իսկ նախագիծը հավաքելիս դա նույնպես տեղի չի ունենում, թեև, տեսականորեն, պետք է: Ես ստանդարտ միջոցների օգտագործմամբ այս խնդրի լուծումը չեմ գտել։ Եվ, ամենայն հավանականությամբ, սա նաև Visual Studio-ի սխալ է:

Հետեւաբար, խմբաքանակի հավաքման համար որոշվեց օգտագործել հատուկ ավտոմատացված հավաքման համակարգ Նուկե. Ես իրականում չէի ուզում սա, քանի որ կարծում եմ, որ դա չափազանցված է plugin-ի մշակման առումով, բայց այս պահին ես այլ լուծում չեմ տեսնում: Իսկ «Ինչո՞ւ Նուկ» հարցին. Պատասխանը պարզ է՝ մենք այն օգտագործում ենք աշխատանքի ժամանակ։

Այսպիսով, գնացեք մեր լուծման թղթապանակը (ոչ թե նախագիծը), սեղմած պահեք բանալին Հերթափոխություն և աջ սեղմեք թղթապանակի դատարկ տարածության վրա - համատեքստի ընտրացանկում ընտրեք կետը «Բացեք PowerShell պատուհանը այստեղ.

Եթե դուք չունեք այն տեղադրված ԱԷԿ, ապա նախ գրեք հրամանը

dotnet tool install Nuke.GlobalTool –global

Այժմ գրեք հրամանը ԱԷԿ և ձեզ կառաջարկվի կարգավորել ԱԷԿ ընթացիկ նախագծի համար։ Ես չգիտեմ, թե ինչպես գրել սա ավելի ճիշտ ռուսերեն - անգլերենում գրվելու է Չհաջողվեց գտնել .nuke ֆայլը: Ցանկանու՞մ եք կառուցապատել: [y/n]

Սեղմեք Y ստեղնը, այնուհետև կլինեն ուղիղ կարգավորումների տարրեր: Մեզ պետք է օգտագործել ամենապարզ տարբերակը MSBuild, ուստի մենք պատասխանում ենք, ինչպես սքրինշոթում.

Եկեք գնանք Visual Studio, որը մեզ հուշում է վերաբեռնել լուծումը, քանի որ դրան ավելացվել է նոր նախագիծ։ Մենք վերաբեռնում ենք լուծումը և տեսնում, որ ունենք նախագիծ կառուցել որում մեզ հետաքրքրում է միայն մեկ ֆայլ՝ 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"));
            }
        });
}

Մենք վերադառնում ենք PowerShell պատուհանին և նորից գրում հրամանը ԱԷԿ (կարող եք գրել հրամանը ԱԷԿ նշելով պահանջվողը թիրախ. Բայց մենք ունենք մեկը թիրախ, որն աշխատում է լռելյայն): Enter ստեղնը սեղմելուց հետո մենք մեզ իրական հաքերներ կզգանք, քանի որ, ինչպես ֆիլմում, մեր նախագիծը ավտոմատ կերպով կհավաքվի տարբեր կոնֆիգուրացիաների համար։

Ի դեպ, PowerShell-ը կարող եք օգտագործել անմիջապես Visual Studio-ից (մենյու «Դիտել»->«Այլ պատուհաններ»->«Փաթեթի կառավարչի վահանակ«), բայց ամեն ինչ լինելու է սեւ-սպիտակ, ինչը այնքան էլ հարմար չէ։

Սա եզրափակում է իմ հոդվածը: Համոզված եմ, որ դուք ինքներդ կարող եք պարզել AutoCAD-ի տարբերակը: Հուսով եմ, որ այստեղ ներկայացված նյութը կգտնի իր «հաճախորդներին»։

Շնորհակալություն ձեր ուշադրության համար:

Source: www.habr.com

Մենք պատրաստում ենք մեկ plugin նախագիծ Revit/AutoCAD-ի տարբեր տարբերակների կոմպիլյացիայով

Հղումներ նախագծի ֆայլերին

Կոնֆիգուրացիաների կախարդանք

Добавить комментарий Չեղարկել պատասխանել