Revit/AutoCAD ನ ವಿವಿಧ ಆವೃತ್ತಿಗಳಿಗೆ ಸಂಕಲನದೊಂದಿಗೆ ನಾವು ಒಂದು ಪ್ಲಗಿನ್ ಯೋಜನೆಯನ್ನು ಮಾಡುತ್ತೇವೆ

CAD ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ (ನನ್ನ ವಿಷಯದಲ್ಲಿ ಇವು ಆಟೋಕ್ಯಾಡ್, ರೆವಿಟ್ ಮತ್ತು ರೆಂಗಾ) ಕಾಲಾನಂತರದಲ್ಲಿ, ಒಂದು ಸಮಸ್ಯೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ - ಕಾರ್ಯಕ್ರಮಗಳ ಹೊಸ ಆವೃತ್ತಿಗಳು ಬಿಡುಗಡೆಯಾಗುತ್ತವೆ, ಅವುಗಳ API ಬದಲಾವಣೆಗಳು ಮತ್ತು ಪ್ಲಗಿನ್‌ಗಳ ಹೊಸ ಆವೃತ್ತಿಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ.

ನೀವು ಕೇವಲ ಒಂದು ಪ್ಲಗಿನ್ ಅನ್ನು ಹೊಂದಿರುವಾಗ ಅಥವಾ ಈ ವಿಷಯದಲ್ಲಿ ನೀವು ಇನ್ನೂ ಸ್ವಯಂ-ಕಲಿಸಿದ ಹರಿಕಾರರಾಗಿರುವಾಗ, ನೀವು ಯೋಜನೆಯ ನಕಲನ್ನು ಸರಳವಾಗಿ ಮಾಡಬಹುದು, ಅದರಲ್ಲಿ ಅಗತ್ಯ ಸ್ಥಳಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ಪ್ಲಗಿನ್‌ನ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಜೋಡಿಸಬಹುದು. ಅಂತೆಯೇ, ಕೋಡ್‌ಗೆ ನಂತರದ ಬದಲಾವಣೆಗಳು ಕಾರ್ಮಿಕ ವೆಚ್ಚದಲ್ಲಿ ಬಹು ಹೆಚ್ಚಳಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ.

ನೀವು ಅನುಭವ ಮತ್ತು ಜ್ಞಾನವನ್ನು ಪಡೆದಂತೆ, ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನೀವು ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ಕಾಣಬಹುದು. ನಾನು ಈ ಹಾದಿಯಲ್ಲಿ ನಡೆದಿದ್ದೇನೆ ಮತ್ತು ನಾನು ಏನು ಕೊನೆಗೊಂಡಿದ್ದೇನೆ ಮತ್ತು ಅದು ಎಷ್ಟು ಅನುಕೂಲಕರವಾಗಿದೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳಲು ಬಯಸುತ್ತೇನೆ.

ಮೊದಲಿಗೆ, ಸ್ಪಷ್ಟವಾದ ಮತ್ತು ನಾನು ದೀರ್ಘಕಾಲದವರೆಗೆ ಬಳಸಿದ ವಿಧಾನವನ್ನು ನೋಡೋಣ.

ಪ್ರಾಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳಿಗೆ ಲಿಂಕ್‌ಗಳು

ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಸರಳ, ದೃಶ್ಯ ಮತ್ತು ಅರ್ಥವಾಗುವಂತೆ ಮಾಡಲು, ಪ್ಲಗಿನ್ ಅಭಿವೃದ್ಧಿಯ ಅಮೂರ್ತ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಾನು ಎಲ್ಲವನ್ನೂ ವಿವರಿಸುತ್ತೇನೆ.

ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋವನ್ನು ತೆರೆಯೋಣ (ನನ್ನ ಬಳಿ ಸಮುದಾಯ 2019 ಆವೃತ್ತಿ ಇದೆ. ಮತ್ತು ಹೌದು - ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ) ಮತ್ತು ಹೊಸ ಪರಿಹಾರವನ್ನು ರಚಿಸೋಣ. ಅವನನ್ನು ಕರೆಯೋಣ MySuperPluginForRevit

