ਅਸੀਂ Revit/AutoCAD ਦੇ ​​ਵੱਖ-ਵੱਖ ਸੰਸਕਰਣਾਂ ਲਈ ਸੰਕਲਨ ਦੇ ਨਾਲ ਇੱਕ ਪਲੱਗਇਨ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਂਦੇ ਹਾਂ

CAD ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਪਲੱਗਇਨ ਵਿਕਸਿਤ ਕਰਨ ਵੇਲੇ (ਮੇਰੇ ਕੇਸ ਵਿੱਚ ਇਹ ਆਟੋਕੈਡ, ਰੀਵਿਟ ਅਤੇ ਰੇਂਗਾ ਹਨ) ਸਮੇਂ ਦੇ ਨਾਲ, ਇੱਕ ਸਮੱਸਿਆ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ - ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਜਾਰੀ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਉਹਨਾਂ ਦੇ ਏਪੀਆਈ ਤਬਦੀਲੀਆਂ ਅਤੇ ਪਲੱਗਇਨਾਂ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣਾਂ ਨੂੰ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ ਇੱਕ ਪਲੱਗਇਨ ਹੈ ਜਾਂ ਤੁਸੀਂ ਅਜੇ ਵੀ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਇੱਕ ਸਵੈ-ਸਿਖਿਅਤ ਸ਼ੁਰੂਆਤੀ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਿਰਫ਼ ਪ੍ਰੋਜੈਕਟ ਦੀ ਇੱਕ ਕਾਪੀ ਬਣਾ ਸਕਦੇ ਹੋ, ਇਸ ਵਿੱਚ ਜ਼ਰੂਰੀ ਸਥਾਨਾਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ ਅਤੇ ਪਲੱਗਇਨ ਦਾ ਇੱਕ ਨਵਾਂ ਸੰਸਕਰਣ ਇਕੱਠਾ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਅਨੁਸਾਰ, ਕੋਡ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਲੇਬਰ ਦੀਆਂ ਲਾਗਤਾਂ ਵਿੱਚ ਕਈ ਵਾਧਾ ਕਰਨਗੀਆਂ।

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਅਨੁਭਵ ਅਤੇ ਗਿਆਨ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ, ਤੁਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਲੱਭੋਗੇ। ਮੈਂ ਇਸ ਰਸਤੇ 'ਤੇ ਚੱਲਿਆ ਅਤੇ ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਮੈਂ ਕਿਸ ਨਾਲ ਖਤਮ ਹੋਇਆ ਅਤੇ ਇਹ ਕਿੰਨਾ ਸੁਵਿਧਾਜਨਕ ਹੈ।

ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਢੰਗ ਵੇਖੀਏ ਜੋ ਸਪੱਸ਼ਟ ਹੈ ਅਤੇ ਜੋ ਮੈਂ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਵਰਤਿਆ ਹੈ.

ਪ੍ਰੋਜੈਕਟ ਫਾਈਲਾਂ ਦੇ ਲਿੰਕ

ਅਤੇ ਹਰ ਚੀਜ਼ ਨੂੰ ਸਰਲ, ਵਿਜ਼ੂਅਲ ਅਤੇ ਸਮਝਣ ਯੋਗ ਬਣਾਉਣ ਲਈ, ਮੈਂ ਪਲੱਗਇਨ ਵਿਕਾਸ ਦੀ ਇੱਕ ਸੰਖੇਪ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਰ ਚੀਜ਼ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ.

ਚਲੋ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਖੋਲ੍ਹੀਏ (ਮੇਰੇ ਕੋਲ ਕਮਿਊਨਿਟੀ 2019 ਸੰਸਕਰਣ ਹੈ। ਅਤੇ ਹਾਂ - ਰੂਸੀ ਵਿੱਚ) ਅਤੇ ਇੱਕ ਨਵਾਂ ਹੱਲ ਤਿਆਰ ਕਰੀਏ। ਚਲੋ ਉਸਨੂੰ ਕਾਲ ਕਰੀਏ MySuperPluginForRevit

ਅਸੀਂ ਵਰਜਨ 2015-2020 ਲਈ Revit ਲਈ ਇੱਕ ਪਲੱਗਇਨ ਬਣਾਵਾਂਗੇ। ਇਸ ਲਈ, ਆਓ ਹੱਲ (ਨੈੱਟ ਫਰੇਮਵਰਕ ਕਲਾਸ ਲਾਇਬ੍ਰੇਰੀ) ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਈਏ ਅਤੇ ਇਸਨੂੰ ਕਾਲ ਕਰੀਏ MySuperPluginForRevit_2015

