અમે Revit/AutoCAD ના વિવિધ સંસ્કરણો માટે સંકલન સાથે એક પ્લગઇન પ્રોજેક્ટ બનાવીએ છીએ

CAD એપ્લીકેશન માટે પ્લગઈનો વિકસાવતી વખતે (મારા કિસ્સામાં આ AutoCAD, Revit અને Renga છે) સમય જતાં, એક સમસ્યા દેખાય છે - પ્રોગ્રામના નવા સંસ્કરણો બહાર પાડવામાં આવે છે, તેમના API ફેરફારો અને પ્લગિન્સના નવા સંસ્કરણો બનાવવાની જરૂર છે.

જ્યારે તમારી પાસે ફક્ત એક જ પ્લગઇન હોય અથવા તમે હજી પણ આ બાબતમાં સ્વ-શિક્ષિત શિખાઉ છો, તો તમે ફક્ત પ્રોજેક્ટની નકલ બનાવી શકો છો, તેમાં જરૂરી સ્થાનો બદલી શકો છો અને પ્લગઇનનું નવું સંસ્કરણ એસેમ્બલ કરી શકો છો. તદનુસાર, કોડમાં અનુગામી ફેરફારો મજૂર ખર્ચમાં બહુવિધ વધારો કરશે.

જેમ જેમ તમે અનુભવ અને જ્ઞાન મેળવશો તેમ, તમને આ પ્રક્રિયાને સ્વચાલિત કરવાની ઘણી રીતો મળશે. હું આ માર્ગ પર ચાલ્યો છું અને હું તમને કહેવા માંગુ છું કે મારી સાથે શું થયું અને તે કેટલું અનુકૂળ છે.

પ્રથમ, ચાલો એક પદ્ધતિ જોઈએ જે સ્પષ્ટ છે અને જેનો મેં લાંબા સમયથી ઉપયોગ કર્યો છે.

પ્રોજેક્ટ ફાઇલોની લિંક્સ

અને બધું સરળ, વિઝ્યુઅલ અને સમજી શકાય તેવું બનાવવા માટે, હું પ્લગઇન ડેવલપમેન્ટના અમૂર્ત ઉદાહરણનો ઉપયોગ કરીને દરેક વસ્તુનું વર્ણન કરીશ.

ચાલો વિઝ્યુઅલ સ્ટુડિયો ખોલીએ (મારી પાસે કોમ્યુનિટી 2019 વર્ઝન છે. અને હા - રશિયનમાં) અને એક નવું સોલ્યુશન બનાવીએ. ચાલો તેને બોલાવીએ MySuperPluginForRevit

અમે વર્ઝન 2015-2020 માટે Revit માટે પ્લગઇન બનાવીશું. તેથી, ચાલો સોલ્યુશનમાં એક નવો પ્રોજેક્ટ બનાવીએ (નેટ ફ્રેમવર્ક ક્લાસ લાઇબ્રેરી) અને તેને કૉલ કરીએ 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>

હવે, પ્રોજેક્ટ બનાવતી વખતે, પેકેજમાંથી ફાઇલોને આઉટપુટ ફોલ્ડરમાં કૉપિ કરવામાં આવશે નહીં.
ચાલો આગળ જઈએ - ચાલો તરત જ કલ્પના કરીએ કે અમારું પ્લગઇન 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;
        }
    }
}

મેં તરત જ સંસ્કરણ 2015 (જે લખવાના સમયે ઉપલબ્ધ હતા) ઉપરના રેવિટના તમામ સંસ્કરણોને ધ્યાનમાં લીધા અને તરત જ શરતી સંકલન પ્રતીકોની હાજરીને ધ્યાનમાં લીધી, જે સમાન નમૂનાનો ઉપયોગ કરીને બનાવવામાં આવે છે.

ચાલો મુખ્ય હાઇલાઇટ પર આગળ વધીએ. અમે અમારા સોલ્યુશનમાં એક નવો પ્રોજેક્ટ બનાવીએ છીએ, ફક્ત Revit 2016 માટેના પ્લગઇનના વર્ઝન માટે. અમે ઉપર વર્ણવેલ તમામ પગલાંઓનું અનુક્રમે પુનરાવર્તન કરીએ છીએ, નંબર 2015 ને નંબર 2016 સાથે બદલીને. પરંતુ ફાઇલ Class1.cs નવા પ્રોજેક્ટમાંથી કાઢી નાખો.

જરૂરી કોડ સાથે ફાઇલ કરો - Class1.cs - અમારી પાસે તે પહેલાથી જ છે અને અમારે નવા પ્રોજેક્ટમાં તેની લિંક દાખલ કરવાની જરૂર છે. લિંક્સ દાખલ કરવાની બે રીત છે:

1. લાંબી - પ્રોજેક્ટ પર જમણું-ક્લિક કરો અને પસંદ કરો "ઉમેરો->હાલનું તત્વ", ખુલતી વિન્ડોમાં, વિકલ્પને બદલે જરૂરી ફાઇલ શોધો"ઉમેરો"વિકલ્પ પસંદ કરો"કનેક્શન તરીકે ઉમેરો»