ನಾವು 2015-2020 ಆವೃತ್ತಿಗಳಿಗಾಗಿ Revit ಗಾಗಿ ಪ್ಲಗಿನ್ ಅನ್ನು ತಯಾರಿಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಪರಿಹಾರದಲ್ಲಿ ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸೋಣ (ನೆಟ್ ಫ್ರೇಮ್ವರ್ಕ್ ಕ್ಲಾಸ್ ಲೈಬ್ರರಿ) ಮತ್ತು ಅದನ್ನು ಕರೆಯೋಣ MySuperPluginForRevit_2015

ನಾವು Revit API ಗೆ ಲಿಂಕ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಸಹಜವಾಗಿ, ನಾವು ಸ್ಥಳೀಯ ಫೈಲ್‌ಗಳಿಗೆ ಲಿಂಕ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು (ನಾವು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ SDK ಗಳನ್ನು ಅಥವಾ Revit ನ ಎಲ್ಲಾ ಆವೃತ್ತಿಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ), ಆದರೆ ನಾವು ತಕ್ಷಣ ಸರಿಯಾದ ಮಾರ್ಗವನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ ಮತ್ತು NuGet ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುತ್ತೇವೆ. ನೀವು ಕೆಲವು ಪ್ಯಾಕೇಜುಗಳನ್ನು ಕಾಣಬಹುದು, ಆದರೆ ನಾನು ನನ್ನದೇ ಆದದನ್ನು ಬಳಸುತ್ತೇನೆ.

ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿದ ನಂತರ, ಐಟಂ ಮೇಲೆ ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ "ಉಲ್ಲೇಖಗಳು"ಮತ್ತು ಐಟಂ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ"packages.config ಅನ್ನು PackageReference ಗೆ ಸರಿಸಿ...»

ಈ ಹಂತದಲ್ಲಿ ಇದ್ದಕ್ಕಿದ್ದಂತೆ ನೀವು ಭಯಭೀತರಾಗಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ಏಕೆಂದರೆ ಪ್ಯಾಕೇಜ್ ಗುಣಲಕ್ಷಣಗಳ ವಿಂಡೋದಲ್ಲಿ ಯಾವುದೇ ಪ್ರಮುಖ ಐಟಂ ಇರುವುದಿಲ್ಲ "ಸ್ಥಳೀಯವಾಗಿ ನಕಲಿಸಿ", ನಾವು ಖಂಡಿತವಾಗಿಯೂ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಸಬೇಕಾಗಿದೆ ಸುಳ್ಳು, ನಂತರ ಪ್ಯಾನಿಕ್ ಮಾಡಬೇಡಿ - ಯೋಜನೆಯೊಂದಿಗೆ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ, ನಿಮಗೆ ಅನುಕೂಲಕರವಾದ ಸಂಪಾದಕದಲ್ಲಿ .csproj ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಿರಿ (ನಾನು ನೋಟ್‌ಪ್ಯಾಡ್ ++ ಅನ್ನು ಬಳಸುತ್ತೇನೆ) ಮತ್ತು ಅಲ್ಲಿ ನಮ್ಮ ಪ್ಯಾಕೇಜ್ ಕುರಿತು ನಮೂದನ್ನು ಹುಡುಕಿ. ಅವಳು ಈಗ ಈ ರೀತಿ ಕಾಣುತ್ತಾಳೆ:

<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 ಮತ್ತು ರೆವಿಟ್‌ನ ವಿವಿಧ ಆವೃತ್ತಿಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ಅಲ್ಲಿ ಕೆಲವು ಕೋಡ್ ಅನ್ನು ಅನುಕರಿಸಿ:

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 ರ ಮೇಲಿನ ಆವೃತ್ತಿಯ ರೆವಿಟ್‌ನ ಎಲ್ಲಾ ಆವೃತ್ತಿಗಳನ್ನು ನಾನು ತಕ್ಷಣವೇ ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡಿದ್ದೇನೆ (ಅವುಗಳು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ ಲಭ್ಯವಿದ್ದವು) ಮತ್ತು ಅದೇ ಟೆಂಪ್ಲೇಟ್ ಬಳಸಿ ರಚಿಸಲಾದ ಷರತ್ತುಬದ್ಧ ಸಂಕಲನ ಚಿಹ್ನೆಗಳ ಉಪಸ್ಥಿತಿಯನ್ನು ತಕ್ಷಣವೇ ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡೆ.

