Revit/AutoCAD-ന്റെ വ്യത്യസ്ത പതിപ്പുകൾക്കായി ഞങ്ങൾ ഒരു പ്ലഗിൻ പ്രോജക്റ്റ് ഉണ്ടാക്കുന്നു

CAD ആപ്ലിക്കേഷനുകൾക്കായി പ്ലഗിനുകൾ വികസിപ്പിക്കുമ്പോൾ (എന്റെ കാര്യത്തിൽ ഇവയാണ് AutoCAD, Revit, Renga) കാലക്രമേണ, ഒരു പ്രശ്നം പ്രത്യക്ഷപ്പെടുന്നു - പ്രോഗ്രാമുകളുടെ പുതിയ പതിപ്പുകൾ പുറത്തിറങ്ങി, അവയുടെ API മാറ്റങ്ങളും പ്ലഗിന്നുകളുടെ പുതിയ പതിപ്പുകളും നിർമ്മിക്കേണ്ടതുണ്ട്.

നിങ്ങൾക്ക് ഒരു പ്ലഗിൻ മാത്രമുള്ളപ്പോൾ അല്ലെങ്കിൽ നിങ്ങൾ ഇപ്പോഴും ഈ വിഷയത്തിൽ സ്വയം പഠിപ്പിച്ച തുടക്കക്കാരനാണെങ്കിൽ, നിങ്ങൾക്ക് പ്രോജക്റ്റിന്റെ ഒരു പകർപ്പ് ഉണ്ടാക്കാനും അതിൽ ആവശ്യമായ സ്ഥലങ്ങൾ മാറ്റാനും പ്ലഗിന്റെ പുതിയ പതിപ്പ് കൂട്ടിച്ചേർക്കാനും കഴിയും. അതനുസരിച്ച്, കോഡിലെ തുടർന്നുള്ള മാറ്റങ്ങൾ തൊഴിൽ ചെലവിൽ ഒന്നിലധികം വർദ്ധനവിന് കാരണമാകും.

നിങ്ങൾ അനുഭവവും അറിവും നേടുമ്പോൾ, ഈ പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള നിരവധി മാർഗങ്ങൾ നിങ്ങൾ കണ്ടെത്തും. ഞാൻ ഈ പാതയിലൂടെ നടന്നു, ഞാൻ എന്താണ് അവസാനിപ്പിച്ചതെന്നും അത് എത്ര സൗകര്യപ്രദമാണെന്നും നിങ്ങളോട് പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

ആദ്യം, വ്യക്തവും ഞാൻ വളരെക്കാലമായി ഉപയോഗിക്കുന്നതുമായ ഒരു രീതി നോക്കാം.

പ്രോജക്റ്റ് ഫയലുകളിലേക്കുള്ള ലിങ്കുകൾ

എല്ലാം ലളിതവും ദൃശ്യവും മനസ്സിലാക്കാവുന്നതും ആക്കുന്നതിന്, പ്ലഗിൻ വികസനത്തിന്റെ ഒരു അമൂർത്ത ഉദാഹരണം ഉപയോഗിച്ച് ഞാൻ എല്ലാം വിവരിക്കും.

നമുക്ക് വിഷ്വൽ സ്റ്റുഡിയോ തുറക്കാം (എനിക്ക് കമ്മ്യൂണിറ്റി 2019 പതിപ്പുണ്ട്. അതെ - റഷ്യൻ ഭാഷയിൽ) ഒരു പുതിയ പരിഹാരം സൃഷ്ടിക്കുക. നമുക്ക് അവനെ വിളിക്കാം MySuperPluginForRevit

