🥇 ვაკეთებთ ერთ მოდულის პროექტს Revit/AutoCAD-ის სხვადასხვა ვერსიის კომპილაციით

CAD აპლიკაციებისთვის დანამატების შემუშავებისას (ჩემს შემთხვევაში ეს არის AutoCAD, Revit და Renga) დროთა განმავლობაში, ჩნდება ერთი პრობლემა - გამოდის პროგრამების ახალი ვერსიები, საჭიროა მათი API ცვლილებები და მოდულების ახალი ვერსიების დამზადება.

როდესაც თქვენ გაქვთ მხოლოდ ერთი დანამატი ან ჯერ კიდევ ხართ თვითნასწავლი დამწყები ამ საკითხში, შეგიძლიათ უბრალოდ გააკეთოთ პროექტის ასლი, შეცვალოთ მასში საჭირო ადგილები და ააწყოთ მოდულის ახალი ვერსია. შესაბამისად, კოდექსში შემდგომი ცვლილებები გამოიწვევს შრომის ხარჯების მრავალჯერად ზრდას.

გამოცდილების და ცოდნის შეძენისას თქვენ იპოვით რამდენიმე გზას ამ პროცესის ავტომატიზაციისთვის. ეს გზა გავიარე და მინდა გითხრათ რითი დავასრულე და რამდენად მოსახერხებელია.

პირველ რიგში, მოდით შევხედოთ მეთოდს, რომელიც აშკარაა და რომელსაც დიდი ხანია ვიყენებ.

ბმულები პროექტის ფაილებთან

და იმისათვის, რომ ყველაფერი იყოს მარტივი, ვიზუალური და გასაგები, მე აღვწერ ყველაფერს დანამატის განვითარების აბსტრაქტული მაგალითის გამოყენებით.