ಮುಖ್ಯ ಹೈಲೈಟ್‌ಗೆ ಹೋಗೋಣ. ನಾವು ನಮ್ಮ ಪರಿಹಾರದಲ್ಲಿ ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ, ರೆವಿಟ್ 2016 ಗಾಗಿ ಪ್ಲಗಿನ್ ಆವೃತ್ತಿಗೆ ಮಾತ್ರ. ನಾವು ಕ್ರಮವಾಗಿ ಮೇಲೆ ವಿವರಿಸಿದ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ, 2015 ಸಂಖ್ಯೆಯನ್ನು 2016 ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ. ಆದರೆ ಫೈಲ್ Class1.cs ಹೊಸ ಯೋಜನೆಯಿಂದ ಅಳಿಸಿ.

ಅಗತ್ಯವಿರುವ ಕೋಡ್‌ನೊಂದಿಗೆ ಫೈಲ್ - Class1.cs - ನಾವು ಈಗಾಗಲೇ ಅದನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಹೊಸ ಯೋಜನೆಯಲ್ಲಿ ಅದಕ್ಕೆ ಲಿಂಕ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಲಿಂಕ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಎರಡು ಮಾರ್ಗಗಳಿವೆ:

1. ಉದ್ದ - ಯೋಜನೆಯ ಮೇಲೆ ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಆಯ್ಕೆಮಾಡಿ "ಸೇರಿಸಿ»->«ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಂಶ", ತೆರೆಯುವ ವಿಂಡೋದಲ್ಲಿ, ಅಗತ್ಯವಿರುವ ಫೈಲ್ ಅನ್ನು ಹುಡುಕಿ ಮತ್ತು ಆಯ್ಕೆಯ ಬದಲಿಗೆ "ಸೇರಿಸಿ"ಆಯ್ಕೆಯನ್ನು ಆರಿಸಿ"ಸಂಪರ್ಕದಂತೆ ಸೇರಿಸಿ»

1. ಚಿಕ್ಕದಾಗಿದೆ - ನೇರವಾಗಿ ಪರಿಹಾರ ಪರಿಶೋಧಕದಲ್ಲಿ, ಬಯಸಿದ ಫೈಲ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ (ಅಥವಾ ಫೈಲ್‌ಗಳು, ಅಥವಾ ಸಂಪೂರ್ಣ ಫೋಲ್ಡರ್‌ಗಳು ಸಹ) ಮತ್ತು ಆಲ್ಟ್ ಕೀಲಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಾಗ ಅದನ್ನು ಹೊಸ ಯೋಜನೆಗೆ ಎಳೆಯಿರಿ. ನೀವು ಡ್ರ್ಯಾಗ್ ಮಾಡುವಾಗ, ನೀವು Alt ಕೀಲಿಯನ್ನು ಒತ್ತಿದಾಗ, ಮೌಸ್ ಕರ್ಸರ್ ಪ್ಲಸ್ ಚಿಹ್ನೆಯಿಂದ ಬಾಣಕ್ಕೆ ಬದಲಾಗುತ್ತದೆ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ.
   ಯುಪಿಡಿ: ಈ ಪ್ಯಾರಾಗ್ರಾಫ್‌ನಲ್ಲಿ ನಾನು ಸ್ವಲ್ಪ ಗೊಂದಲವನ್ನು ಮಾಡಿದ್ದೇನೆ - ಹಲವಾರು ಫೈಲ್‌ಗಳನ್ನು ವರ್ಗಾಯಿಸಲು ನೀವು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬೇಕು ಶಿಫ್ಟ್ + ಆಲ್ಟ್!

ಕಾರ್ಯವಿಧಾನವನ್ನು ನಡೆಸಿದ ನಂತರ, ನಾವು ಎರಡನೇ ಯೋಜನೆಯಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ Class1.cs ಅನುಗುಣವಾದ ಐಕಾನ್‌ನೊಂದಿಗೆ (ನೀಲಿ ಬಾಣ):

