אנו מייצרים פרויקט תוסף אחד עם קומפילציה עבור גרסאות שונות של Revit/AutoCAD

בעת פיתוח תוספים עבור יישומי CAD (במקרה שלי אלה הם AutoCAD, Revit ו-Renga) עם הזמן, מופיעה בעיה אחת - גרסאות חדשות של תוכניות משוחררות, יש לבצע שינויים ב-API שלהן וגרסאות חדשות של תוספים.

כאשר יש לך רק תוסף אחד או שאתה עדיין אוטודידקט מתחיל בעניין הזה, אתה יכול פשוט ליצור עותק של הפרוייקט, לשנות את המקומות הדרושים בו ולהרכיב גרסה חדשה של התוסף. בהתאם לכך, שינויים הבאים בקוד יגררו עלייה מרובה בעלויות העבודה.

ככל שתצבור ניסיון וידע, תמצא מספר דרכים להפוך את התהליך הזה לאוטומטי. הלכתי בנתיב הזה ואני רוצה לספר לכם במה הגעתי וכמה זה נוח.

ראשית, בואו נסתכל על שיטה ברורה ושאני השתמשתי בה כבר הרבה זמן.

קישורים לקבצי פרויקט

וכדי שהכל יהיה פשוט, ויזואלי ומובן, אתאר הכל באמצעות דוגמה מופשטת של פיתוח תוספים.

בואו נפתח את Visual Studio (יש לי את גרסת הקהילה 2019. וכן - ברוסית) וניצור פתרון חדש. בואו נתקשר אליו MySuperPluginForRevit

אנו ניצור תוסף עבור Revit עבור גרסאות 2015-2020. לכן, בואו ניצור פרויקט חדש בפתרון (Net Framework Class Library) ונקרא לו MySuperPluginForRevit_2015