ਸਾਨੂੰ Revit API ਵਿੱਚ ਲਿੰਕ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਬੇਸ਼ੱਕ, ਅਸੀਂ ਸਥਾਨਕ ਫਾਈਲਾਂ ਦੇ ਲਿੰਕ ਜੋੜ ਸਕਦੇ ਹਾਂ (ਸਾਨੂੰ ਸਾਰੇ ਲੋੜੀਂਦੇ SDKs ਜਾਂ 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ਤਾਂ ਕਿ ਸਾਡਾ ਨਾਮ ਸਥਾਨ ਸਰਵ ਵਿਆਪਕ ਅਤੇ ਅਸੈਂਬਲੀ ਨਾਮ ਤੋਂ ਸੁਤੰਤਰ ਹੋਵੇ:

ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਅੰਤਮ ਉਤਪਾਦ ਵਿੱਚ, ਸਾਰੇ ਸੰਸਕਰਣਾਂ ਦੇ ਪਲੱਗਇਨ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਰੱਖੇ ਜਾਂਦੇ ਹਨ, ਇਸਲਈ ਮੇਰੇ ਅਸੈਂਬਲੀ ਨਾਮ ਫਾਰਮ ਦੇ ਪਿਛੇਤਰ ਦੇ ਨਾਲ ਰਹਿੰਦੇ ਹਨ _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 (ਜੋ ਲਿਖਣ ਦੇ ਸਮੇਂ ਉਪਲਬਧ ਸਨ) ਦੇ ਸਾਰੇ ਸੰਸਕਰਣਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ ਅਤੇ ਤੁਰੰਤ ਸ਼ਰਤੀਆ ਸੰਕਲਨ ਚਿੰਨ੍ਹਾਂ ਦੀ ਮੌਜੂਦਗੀ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ, ਜੋ ਉਸੇ ਟੈਪਲੇਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਏ ਗਏ ਹਨ।

ਆਉ ਮੁੱਖ ਹਾਈਲਾਈਟ ਵੱਲ ਵਧੀਏ. ਅਸੀਂ ਆਪਣੇ ਹੱਲ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਂਦੇ ਹਾਂ, ਸਿਰਫ ਰੀਵਿਟ 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 ਅਤੇ ਫਿਰ ਹੱਲ ਤੋਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਹਟਾਓ। ਇਹ ਸੰਪੂਰਨਤਾਵਾਦੀਆਂ ਦੀ ਵਿਵਸਥਾ ਅਤੇ ਭਾਵਨਾਵਾਂ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ! ਅਸੀਂ ਆਪਣੇ ਹੱਲ ਦੇ ਫੋਲਡਰ ਨੂੰ ਖੋਲ੍ਹਦੇ ਹਾਂ, ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਦਾ ਨਾਮ ਬਦਲਦੇ ਹਾਂ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਹੱਲ ਵਿੱਚ ਵਾਪਸ ਲੋਡ ਕਰਦੇ ਹਾਂ.

ਸੰਰਚਨਾ ਪ੍ਰਬੰਧਕ ਨੂੰ ਖੋਲ੍ਹੋ. US ਸੰਰਚਨਾ ਰੀਲਿਜ਼ ਸਿਧਾਂਤ ਵਿੱਚ, ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੋਵੇਗੀ, ਇਸਲਈ ਅਸੀਂ ਇਸਨੂੰ ਮਿਟਾ ਦਿੰਦੇ ਹਾਂ। ਅਸੀਂ ਉਹਨਾਂ ਨਾਮਾਂ ਨਾਲ ਨਵੀਆਂ ਸੰਰਚਨਾਵਾਂ ਬਣਾਉਂਦੇ ਹਾਂ ਜੋ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣੂ ਹਨ R2015, R2016,..., R2020. ਨੋਟ ਕਰੋ ਕਿ ਤੁਹਾਨੂੰ ਹੋਰ ਸੰਰਚਨਾਵਾਂ ਤੋਂ ਸੈਟਿੰਗਾਂ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਪ੍ਰੋਜੈਕਟ ਸੰਰਚਨਾਵਾਂ ਬਣਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ:

ਪ੍ਰੋਜੈਕਟ ਵਾਲੇ ਫੋਲਡਰ 'ਤੇ ਜਾਓ ਅਤੇ ਤੁਹਾਡੇ ਲਈ ਸੁਵਿਧਾਜਨਕ ਸੰਪਾਦਕ ਵਿੱਚ .csproj ਐਕਸਟੈਂਸ਼ਨ ਨਾਲ ਫਾਈਲ ਖੋਲ੍ਹੋ। ਤਰੀਕੇ ਨਾਲ, ਤੁਸੀਂ ਇਸਨੂੰ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਵਿੱਚ ਵੀ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ - ਤੁਹਾਨੂੰ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅਨਲੋਡ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਅਤੇ ਫਿਰ ਲੋੜੀਂਦੀ ਆਈਟਮ ਸੰਦਰਭ ਮੀਨੂ ਵਿੱਚ ਹੋਵੇਗੀ:

ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਵਿੱਚ ਸੰਪਾਦਨ ਕਰਨਾ ਹੋਰ ਵੀ ਤਰਜੀਹੀ ਹੈ, ਕਿਉਂਕਿ ਸੰਪਾਦਕ ਦੋਵੇਂ ਅਲਾਈਨ ਅਤੇ ਪ੍ਰੋਂਪਟ ਕਰਦਾ ਹੈ।

ਫਾਈਲ ਵਿੱਚ ਅਸੀਂ ਐਲੀਮੈਂਟਸ ਵੇਖਾਂਗੇ ਪ੍ਰਾਪਰਟੀ ਗਰੁੱਪ - ਸਭ ਤੋਂ ਸਿਖਰ 'ਤੇ ਆਮ ਹੈ, ਅਤੇ ਫਿਰ ਹਾਲਾਤ ਆਉਂਦੇ ਹਨ। ਇਹ ਤੱਤ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਜਦੋਂ ਇਹ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ. ਪਹਿਲਾ ਐਲੀਮੈਂਟ, ਜੋ ਬਿਨਾਂ ਸ਼ਰਤਾਂ ਤੋਂ ਹੁੰਦਾ ਹੈ, ਆਮ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੈੱਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਸ਼ਰਤਾਂ ਵਾਲੇ ਤੱਤ, ਉਸ ਅਨੁਸਾਰ, ਸੰਰਚਨਾਵਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ।

ਆਮ (ਪਹਿਲੇ) ਤੱਤ 'ਤੇ ਜਾਓ ਪ੍ਰਾਪਰਟੀ ਗਰੁੱਪ ਅਤੇ ਜਾਇਦਾਦ ਨੂੰ ਦੇਖੋ ਅਸੈਂਬਲੀ ਦਾ ਨਾਮ - ਇਹ ਅਸੈਂਬਲੀ ਦਾ ਨਾਮ ਹੈ ਅਤੇ ਸਾਨੂੰ ਇਹ ਬਿਨਾਂ ਪਿਛੇਤਰ ਦੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ _2015. ਜੇ ਕੋਈ ਪਿਛੇਤਰ ਹੈ, ਤਾਂ ਉਸ ਨੂੰ ਹਟਾ ਦਿਓ.

ਇੱਕ ਸ਼ਰਤ ਦੇ ਨਾਲ ਇੱਕ ਤੱਤ ਲੱਭਣਾ

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

ਸਾਨੂੰ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੈ - ਅਸੀਂ ਇਸਨੂੰ ਮਿਟਾ ਦਿੰਦੇ ਹਾਂ।

ਸ਼ਰਤ ਵਾਲਾ ਤੱਤ

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

ਕੋਡ ਡਿਵੈਲਪਮੈਂਟ ਅਤੇ ਡੀਬੱਗਿੰਗ ਦੇ ਪੜਾਅ 'ਤੇ ਕੰਮ ਕਰਨ ਲਈ ਲੋੜ ਹੋਵੇਗੀ। ਤੁਸੀਂ ਆਪਣੀਆਂ ਲੋੜਾਂ ਮੁਤਾਬਕ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ - ਵੱਖ-ਵੱਖ ਆਉਟਪੁੱਟ ਮਾਰਗ ਸੈਟ ਕਰੋ, ਕੰਡੀਸ਼ਨਲ ਕੰਪਾਈਲੇਸ਼ਨ ਸਿੰਬਲ ਬਦਲੋ, ਆਦਿ।

ਹੁਣ ਨਵੇਂ ਤੱਤ ਬਣਾਉ ਪ੍ਰਾਪਰਟੀ ਗਰੁੱਪ ਸਾਡੀਆਂ ਸੰਰਚਨਾਵਾਂ ਲਈ। ਇਹਨਾਂ ਤੱਤਾਂ ਵਿੱਚ ਸਾਨੂੰ ਸਿਰਫ਼ ਚਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

• ਆਉਟਪੁੱਟਪਾਥ - ਆਉਟਪੁੱਟ ਫੋਲਡਰ. ਮੈਂ ਡਿਫੌਲਟ ਮੁੱਲ ਸੈੱਟ ਕੀਤਾ ਹੈ binR20xx
• ਕੰਸਟੈਂਟਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ - ਸ਼ਰਤੀਆ ਸੰਕਲਨ ਚਿੰਨ੍ਹ। ਮੁੱਲ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ TRACE;R20хх
• ਟਾਰਗੇਟਫ੍ਰੇਮਵਰਕ ਵਰਜ਼ਨ - ਪਲੇਟਫਾਰਮ ਸੰਸਕਰਣ. Revit API ਦੇ ਵੱਖ-ਵੱਖ ਸੰਸਕਰਣਾਂ ਲਈ ਵੱਖ-ਵੱਖ ਪਲੇਟਫਾਰਮਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
• ਅਸੈਂਬਲੀ ਦਾ ਨਾਮ - ਅਸੈਂਬਲੀ ਦਾ ਨਾਮ (ਜਿਵੇਂ ਕਿ ਫਾਈਲ ਨਾਮ)। ਤੁਸੀਂ ਅਸੈਂਬਲੀ ਦਾ ਸਹੀ ਨਾਮ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਬਹੁਪੱਖੀਤਾ ਲਈ ਮੈਂ ਮੁੱਲ ਲਿਖਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ $(AsemblyName)_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. ਮੈਂ ਅਸਲ ਵਿੱਚ ਇਹ ਨਹੀਂ ਚਾਹੁੰਦਾ ਸੀ ਕਿਉਂਕਿ ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਪਲੱਗਇਨ ਵਿਕਾਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ, ਪਰ ਇਸ ਸਮੇਂ ਮੈਨੂੰ ਕੋਈ ਹੋਰ ਹੱਲ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦਾ। ਅਤੇ ਇਸ ਸਵਾਲ ਦਾ ਜਵਾਬ "ਕਿਉਂ Nuke?" ਜਵਾਬ ਸਧਾਰਨ ਹੈ - ਅਸੀਂ ਇਸਨੂੰ ਕੰਮ 'ਤੇ ਵਰਤਦੇ ਹਾਂ।

ਇਸ ਲਈ, ਸਾਡੇ ਹੱਲ ਦੇ ਫੋਲਡਰ 'ਤੇ ਜਾਓ (ਪ੍ਰੋਜੈਕਟ ਨਹੀਂ), ਕੁੰਜੀ ਨੂੰ ਦਬਾ ਕੇ ਰੱਖੋ Shift ਅਤੇ ਫੋਲਡਰ ਵਿੱਚ ਖਾਲੀ ਥਾਂ 'ਤੇ ਸੱਜਾ-ਕਲਿੱਕ ਕਰੋ - ਸੰਦਰਭ ਮੀਨੂ ਵਿੱਚ ਆਈਟਮ ਦੀ ਚੋਣ ਕਰੋ "ਇੱਥੇ PowerShell ਵਿੰਡੋ ਖੋਲ੍ਹੋ".

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇਹ ਸਥਾਪਿਤ ਨਹੀਂ ਹੈ 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"));
            }
        });
}