2015-2020 പതിപ്പുകൾക്കായി ഞങ്ങൾ റിവിറ്റിനായി ഒരു പ്ലഗിൻ നിർമ്മിക്കും. അതിനാൽ, പരിഹാരത്തിൽ (നെറ്റ് ഫ്രെയിംവർക്ക് ക്ലാസ് ലൈബ്രറി) ഒരു പുതിയ പ്രോജക്റ്റ് സൃഷ്ടിച്ച് അതിനെ വിളിക്കാം 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-യിൽ നിന്ന് ഞങ്ങളുടെ പ്ലഗിൻ എന്തെങ്കിലും ഉപയോഗിക്കുമെന്ന് നമുക്ക് സങ്കൽപ്പിക്കാം. ശരി, അല്ലെങ്കിൽ ഞങ്ങൾ പ്ലഗിൻ നിർമ്മിക്കുന്ന റിവിറ്റിന്റെ പതിപ്പിനെ ആശ്രയിച്ച് കോഡിൽ എന്തെങ്കിലും മാറ്റേണ്ടതുണ്ട്. കോഡിലെ അത്തരം വ്യത്യാസങ്ങൾ പരിഹരിക്കുന്നതിന്, ഞങ്ങൾ സോപാധിക സമാഹാര ചിഹ്നങ്ങൾ ഉപയോഗിക്കും. പ്രോജക്റ്റ് പ്രോപ്പർട്ടികൾ തുറക്കുക, "ടാബിലേക്ക് പോകുകനിയമസഭ"ഒപ്പം വയലിൽ"സോപാധിക സമാഹാര നൊട്ടേഷൻ"നമുക്ക് എഴുതാം R2015.

ഡീബഗ്, റിലീസ് കോൺഫിഗറേഷനുകൾക്കായി ചിഹ്നം ചേർക്കേണ്ടതുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക.

ശരി, ഞങ്ങൾ പ്രോപ്പർട്ടി വിൻഡോയിലായിരിക്കുമ്പോൾ, ഞങ്ങൾ ഉടൻ തന്നെ "ടാബിലേക്ക് പോകുന്നുഅപേക്ഷ"ഒപ്പം വയലിൽ"ഡിഫോൾട്ട് നെയിംസ്പേസ്» സഫിക്സ് നീക്കം ചെയ്യുക _2015അങ്ങനെ നമ്മുടെ നെയിംസ്പേസ് സാർവത്രികവും അസംബ്ലി നാമത്തിൽ നിന്ന് സ്വതന്ത്രവുമാണ്:

എന്റെ കാര്യത്തിൽ, അന്തിമ ഉൽപ്പന്നത്തിൽ, എല്ലാ പതിപ്പുകളുടെയും പ്ലഗിനുകൾ ഒരു ഫോൾഡറിൽ ഇടുന്നു, അതിനാൽ എന്റെ അസംബ്ലി പേരുകൾ ഫോമിന്റെ പ്രത്യയത്തിൽ തന്നെ നിലനിൽക്കും _20xx. എന്നാൽ ഫയലുകൾ വ്യത്യസ്ത ഫോൾഡറുകളിൽ സ്ഥിതി ചെയ്യുന്നെങ്കിൽ, അസംബ്ലി നാമത്തിൽ നിന്ന് സഫിക്സ് നീക്കം ചെയ്യാനും നിങ്ങൾക്ക് കഴിയും.

നമുക്ക് ഫയൽ കോഡിലേക്ക് പോകാം 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;
        }
    }
}

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 തുടർന്ന് പരിഹാരത്തിൽ നിന്ന് പദ്ധതി നീക്കം ചെയ്യുക. പെർഫെക്ഷനിസ്റ്റുകളുടെ ക്രമവും വികാരങ്ങളും നിലനിർത്താൻ ഇത് ആവശ്യമാണ്! ഞങ്ങൾ ഞങ്ങളുടെ സൊല്യൂഷന്റെ ഫോൾഡർ തുറന്ന്, പ്രോജക്റ്റ് ഫോൾഡറിന്റെ പേര് അതേ രീതിയിൽ പുനർനാമകരണം ചെയ്യുകയും പ്രോജക്റ്റ് സൊല്യൂഷനിലേക്ക് തിരികെ ലോഡുചെയ്യുകയും ചെയ്യുന്നു.

കോൺഫിഗറേഷൻ മാനേജർ തുറക്കുക. യുഎസ് കോൺഫിഗറേഷൻ റിലീസ് തത്വത്തിൽ, അത് ആവശ്യമില്ല, അതിനാൽ ഞങ്ങൾ അത് ഇല്ലാതാക്കുന്നു. ഞങ്ങൾക്ക് ഇതിനകം പരിചിതമായ പേരുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ പുതിയ കോൺഫിഗറേഷനുകൾ സൃഷ്ടിക്കുന്നു R2015, R2016,…, R2020. മറ്റ് കോൺഫിഗറേഷനുകളിൽ നിന്ന് നിങ്ങൾ ക്രമീകരണങ്ങൾ പകർത്തേണ്ടതില്ല എന്നതും പ്രോജക്റ്റ് കോൺഫിഗറേഷനുകൾ സൃഷ്ടിക്കേണ്ട ആവശ്യമില്ലെന്നതും ശ്രദ്ധിക്കുക:

പ്രോജക്റ്റ് ഉള്ള ഫോൾഡറിലേക്ക് പോയി നിങ്ങൾക്ക് സൗകര്യപ്രദമായ ഒരു എഡിറ്ററിൽ .csproj എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് ഫയൽ തുറക്കുക. വഴിയിൽ, നിങ്ങൾക്ക് ഇത് വിഷ്വൽ സ്റ്റുഡിയോയിലും തുറക്കാൻ കഴിയും - നിങ്ങൾ പ്രോജക്റ്റ് അൺലോഡ് ചെയ്യേണ്ടതുണ്ട്, തുടർന്ന് ആവശ്യമുള്ള ഇനം സന്ദർഭ മെനുവിൽ ആയിരിക്കും:

വിഷ്വൽ സ്റ്റുഡിയോയിലെ എഡിറ്റിംഗ് കൂടുതൽ അഭികാമ്യമാണ്, കാരണം എഡിറ്റർ വിന്യസിക്കുകയും ആവശ്യപ്പെടുകയും ചെയ്യുന്നു.

ഫയലിൽ നമ്മൾ ഘടകങ്ങൾ കാണും പ്രോപ്പർട്ടി ഗ്രൂപ്പ് - ഏറ്റവും മുകളിൽ പൊതുവായതാണ്, തുടർന്ന് വ്യവസ്ഥകൾ വരുന്നു. ഈ ഘടകങ്ങൾ പ്രോജക്റ്റ് നിർമ്മിക്കുമ്പോൾ അതിന്റെ ഗുണങ്ങളെ സജ്ജമാക്കുന്നു. വ്യവസ്ഥകളില്ലാത്ത ആദ്യ ഘടകം, പൊതുവായ ഗുണവിശേഷതകൾ സജ്ജമാക്കുന്നു, വ്യവസ്ഥകളുള്ള ഘടകങ്ങൾ, അതനുസരിച്ച്, കോൺഫിഗറേഷനുകളെ ആശ്രയിച്ച് ചില ഗുണങ്ങൾ മാറ്റുന്നു.

പൊതുവായ (ആദ്യത്തെ) ഘടകത്തിലേക്ക് പോകുക പ്രോപ്പർട്ടി ഗ്രൂപ്പ് വസ്തുവകകൾ നോക്കുക അസംബ്ലിയുടെ പേര് - ഇതാണ് അസംബ്ലിയുടെ പേര്, നമുക്ക് ഇത് ഒരു പ്രത്യയവുമില്ലാതെ ഉണ്ടായിരിക്കണം _2015. ഒരു പ്രത്യയം ഉണ്ടെങ്കിൽ, അത് നീക്കം ചെയ്യുക.

ഒരു വ്യവസ്ഥയുള്ള ഒരു ഘടകം കണ്ടെത്തുന്നു

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

ഞങ്ങൾക്ക് ഇത് ആവശ്യമില്ല - ഞങ്ങൾ അത് ഇല്ലാതാക്കുന്നു.

വ്യവസ്ഥയോടുകൂടിയ ഘടകം

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

കോഡ് വികസനത്തിന്റെയും ഡീബഗ്ഗിംഗിന്റെയും ഘട്ടത്തിൽ പ്രവർത്തിക്കാൻ ആവശ്യമായി വരും. നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുസൃതമായി നിങ്ങൾക്ക് അതിന്റെ പ്രോപ്പർട്ടികൾ മാറ്റാൻ കഴിയും - വ്യത്യസ്ത ഔട്ട്പുട്ട് പാതകൾ സജ്ജമാക്കുക, സോപാധിക സമാഹാര ചിഹ്നങ്ങൾ മാറ്റുക തുടങ്ങിയവ.

ഇനി നമുക്ക് പുതിയ ഘടകങ്ങൾ ഉണ്ടാക്കാം പ്രോപ്പർട്ടി ഗ്രൂപ്പ് ഞങ്ങളുടെ കോൺഫിഗറേഷനുകൾക്കായി. ഈ ഘടകങ്ങളിൽ നമുക്ക് നാല് പ്രോപ്പർട്ടികൾ സജ്ജീകരിക്കേണ്ടതുണ്ട്:

• ഔട്ട്പുട്ട്പാത്ത് - ഔട്ട്പുട്ട് ഫോൾഡർ. ഞാൻ സ്ഥിര മൂല്യം സജ്ജമാക്കി binR20xx
• കോൺസ്റ്റന്റുകൾ നിർവചിക്കുക - സോപാധിക സമാഹാര ചിഹ്നങ്ങൾ. മൂല്യം വ്യക്തമാക്കണം TRACE;R20xx
• ടാർഗെറ്റ് ഫ്രെയിംവർക്ക് പതിപ്പ് - പ്ലാറ്റ്ഫോം പതിപ്പ്. Revit API-യുടെ വ്യത്യസ്ത പതിപ്പുകൾക്ക് വ്യത്യസ്ത പ്ലാറ്റ്‌ഫോമുകൾ വ്യക്തമാക്കേണ്ടതുണ്ട്.
• അസംബ്ലിയുടെ പേര് - അസംബ്ലി നാമം (അതായത് ഫയലിന്റെ പേര്). നിങ്ങൾക്ക് അസംബ്ലിയുടെ കൃത്യമായ പേര് എഴുതാം, പക്ഷേ ബഹുമുഖതയ്ക്കായി ഞാൻ മൂല്യം എഴുതാൻ ശുപാർശ ചെയ്യുന്നു $(AssemblyName)_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 പാക്കേജുകളും പുനഃസ്ഥാപിക്കുക"ഞങ്ങളുടെ പാക്കേജുകൾ എങ്ങനെ മാറുന്നുവെന്ന് ഞങ്ങൾ കാണുന്നു.

ഈ ഘട്ടത്തിൽ ഞാൻ ഒരു അവസാനഘട്ടത്തിലെത്തി - എല്ലാ കോൺഫിഗറേഷനുകളും ഒരേസമയം ശേഖരിക്കുന്നതിന്, ഞങ്ങൾക്ക് ബാച്ച് അസംബ്ലി ഉപയോഗിക്കാം (മെനു "നിയമസഭ»->«ബാച്ച് ബിൽഡ്"), എന്നാൽ കോൺഫിഗറേഷനുകൾ മാറുമ്പോൾ, പാക്കേജുകൾ സ്വയമേവ പുനഃസ്ഥാപിക്കില്ല. പ്രോജക്റ്റ് കൂട്ടിച്ചേർക്കുമ്പോൾ, ഇതും സംഭവിക്കുന്നില്ല, എന്നിരുന്നാലും, സിദ്ധാന്തത്തിൽ, അത് ചെയ്യണം. സ്റ്റാൻഡേർഡ് മാർഗങ്ങൾ ഉപയോഗിച്ച് ഈ പ്രശ്നത്തിന് ഞാൻ ഒരു പരിഹാരം കണ്ടെത്തിയില്ല. മിക്കവാറും ഇതൊരു വിഷ്വൽ സ്റ്റുഡിയോ ബഗ് കൂടിയാണ്.

അതിനാൽ, ബാച്ച് അസംബ്ലിക്ക്, ഒരു പ്രത്യേക ഓട്ടോമേറ്റഡ് അസംബ്ലി സിസ്റ്റം ഉപയോഗിക്കാൻ തീരുമാനിച്ചു ന്യൂക്ക്. പ്ലഗിൻ വികസനത്തിന്റെ കാര്യത്തിൽ ഇത് ഓവർകിൽ ആണെന്ന് ഞാൻ കരുതുന്നതിനാൽ എനിക്ക് ഇത് ശരിക്കും ആവശ്യമില്ല, എന്നാൽ ഇപ്പോൾ മറ്റൊരു പരിഹാരവും ഞാൻ കാണുന്നില്ല. “എന്തുകൊണ്ട് ആണവായുധം?” എന്ന ചോദ്യത്തിനും ഉത്തരം ലളിതമാണ് - ഞങ്ങൾ ഇത് ജോലിയിൽ ഉപയോഗിക്കുന്നു.

അതിനാൽ, ഞങ്ങളുടെ പരിഹാരത്തിന്റെ ഫോൾഡറിലേക്ക് പോകുക (പ്രോജക്റ്റ് അല്ല), കീ അമർത്തിപ്പിടിക്കുക മാറ്റം ഫോൾഡറിലെ ശൂന്യമായ സ്ഥലത്ത് വലത്-ക്ലിക്കുചെയ്യുക - സന്ദർഭ മെനുവിൽ ഇനം തിരഞ്ഞെടുക്കുക "ഇവിടെ PowerShell വിൻഡോ തുറക്കുക".