ಸಂಪಾದಕ ವಿಂಡೋದಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಸಂಪಾದಿಸುವಾಗ, ಕೋಡ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲು ಯಾವ ಯೋಜನೆಯ ಸಂದರ್ಭವನ್ನು ಸಹ ನೀವು ಆಯ್ಕೆ ಮಾಡಬಹುದು, ಇದು ವಿಭಿನ್ನ ಷರತ್ತುಬದ್ಧ ಸಂಕಲನ ಚಿಹ್ನೆಗಳ ಅಡಿಯಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಸಂಪಾದಿಸುವುದನ್ನು ನೋಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

ಈ ಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಎಲ್ಲಾ ಇತರ ಯೋಜನೆಗಳನ್ನು (2017-2020) ರಚಿಸುತ್ತೇವೆ. ಲೈಫ್ ಹ್ಯಾಕ್ - ನೀವು ಸೊಲ್ಯೂಷನ್ ಎಕ್ಸ್‌ಪ್ಲೋರರ್‌ನಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ಎಳೆದರೆ ಬೇಸ್ ಪ್ರಾಜೆಕ್ಟ್‌ನಿಂದ ಅಲ್ಲ, ಆದರೆ ಅವುಗಳನ್ನು ಈಗಾಗಲೇ ಲಿಂಕ್‌ನಂತೆ ಸೇರಿಸಲಾದ ಯೋಜನೆಯಿಂದ, ನೀವು ಆಲ್ಟ್ ಕೀಲಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ!

ಪ್ಲಗಿನ್‌ನ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಸೇರಿಸುವ ಕ್ಷಣದವರೆಗೆ ಅಥವಾ ಯೋಜನೆಗೆ ಹೊಸ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸುವ ಕ್ಷಣದವರೆಗೆ ವಿವರಿಸಿದ ಆಯ್ಕೆಯು ತುಂಬಾ ಒಳ್ಳೆಯದು - ಇವೆಲ್ಲವೂ ತುಂಬಾ ಬೇಸರದ ಸಂಗತಿಯಾಗಿದೆ. ಮತ್ತು ಇತ್ತೀಚೆಗೆ ನಾನು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಒಂದು ಯೋಜನೆಯೊಂದಿಗೆ ಎಲ್ಲವನ್ನೂ ಹೇಗೆ ವಿಂಗಡಿಸಬೇಕು ಎಂದು ಅರಿತುಕೊಂಡೆ ಮತ್ತು ನಾವು ಎರಡನೇ ವಿಧಾನಕ್ಕೆ ಹೋಗುತ್ತಿದ್ದೇವೆ

ಸಂರಚನೆಗಳ ಮ್ಯಾಜಿಕ್

ಇಲ್ಲಿ ಓದಿ ಮುಗಿಸಿದ ನಂತರ, "ಲೇಖನವು ತಕ್ಷಣವೇ ಎರಡನೆಯದಾಗಿದ್ದರೆ ನೀವು ಮೊದಲ ವಿಧಾನವನ್ನು ಏಕೆ ವಿವರಿಸಿದ್ದೀರಿ?!" ಮತ್ತು ನಮಗೆ ಷರತ್ತುಬದ್ಧ ಸಂಕಲನ ಚಿಹ್ನೆಗಳು ಏಕೆ ಬೇಕು ಮತ್ತು ನಮ್ಮ ಯೋಜನೆಗಳು ಯಾವ ಸ್ಥಳಗಳಲ್ಲಿ ಭಿನ್ನವಾಗಿವೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು ನಾನು ಎಲ್ಲವನ್ನೂ ವಿವರಿಸಿದೆ. ಮತ್ತು ಈಗ ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಯೋಜನೆಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸಗಳು ನಿಖರವಾಗಿ ನಮಗೆ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ, ಕೇವಲ ಒಂದು ಯೋಜನೆಯನ್ನು ಮಾತ್ರ ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿ ಮಾಡಲು, ನಾವು ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸುವುದಿಲ್ಲ, ಆದರೆ ಮೊದಲ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲಾದ ನಮ್ಮ ಪ್ರಸ್ತುತ ಯೋಜನೆಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುತ್ತೇವೆ.