1. ટૂંકા - સીધું જ સોલ્યુશન એક્સપ્લોરરમાં, ઇચ્છિત ફાઇલ (અથવા ફાઇલો અથવા તો આખા ફોલ્ડર્સ) પસંદ કરો અને Alt કી દબાવી રાખીને તેને નવા પ્રોજેક્ટમાં ખેંચો. જેમ જેમ તમે ખેંચો છો, તમે જોશો કે જ્યારે તમે 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;R20хх
• ટાર્ગેટફ્રેમવર્ક વર્ઝન - પ્લેટફોર્મ સંસ્કરણ. Revit API ના વિવિધ વર્ઝનને અલગ અલગ પ્લેટફોર્મનો ઉલ્લેખ કરવાની જરૂર છે.
• એસેમ્બલીનું નામ - એસેમ્બલીનું નામ (એટલે ​​​​કે ફાઇલનું નામ). તમે એસેમ્બલીનું ચોક્કસ નામ લખી શકો છો, પરંતુ વર્સેટિલિટી માટે હું મૂલ્ય લખવાની ભલામણ કરું છું $(એસેમ્બલી નામ)_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. હું વાસ્તવમાં આ ઇચ્છતો ન હતો કારણ કે મને લાગે છે કે તે પ્લગઇન ડેવલપમેન્ટના સંદર્ભમાં ઓવરકિલ છે, પરંતુ આ ક્ષણે મને અન્ય કોઈ ઉકેલ દેખાતો નથી. અને પ્રશ્ન "શા માટે ન્યુક?" જવાબ સરળ છે - અમે તેનો ઉપયોગ કામ પર કરીએ છીએ.

તેથી, અમારા સોલ્યુશનના ફોલ્ડર પર જાઓ (પ્રોજેક્ટ નહીં), કી દબાવી રાખો Shift અને ફોલ્ડરમાં ખાલી જગ્યા પર જમણું-ક્લિક કરો - સંદર્ભ મેનૂમાં આઇટમ પસંદ કરો “અહીં પાવરશેલ વિન્ડો ખોલો».

જો તમારી પાસે તે ઇન્સ્ટોલ કરેલ નથી nuke, પછી પ્રથમ આદેશ લખો

dotnet tool install Nuke.GlobalTool –global

હવે આદેશ લખો nuke અને તમને રૂપરેખાંકિત કરવા માટે પૂછવામાં આવશે nuke વર્તમાન પ્રોજેક્ટ માટે. મને ખબર નથી કે આને રશિયનમાં વધુ યોગ્ય રીતે કેવી રીતે લખવું - અંગ્રેજીમાં તે લખવામાં આવશે Could not find .nuke ફાઇલ. શું તમે બિલ્ડ સેટઅપ કરવા માંગો છો? [y/n]

Y કી દબાવો અને પછી ત્યાં સીધી સેટિંગ્સ વસ્તુઓ હશે. અમને સૌથી સરળ વિકલ્પનો ઉપયોગ કરવાની જરૂર છે MSB બિલ્ડ, તેથી અમે સ્ક્રીનશોટની જેમ જવાબ આપીએ છીએ:

ચાલો વિઝ્યુઅલ સ્ટુડિયો પર જઈએ, જે અમને સોલ્યુશન ફરીથી લોડ કરવા માટે સંકેત આપશે, કારણ કે તેમાં એક નવો પ્રોજેક્ટ ઉમેરવામાં આવ્યો છે. અમે સોલ્યુશન ફરીથી લોડ કરીએ છીએ અને જોઈએ છીએ કે અમારી પાસે એક પ્રોજેક્ટ છે બિલ્ડ કરો જેમાં અમને ફક્ત એક જ ફાઇલમાં રસ છે - 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 જરૂરી સૂચવે છે લક્ષ્યાંક. પરંતુ અમારી પાસે એક છે લક્ષ્યાંક, જે મૂળભૂત રીતે ચાલે છે). એન્ટર કી દબાવ્યા પછી, અમે વાસ્તવિક હેકર્સ જેવા અનુભવીશું, કારણ કે, મૂવીની જેમ, અમારો પ્રોજેક્ટ વિવિધ રૂપરેખાંકનો માટે આપમેળે એસેમ્બલ થઈ જશે.

માર્ગ દ્વારા, તમે પાવરશેલનો ઉપયોગ વિઝ્યુઅલ સ્ટુડિયોમાંથી સીધો કરી શકો છો (મેનુ "જુઓ->અન્ય વિન્ડો->પેકેજ મેનેજર કન્સોલ"), પરંતુ બધું કાળા અને સફેદ હશે, જે ખૂબ અનુકૂળ નથી.

આ મારા લેખને સમાપ્ત કરે છે. મને ખાતરી છે કે તમે AutoCAD માટેનો વિકલ્પ જાતે શોધી શકશો. હું આશા રાખું છું કે અહીં પ્રસ્તુત સામગ્રી તેના "ગ્રાહકો" શોધી શકશે.

તમારું ધ્યાન બદલ આભાર!

સોર્સ: www.habr.com