მოდით გავხსნათ Visual Studio (მე მაქვს Community 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>

ახლა, პროექტის აშენებისას, პაკეტიდან ფაილები არ იქნება კოპირებული გამომავალი საქაღალდეში.
მოდით წავიდეთ უფრო შორს - დაუყოვნებლივ წარმოვიდგინოთ, რომ ჩვენი დანამატი გამოიყენებს რაღაც Revit API-დან, რომელიც დროთა განმავლობაში შეიცვალა ახალი ვერსიების გამოშვებისას. კარგად, ან უბრალოდ უნდა შევცვალოთ რაღაც კოდში, რაც დამოკიდებულია Revit-ის ვერსიაზე, რომლისთვისაც ჩვენ ვამზადებთ დანამატს. კოდებში ასეთი განსხვავებების მოსაგვარებლად, ჩვენ გამოვიყენებთ პირობით კომპილაციის სიმბოლოებს. გახსენით პროექტის თვისებები, გადადით " ჩანართზეასამბლეა"და მინდორში"პირობითი კომპილაციის აღნიშვნა"მოდი დავწეროთ R2015.

გაითვალისწინეთ, რომ სიმბოლო უნდა დაემატოს როგორც გამართვის, ასევე გამოშვების კონფიგურაციისთვის.

კარგად, სანამ თვისებების ფანჯარაში ვართ, მაშინვე გადავდივართ " ჩანართზეგანაცხადის"და მინდორში"ნაგულისხმევი სახელთა სივრცე» ამოიღეთ სუფიქსი _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 კლავიშზე დაჭერისას მაუსის კურსორი გარდაიქმნება პლუსის ნიშნიდან ისარზე.
UPD: ამ აბზაცში ცოტა დაბნეულობა მოვახდინე - რამდენიმე ფაილის გადასატანად თქვენ უნდა დააჭიროთ Shift + Alt!

პროცედურის განხორციელების შემდეგ მეორე პროექტში გვექნება ფაილი Class1.cs შესაბამისი ხატით (ლურჯი ისარი):

კოდის რედაქტირებისას რედაქტორის ფანჯარაში, თქვენ ასევე შეგიძლიათ აირჩიოთ პროექტის რომელ კონტექსტში აჩვენოთ კოდი, რაც საშუალებას მოგცემთ ნახოთ კოდის რედაქტირება სხვადასხვა პირობითი კომპილაციის სიმბოლოების ქვეშ:

ჩვენ ვქმნით ყველა სხვა პროექტს (2017-2020) ამ სქემის გამოყენებით. Life hack - თუ ფაილებს Solution Explorer-ში გადაიტანეთ არა საბაზისო პროექტიდან, არამედ იმ პროექტიდან, სადაც ისინი უკვე ჩასმულია ბმულის სახით, მაშინ არ გჭირდებათ Alt კლავიშის დაჭერა!

აღწერილი ვარიანტი საკმაოდ კარგია მოდულის ახალი ვერსიის დამატების მომენტამდე ან პროექტში ახალი ფაილების დამატების მომენტამდე - ეს ყველაფერი ძალიან დამღლელი ხდება. ახლახან კი უცებ მივხვდი, როგორ მოვაგვარო ეს ყველაფერი ერთი პროექტით და გადავდივართ მეორე მეთოდზე

კონფიგურაციების მაგია

აქ წაკითხვის დასრულების შემდეგ, თქვენ შეგიძლიათ თქვათ: "რატომ აღწერე პირველი მეთოდი, თუ სტატია დაუყოვნებლივ ეხება მეორეს?" და მე აღვწერე ყველაფერი, რათა უფრო ნათლად განვაცხადო, რატომ გვჭირდება პირობითი კომპილაციის სიმბოლოები და რა ადგილებში განსხვავდება ჩვენი პროექტები. ახლა კი ჩვენთვის უფრო ნათელი ხდება ზუსტად რა განსხვავებები პროექტებში უნდა განვახორციელოთ და მხოლოდ ერთი პროექტი დავტოვოთ.

და ყველაფერი უფრო ცხადი რომ იყოს, ჩვენ არ შევქმნით ახალ პროექტს, არამედ შევცვლით პირველ რიგში შექმნილ ჩვენს მიმდინარე პროექტს.

ასე რომ, უპირველეს ყოვლისა, ჩვენ ვხსნით ყველა პროექტს გადაწყვეტილებისგან, გარდა მთავარი (პირდაპირ ფაილებს შეიცავს). იმათ. პროექტები 2016-2020 ვერსიებისთვის. გახსენით საქაღალდე ხსნარით და წაშალეთ ამ პროექტების საქაღალდეები.

ჩვენს გადაწყვეტილებაში დარჩა ერთი პროექტი - MySuperPluginForRevit_2015. გახსენით მისი თვისებები და:

ჩანართზე "განაცხადის"ამოშალეთ სუფიქსი ასამბლეის სახელიდან _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
განსაზღვრეთ მუდმივები - პირობითი კომპილაციის სიმბოლოები. მნიშვნელობა უნდა იყოს მითითებული TRACE;R20хх
TargetFrameworkVersion - პლატფორმის ვერსია. Revit API-ის სხვადასხვა ვერსია მოითხოვს სხვადასხვა პლატფორმის მითითებას.
ასამბლეის სახელი - ასამბლეის სახელი (ანუ ფაილის სახელი). თქვენ შეგიძლიათ დაწეროთ ასამბლეის ზუსტი სახელი, მაგრამ მრავალფეროვნებისთვის გირჩევთ დაწეროთ მნიშვნელობა $(AssemblyName)_20хх. ამისათვის ჩვენ ადრე ამოიღეთ სუფიქსი ასამბლეის სახელიდან

ყველა ამ ელემენტის ყველაზე მნიშვნელოვანი მახასიათებელია ის, რომ მათი უბრალოდ კოპირება შესაძლებელია სხვა პროექტებში მათი საერთოდ შეცვლის გარეშე. მოგვიანებით სტატიაში დავამაგრებ .csproj ფაილის ყველა შინაარსს.

კარგი, ჩვენ გავარკვიეთ პროექტის თვისებები - ეს არ არის რთული. მაგრამ რა უნდა გავაკეთოთ დანამატებით ბიბლიოთეკებთან (NuGet პაკეტები). თუ უფრო შორს გადავხედავთ, დავინახავთ, რომ ჩართული ბიბლიოთეკები მითითებულია ელემენტებში ItemGroup. მაგრამ ცუდი იღბალი - ეს ელემენტი არასწორად ამუშავებს პირობებს, როგორც ელემენტს PropertyGroup. შესაძლოა, ეს არის Visual Studio-ს გაუმართაობა, მაგრამ თუ მიუთითებთ რამდენიმე ელემენტს ItemGroup კონფიგურაციის პირობებით და შიგნით ჩადეთ 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>

გთხოვთ გაითვალისწინოთ, რომ ერთ-ერთ პირობაში მე დავაზუსტე ორი კონფიგურაცია via ან. ამ გზით საჭირო პაკეტი დაუკავშირდება კონფიგურაციის დროს Debug.

და აქ ჩვენ გვაქვს თითქმის ყველაფერი სრულყოფილი. ჩვენ ვტვირთავთ პროექტს უკან, ჩავრთავთ ჩვენთვის საჭირო კონფიგურაციას, მოვუწოდებთ ელემენტს ” გადაწყვეტის კონტექსტურ მენიუში (არა პროექტი)აღადგინეთ ყველა NuGet პაკეტი"და ჩვენ ვხედავთ, როგორ იცვლება ჩვენი პაკეტები.

და ამ ეტაპზე მე მივედი ჩიხში - იმისათვის, რომ ერთდროულად შეგვეგროვებინა ყველა კონფიგურაცია, შეგვეძლო გამოვიყენოთ სურათების შეკრება (მენიუ "ასამბლეა»->«პარტიული აგება"), მაგრამ კონფიგურაციების გადართვისას, პაკეტები ავტომატურად არ აღდგება. და პროექტის აწყობისას, ეს ასევე არ ხდება, თუმცა, თეორიულად, ასეც უნდა იყოს. მე ვერ ვიპოვე ამ პრობლემის გადაწყვეტა სტანდარტული საშუალებების გამოყენებით. და, სავარაუდოდ, ეს ასევე არის Visual Studio-ს შეცდომა.

ამიტომ, პარტიული შეკრებისთვის გადაწყდა სპეციალური ავტომატური შეკრების სისტემის გამოყენება Nuke. მე რეალურად არ მინდოდა ეს, რადგან ვფიქრობ, რომ ეს ზედმეტია დანამატების განვითარების თვალსაზრისით, მაგრამ ამ მომენტში სხვა გამოსავალს ვერ ვხედავ. და კითხვაზე "რატომ ნუკი?" პასუხი მარტივია - ჩვენ მას სამსახურში ვიყენებთ.

ასე რომ, გადადით ჩვენი გადაწყვეტის საქაღალდეში (არა პროექტი), დაჭერით გასაღები გადაიტანოს და დააწკაპუნეთ მაუსის მარჯვენა ღილაკით საქაღალდეში ცარიელ სივრცეზე - კონტექსტურ მენიუში აირჩიეთ ელემენტი ”გახსენით PowerShell ფანჯარა აქ".

თუ არ გაქვს დაინსტალირებული ნუკე, შემდეგ ჯერ დაწერეთ ბრძანება

dotnet tool install Nuke.GlobalTool –global

ახლა დაწერეთ ბრძანება ნუკე და მოგეთხოვებათ კონფიგურაცია ნუკე მიმდინარე პროექტისთვის. არ ვიცი როგორ დავწერო ეს უფრო სწორად რუსულად - ინგლისურად დაიწერება ვერ ვიპოვე .nuke ფაილი. გსურთ დააყენოთ build? [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-ის ვარიანტი. ვიმედოვნებ, რომ აქ წარმოდგენილი მასალა იპოვის თავის „კლიენტებს“.

დიდი მადლობა!

წყარო: www.habr.com

ჩვენ ვაკეთებთ ერთ მოდულის პროექტს Revit/AutoCAD-ის სხვადასხვა ვერსიების კომპილაციით

ბმულები პროექტის ფაილებთან

კონფიგურაციების მაგია

ახალი კომენტარის დამატება

ჩვენ ვაკეთებთ ერთ მოდულის პროექტს Revit/AutoCAD-ის სხვადასხვა ვერსიების კომპილაციით

ბმულები პროექტის ფაილებთან

კონფიგურაციების მაგია

ახალი კომენტარის დამატება პასუხის გასაუქმებლად

ახალი კომენტარის დამატება