ಆದ್ದರಿಂದ, ಮೊದಲನೆಯದಾಗಿ, ಮುಖ್ಯವಾದ (ಫೈಲ್ಗಳನ್ನು ನೇರವಾಗಿ ಒಳಗೊಂಡಿರುವ) ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಯೋಜನೆಗಳನ್ನು ನಾವು ಪರಿಹಾರದಿಂದ ತೆಗೆದುಹಾಕುತ್ತೇವೆ. ಆ. 2016-2020 ಆವೃತ್ತಿಗಳಿಗೆ ಯೋಜನೆಗಳು. ಪರಿಹಾರದೊಂದಿಗೆ ಫೋಲ್ಡರ್ ತೆರೆಯಿರಿ ಮತ್ತು ಅಲ್ಲಿ ಈ ಯೋಜನೆಗಳ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಅಳಿಸಿ.

ನಮ್ಮ ನಿರ್ಧಾರದಲ್ಲಿ ನಮಗೆ ಒಂದು ಯೋಜನೆ ಉಳಿದಿದೆ - MySuperPluginForRevit_2015. ಅದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು:

1. ಟ್ಯಾಬ್‌ನಲ್ಲಿ "ಅಪ್ಲಿಕೇಶನ್ಅಸೆಂಬ್ಲಿ ಹೆಸರಿನಿಂದ ಪ್ರತ್ಯಯವನ್ನು ತೆಗೆದುಹಾಕಿ _2015 (ಏಕೆ ಎಂಬುದು ನಂತರ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ)
2. ಟ್ಯಾಬ್‌ನಲ್ಲಿ "ಅಸೆಂಬ್ಲಿ» ಷರತ್ತುಬದ್ಧ ಸಂಕಲನ ಚಿಹ್ನೆಯನ್ನು ತೆಗೆದುಹಾಕಿ R2015 ಅನುಗುಣವಾದ ಕ್ಷೇತ್ರದಿಂದ

ಗಮನಿಸಿ: ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೊದ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯು ದೋಷವನ್ನು ಹೊಂದಿದೆ - ಷರತ್ತುಬದ್ಧ ಸಂಕಲನ ಚಿಹ್ನೆಗಳು ಲಭ್ಯವಿದ್ದರೂ ಪ್ರಾಜೆಕ್ಟ್ ಗುಣಲಕ್ಷಣಗಳ ವಿಂಡೋದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುವುದಿಲ್ಲ. ನೀವು ಈ ದೋಷವನ್ನು ಅನುಭವಿಸಿದರೆ, ನಂತರ ನೀವು ಅವುಗಳನ್ನು .csproj ಫೈಲ್‌ನಿಂದ ಹಸ್ತಚಾಲಿತವಾಗಿ ತೆಗೆದುಹಾಕಬೇಕಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನಾವು ಇನ್ನೂ ಅದರಲ್ಲಿ ಕೆಲಸ ಮಾಡಬೇಕಾಗಿದೆ, ಆದ್ದರಿಂದ ಓದಿ.

ಪ್ರತ್ಯಯವನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ಪರಿಹಾರ ಎಕ್ಸ್‌ಪ್ಲೋರರ್ ವಿಂಡೋದಲ್ಲಿ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಮರುಹೆಸರಿಸಿ _2015 ತದನಂತರ ಪರಿಹಾರದಿಂದ ಯೋಜನೆಯನ್ನು ತೆಗೆದುಹಾಕಿ. ಪರಿಪೂರ್ಣತಾವಾದಿಗಳ ಕ್ರಮ ಮತ್ತು ಭಾವನೆಗಳನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ! ನಾವು ನಮ್ಮ ಪರಿಹಾರದ ಫೋಲ್ಡರ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ, ಅಲ್ಲಿ ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್ ಅನ್ನು ಅದೇ ರೀತಿಯಲ್ಲಿ ಮರುಹೆಸರಿಸಿ ಮತ್ತು ಯೋಜನೆಯನ್ನು ಮತ್ತೆ ಪರಿಹಾರಕ್ಕೆ ಲೋಡ್ ಮಾಡುತ್ತೇವೆ.