നിങ്ങൾ ഇത് ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിൽ ആണവ, എന്നിട്ട് ആദ്യം കമാൻഡ് എഴുതുക

dotnet tool install Nuke.GlobalTool –global

ഇപ്പോൾ കമാൻഡ് എഴുതുക ആണവ കോൺഫിഗർ ചെയ്യാൻ നിങ്ങളോട് ആവശ്യപ്പെടും ആണവ നിലവിലെ പദ്ധതിക്കായി. റഷ്യൻ ഭാഷയിൽ ഇത് എങ്ങനെ കൂടുതൽ ശരിയായി എഴുതണമെന്ന് എനിക്കറിയില്ല - ഇംഗ്ലീഷിൽ ഇത് എഴുതപ്പെടും Could not find .nuke file. നിങ്ങൾക്ക് ഒരു ബിൽഡ് സജ്ജീകരിക്കണോ? [y/n]

Y കീ അമർത്തുക, തുടർന്ന് നേരിട്ടുള്ള ക്രമീകരണ ഇനങ്ങൾ ഉണ്ടാകും. ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ ഓപ്ഷൻ ഞങ്ങൾക്ക് ആവശ്യമാണ് എംഎസ്ബിൽഡ്, അതിനാൽ ഞങ്ങൾ സ്ക്രീൻഷോട്ടിലെന്നപോലെ ഉത്തരം നൽകുന്നു:

നമുക്ക് വിഷ്വൽ സ്റ്റുഡിയോയിലേക്ക് പോകാം, അതിലേക്ക് ഒരു പുതിയ പ്രോജക്റ്റ് ചേർത്തതിനാൽ, പരിഹാരം വീണ്ടും ലോഡുചെയ്യാൻ അത് ഞങ്ങളെ പ്രേരിപ്പിക്കും. ഞങ്ങൾ പരിഹാരം വീണ്ടും ലോഡുചെയ്ത് ഞങ്ങൾക്ക് ഒരു പ്രോജക്റ്റ് ഉണ്ടെന്ന് കാണുന്നു പണിയുക ഒരു ഫയലിൽ മാത്രമേ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ളൂ - 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 വിൻഡോയിലേക്ക് മടങ്ങുകയും വീണ്ടും കമാൻഡ് എഴുതുകയും ചെയ്യുന്നു ആണവ (നിങ്ങൾക്ക് കമാൻഡ് എഴുതാം ആണവ ആവശ്യമുള്ളത് സൂചിപ്പിക്കുന്നു ടാർഗെറ്റ്. പക്ഷെ നമുക്ക് ഒന്നുണ്ട് ടാർഗെറ്റ്, ഇത് സ്ഥിരസ്ഥിതിയായി പ്രവർത്തിക്കുന്നു). എന്റർ കീ അമർത്തിയാൽ, ഞങ്ങൾക്ക് യഥാർത്ഥ ഹാക്കർമാരെപ്പോലെ തോന്നും, കാരണം, ഒരു സിനിമയിലെന്നപോലെ, വ്യത്യസ്ത കോൺഫിഗറേഷനുകൾക്കായി ഞങ്ങളുടെ പ്രോജക്റ്റ് സ്വയമേവ കൂട്ടിച്ചേർക്കപ്പെടും.

വഴിയിൽ, നിങ്ങൾക്ക് വിഷ്വൽ സ്റ്റുഡിയോയിൽ നിന്ന് നേരിട്ട് PowerShell ഉപയോഗിക്കാം (മെനു "കാഴ്ച»->«മറ്റ് വിൻഡോകൾ»->«പാക്കേജ് മാനേജർ കൺസോൾ"), എന്നാൽ എല്ലാം കറുപ്പും വെളുപ്പും ആയിരിക്കും, അത് വളരെ സൗകര്യപ്രദമല്ല.

ഇത് എന്റെ ലേഖനം അവസാനിപ്പിക്കുന്നു. AutoCAD-നുള്ള ഓപ്ഷൻ നിങ്ങൾക്ക് സ്വയം കണ്ടെത്താനാകുമെന്ന് എനിക്ക് ഉറപ്പുണ്ട്. ഇവിടെ അവതരിപ്പിച്ച മെറ്റീരിയൽ അതിന്റെ "ക്ലയന്റുകളെ" കണ്ടെത്തുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

Спасибо!

അവലംബം: www.habr.com