ਅਸੀਂ PowerShell ਵਿੰਡੋ 'ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ਅਤੇ ਕਮਾਂਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਦੇ ਹਾਂ nuke (ਤੁਸੀਂ ਕਮਾਂਡ ਲਿਖ ਸਕਦੇ ਹੋ nuke ਲੋੜ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਟੀਚੇ ਦਾ. ਪਰ ਸਾਡੇ ਕੋਲ ਇੱਕ ਹੈ ਟੀਚੇ ਦਾ, ਜੋ ਮੂਲ ਰੂਪ ਵਿੱਚ ਚੱਲਦਾ ਹੈ)। ਐਂਟਰ ਕੁੰਜੀ ਨੂੰ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਅਸਲ ਹੈਕਰਾਂ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ, ਇੱਕ ਫਿਲਮ ਦੀ ਤਰ੍ਹਾਂ, ਸਾਡਾ ਪ੍ਰੋਜੈਕਟ ਵੱਖ-ਵੱਖ ਸੰਰਚਨਾਵਾਂ ਲਈ ਆਪਣੇ ਆਪ ਹੀ ਅਸੈਂਬਲ ਹੋ ਜਾਵੇਗਾ।

ਵੈਸੇ, ਤੁਸੀਂ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ (ਮੀਨੂ " ਤੋਂ ਸਿੱਧਾ PowerShell ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋਝਲਕ->ਹੋਰ ਵਿੰਡੋਜ਼->ਪੈਕੇਜ ਮੈਨੇਜਰ ਕੰਸੋਲ"), ਪਰ ਸਭ ਕੁਝ ਕਾਲੇ ਅਤੇ ਚਿੱਟੇ ਵਿੱਚ ਹੋਵੇਗਾ, ਜੋ ਕਿ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ.

ਇਹ ਮੇਰੇ ਲੇਖ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ. ਮੈਨੂੰ ਯਕੀਨ ਹੈ ਕਿ ਤੁਸੀਂ ਖੁਦ ਆਟੋਕੈਡ ਲਈ ਵਿਕਲਪ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹੋ। ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇੱਥੇ ਪੇਸ਼ ਕੀਤੀ ਗਈ ਸਮੱਗਰੀ ਇਸਦੇ "ਗਾਹਕਾਂ" ਨੂੰ ਲੱਭ ਲਵੇਗੀ.

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ!

ਸਰੋਤ: www.habr.com