ಕಾನ್ಫಿಗರೇಶನ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ತೆರೆಯಿರಿ. US ಸಂರಚನೆ ಬಿಡುಗಡೆ ತಾತ್ವಿಕವಾಗಿ, ಇದು ಅಗತ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಅಳಿಸುತ್ತೇವೆ. ನಮಗೆ ಈಗಾಗಲೇ ಪರಿಚಿತವಾಗಿರುವ ಹೆಸರುಗಳೊಂದಿಗೆ ನಾವು ಹೊಸ ಸಂರಚನೆಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ 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

ಈಗ ಆಜ್ಞೆಯನ್ನು ಬರೆಯಿರಿ ಅಣುಬಾಂಬು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಅಣುಬಾಂಬು ಪ್ರಸ್ತುತ ಯೋಜನೆಗಾಗಿ. ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ ಇದನ್ನು ಹೆಚ್ಚು ಸರಿಯಾಗಿ ಬರೆಯುವುದು ಹೇಗೆ ಎಂದು ನನಗೆ ತಿಳಿದಿಲ್ಲ - ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಇದನ್ನು ಬರೆಯಲಾಗುವುದು .nuke ಫೈಲ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗಲಿಲ್ಲ. ನೀವು ನಿರ್ಮಾಣವನ್ನು ಹೊಂದಿಸಲು ಬಯಸುವಿರಾ? [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"));
            }
        });
}

ನಾವು ಪವರ್ಶೆಲ್ ವಿಂಡೋಗೆ ಹಿಂತಿರುಗುತ್ತೇವೆ ಮತ್ತು ಮತ್ತೆ ಆಜ್ಞೆಯನ್ನು ಬರೆಯುತ್ತೇವೆ ಅಣುಬಾಂಬು (ನೀವು ಆಜ್ಞೆಯನ್ನು ಬರೆಯಬಹುದು ಅಣುಬಾಂಬು ಅಗತ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಟಾರ್ಗೆಟ್. ಆದರೆ ನಮ್ಮಲ್ಲಿ ಒಂದಿದೆ ಟಾರ್ಗೆಟ್, ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಚಲಿಸುತ್ತದೆ). Enter ಕೀಲಿಯನ್ನು ಒತ್ತಿದ ನಂತರ, ನಾವು ನಿಜವಾದ ಹ್ಯಾಕರ್‌ಗಳಂತೆ ಭಾವಿಸುತ್ತೇವೆ, ಏಕೆಂದರೆ, ಚಲನಚಿತ್ರದಲ್ಲಿರುವಂತೆ, ನಮ್ಮ ಯೋಜನೆಯು ವಿಭಿನ್ನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗಾಗಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಜೋಡಿಸಲ್ಪಡುತ್ತದೆ.

ಮೂಲಕ, ನೀವು ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೊದಿಂದ ನೇರವಾಗಿ PowerShell ಅನ್ನು ಬಳಸಬಹುದು (ಮೆನು "ವೀಕ್ಷಿಸಿ»->«ಇತರ ಕಿಟಕಿಗಳು»->«ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಕನ್ಸೋಲ್"), ಆದರೆ ಎಲ್ಲವೂ ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ಬಣ್ಣದಲ್ಲಿ ಇರುತ್ತದೆ, ಅದು ತುಂಬಾ ಅನುಕೂಲಕರವಲ್ಲ.

ಇದು ನನ್ನ ಲೇಖನವನ್ನು ಮುಕ್ತಾಯಗೊಳಿಸುತ್ತದೆ. ಆಟೋಕ್ಯಾಡ್ ಆಯ್ಕೆಯನ್ನು ನೀವೇ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು ಎಂದು ನನಗೆ ಖಾತ್ರಿಯಿದೆ. ಇಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾದ ವಸ್ತುವು ಅದರ "ಗ್ರಾಹಕರನ್ನು" ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು!

ಮೂಲ: www.habr.com