אנחנו צריכים להוסיף קישורים ל-Revit API. כמובן שנוכל להוסיף קישורים לקבצים מקומיים (נצטרך להתקין את כל ה-SDKs הנחוצים או את כל הגרסאות של 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>

כעת, בעת בניית פרויקט, קבצים מהחבילה לא יועתקו לתיקיית הפלט.
בואו נלך רחוק יותר – בואו מיד נדמיין שהתוסף שלנו ישתמש במשהו מה-API של Revit, שהשתנה עם הזמן כאשר גרסאות חדשות יצאו לאור. ובכן, או שאנחנו פשוט צריכים לשנות משהו בקוד בהתאם לגרסה של Revit שעבורה אנחנו מייצרים את התוסף. כדי לפתור הבדלים כאלה בקוד, נשתמש בסמלי קומפילציה מותנים. פתח את מאפייני הפרויקט, עבור ללשונית "העצרת"ובשטח"סימון אוסף מותנה"בוא נכתוב R2015.

שים לב שיש להוסיף את הסמל עבור תצורות Debug ו-Release.

ובכן, בזמן שאנחנו בחלון המאפיינים, אנחנו מיד עוברים ללשונית "יישום"ובשטח"מרחב שמות ברירת מחדל» להסיר את הסיומת _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 - כבר יש לנו את זה ואנחנו רק צריכים להוסיף קישור אליו בפרויקט חדש. ישנן שתי דרכים להכנסת קישורים:

1. ארוך - לחץ לחיצה ימנית על הפרויקט ובחר "להוסיף»->«אלמנט קיים", בחלון שנפתח, מצא את הקובץ הרצוי ובמקום האפשרות "להוסיף"בחר את האפשרות"הוסף כחיבור»

1. קצר – ישירות בסייר הפתרונות, בחר את הקובץ הרצוי (או אפילו קבצים, או אפילו תיקיות שלמות) וגרור אותו לפרויקט חדש תוך לחיצה ממושכת על מקש Alt. תוך כדי גרירה, תראה שכאשר תלחץ על מקש Alt, סמן העכבר ישתנה מסימן פלוס לחץ.
   UPD: עשיתי קצת בלבול בפסקה זו - כדי להעביר מספר קבצים עליך להחזיק מעמד Shift + Alt!

לאחר ביצוע ההליך, יהיה לנו תיק בפרויקט השני Class1.cs עם הסמל המתאים (חץ כחול):

בעת עריכת קוד בחלון העורך, תוכל גם לבחור באיזה הקשר של הפרויקט להציג את הקוד, מה שיאפשר לך לראות את הקוד נערוך תחת סמלי קומפילציה מותנים שונים:

אנו יוצרים את כל הפרויקטים האחרים (2017-2020) באמצעות תוכנית זו. פריצת חיים - אם אתה גורר קבצים בסייר הפתרונות לא מהפרויקט הבסיסי, אלא מהפרויקט שבו הם כבר הוכנסו כקישור, אז אתה לא צריך להחזיק את מקש Alt!

האפשרות המתוארת די טובה עד לרגע הוספת גרסה חדשה של התוסף או עד לרגע הוספת קבצים חדשים לפרויקט - כל זה הופך להיות מייגע מאוד. ולאחרונה פתאום פתאום הבנתי איך לסדר את הכל בפרויקט אחד ואנחנו עוברים לשיטה השנייה

הקסם של תצורות

לאחר שסיימת לקרוא כאן, אתה עשוי לצעוק, "מדוע תיארת את השיטה הראשונה, אם המאמר הוא מיד על השני?!" ותארתי הכל כדי להבהיר למה אנחנו צריכים סמלי קומפילציה מותנים ובאילו מקומות שונים הפרויקטים שלנו. ועכשיו מתברר לנו בדיוק אילו הבדלים בפרויקטים אנחנו צריכים ליישם, ונשאר רק פרויקט אחד.

וכדי שהכל יהיה ברור יותר, לא ניצור פרויקט חדש, אלא נעשה שינויים בפרויקט הנוכחי שלנו שנוצר בדרך הראשונה.

אז, קודם כל, אנו מסירים את כל הפרויקטים מהפתרון מלבד הראשי (המכיל את הקבצים ישירות). הָהֵן. פרויקטים לגרסאות 2016-2020. פתח את התיקיה עם הפתרון ומחק שם את התיקיות של הפרויקטים הללו.

נותר לנו פרויקט אחד בהחלטה שלנו - MySuperPluginForRevit_2015. פתח את המאפיינים שלו ו:

1. בכרטיסייה "יישום"הסר את הסיומת משם האסיפה _2015 (יתברר למה בהמשך)
2. בכרטיסייה "העצרת» הסר את סמל ההידור המותנה R2015 מהשדה המתאים

הערה: בגרסה האחרונה של Visual Studio יש באג - סמלי קומפילציה מותנים אינם מוצגים בחלון מאפייני הפרויקט, למרות שהם זמינים. אם אתה חווה תקלה זו, עליך להסיר אותם באופן ידני מקובץ ה-.csproj. עם זאת, אנחנו עדיין צריכים לעבוד בו, אז המשך לקרוא.

שנה את שם הפרויקט בחלון סייר הפתרונות על ידי הסרת הסיומת _2015 ולאחר מכן הסר את הפרויקט מהפתרון. זה הכרחי כדי לשמור על סדר ורגשות של פרפקציוניסטים! פתח את התיקיה של הפתרון שלנו, שנה את שם תיקיית הפרויקט שם באותו אופן וטען את הפרויקט בחזרה לפתרון.

פתח את מנהל התצורה. תצורה בארה"ב לשחרר באופן עקרוני, לא יהיה צורך בו, אז אנו מוחקים אותו. אנו יוצרים תצורות חדשות עם שמות שכבר מוכרים לנו R2015, R2016, ..., R2020. שים לב שאינך צריך להעתיק הגדרות מתצורות אחרות ואין צורך ליצור תצורות פרויקט:

כנסו לתיקיה עם הפרוייקט ופתחו את הקובץ עם סיומת .csproj בעורך שנוח לכם. אגב, אתה יכול לפתוח אותו גם ב-Visual Studio - אתה צריך לפרוק את הפרויקט ואז הפריט הרצוי יהיה בתפריט ההקשר:

עריכה ב-Visual Studio אפילו עדיפה, מכיוון שהעורך גם מיישר וגם מבקש.

בקובץ נראה את האלמנטים קבוצת נכסים - בחלק העליון הוא הכללי, ואז באים התנאים. אלמנטים אלה קובעים את המאפיינים של הפרויקט כאשר הוא נבנה. האלמנט הראשון, שהוא ללא תנאים, קובע מאפיינים כלליים, ואלמנטים עם תנאים, בהתאם, משנים כמה מאפיינים בהתאם לתצורות.

עבור אל האלמנט המשותף (הראשון). קבוצת נכסים ולהסתכל על הנכס הרכבה שם – זהו שם האסיפה וצריך לקבל אותה ללא סיומת _2015. אם יש סיומת, אז הסר אותה.

מציאת אלמנט עם תנאי

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

אנחנו לא צריכים את זה - אנחנו מוחקים את זה.

אלמנט עם מצב

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

יהיה צורך לעבוד בשלב של פיתוח קוד ואיתור באגים. אתה יכול לשנות את המאפיינים שלו כדי להתאים לצרכים שלך - להגדיר נתיבי פלט שונים, לשנות סמלי קומפילציה מותנים וכו'.

עכשיו בואו ניצור אלמנטים חדשים קבוצת נכסים עבור התצורות שלנו. באלמנטים האלה אנחנו רק צריכים להגדיר ארבעה מאפיינים:

• OutputPath - תיקיית פלט. הגדרתי את ערך ברירת המחדל binR20xx
• הגדר קבועים – סמלי קומפילציה מותנים. יש לציין את הערך TRACE;R20хх
• TargetFrameworkVersion - גרסת פלטפורמה. גרסאות שונות של Revit API דורשות לציין פלטפורמות שונות.
• הרכבה שם - שם הרכבה (כלומר שם הקובץ). אתה יכול לכתוב את השם המדויק של המכלול, אבל בשביל הרבגוניות אני ממליץ לכתוב את הערך $(AssemblyName)_20хх. לשם כך, הסרנו בעבר את הסיומת משם המכלול

המאפיין החשוב ביותר של כל האלמנטים הללו הוא שניתן פשוט להעתיק אותם לפרויקטים אחרים מבלי לשנות אותם כלל. בהמשך המאמר אצרף את כל התוכן של קובץ ה-.csproj.

אוקיי, הבנו את המאפיינים של הפרויקט - זה לא קשה. אבל מה לעשות עם ספריות פלאגין (חבילות NuGet). אם נסתכל עוד יותר, נראה שהספריות הנכללות מצוינות באלמנטים קבוצת פריטים. אבל מזל רע - אלמנט זה מעבד בצורה לא נכונה את התנאים כאלמנט קבוצת נכסים. אולי זו אפילו תקלה של 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>

שימו לב שבאחד התנאים ציינתי שתי תצורות באמצעות אוֹ. בדרך זו החבילה הנדרשת תחובר במהלך ההגדרה לנפות.

וכאן יש לנו כמעט הכל מושלם. אנו טוענים את הפרויקט בחזרה, מאפשרים את התצורה שאנו צריכים, קוראים לפריט "בתפריט ההקשר של הפתרון (לא הפרויקט)שחזר את כל חבילות NuGet"ואנחנו רואים איך החבילות שלנו משתנות.

ובשלב הזה הגעתי למבוי סתום - כדי לאסוף את כל התצורות בבת אחת, נוכל להשתמש בהרכבת אצווה (תפריט "העצרת»->«בניית אצווה"), אך בעת החלפת תצורות, החבילות אינן משוחזרות אוטומטית. וכאשר מרכיבים את הפרויקט, זה גם לא קורה, אם כי, בתיאוריה, זה צריך להיות. לא מצאתי פתרון לבעיה הזו באמצעים סטנדרטיים. וסביר להניח שזה גם באג של Visual Studio.

לכן, עבור הרכבה אצווה, הוחלט להשתמש במערכת הרכבה אוטומטית מיוחדת Nuke. למעשה לא רציתי את זה כי אני חושב שזה מוגזם מבחינת פיתוח תוספים, אבל כרגע אני לא רואה שום פתרון אחר. ולשאלה "למה Nuke?" התשובה פשוטה - אנחנו משתמשים בה בעבודה.

אז, עבור אל התיקיה של הפתרון שלנו (לא הפרויקט), החזק את המקש משמרת ולחץ לחיצה ימנית על מקום ריק בתיקייה - בתפריט ההקשר בחר את הפריט "פתח את חלון PowerShell כאן".

אם זה לא מותקן אצלך Nuke, ואז תחילה כתוב את הפקודה

dotnet tool install Nuke.GlobalTool –global

כעת כתוב את הפקודה Nuke ותתבקש להגדיר Nuke עבור הפרויקט הנוכחי. אני לא יודע איך לכתוב את זה בצורה יותר נכונה ברוסית - באנגלית זה ייכתב לא ניתן למצוא קובץ .nuke. האם אתה רוצה להגדיר build? [י/נ]

הקש על מקש 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 ונכתוב שוב את הפקודה Nuke (אתה יכול לכתוב את הפקודה Nuke מציין את הנדרש יעד. אבל יש לנו אחד יעד, שפועל כברירת מחדל). לאחר לחיצה על מקש Enter, נרגיש כמו האקרים אמיתיים, מכיוון שכמו בסרט, הפרויקט שלנו יורכב אוטומטית לתצורות שונות.

אגב, אתה יכול להשתמש ב-PowerShell ישירות מ-Visual Studio (תפריט "לצפות»->«חלונות אחרים»->«קונסולת מנהל החבילות"), אבל הכל יהיה בשחור לבן, וזה לא מאוד נוח.

זה מסיים את המאמר שלי. אני בטוח שאתה יכול להבין את האפשרות של AutoCAD בעצמך. אני מקווה שהחומר המוצג כאן ימצא את "לקוחותיו".

תודה לך!

מקור: www.habr.com