Visual Studio 2017 (.NET Core) में ऑटो संस्करण

112

मैंने कुछ घंटों के बेहतर हिस्से को .NETCoreApp 1.1 (विजुअल स्टूडियो 2017) में ऑटो-इंक्रीमेंट वर्जन का रास्ता खोजने की कोशिश में बिताया है।

मुझे पता है कि विधानसभाInfo.cs फ़ोल्डर में गतिशील रूप से बनाया जा रहा है: obj/Debug/netcoreapp1.1/

यह पुरानी पद्धति को स्वीकार नहीं करता है: [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.*")]

अगर मैं इस परियोजना को पैकेज करने के लिए सेट करता हूं तो मैं वहां संस्करण सेट कर सकता हूं, लेकिन असेंबलीइन्फो को बनाने के लिए इसका उपयोग किया जाता है।

मेरा प्रश्न यह है कि क्या किसी को पता लगा है कि .NET कोर (या उस मामले के लिए .NET मानक) में संस्करण को कैसे नियंत्रित किया जाए।

c#  visual-studio  .net-core  visual-studio-2017  .net-standard 
— जेसन एच
स्रोत
मुझे नहीं पता कि आप इसके साथ कितने दूर हैं, लेकिन ऐसा लगता है कि मैंने लगभग एक ही सवाल एक अलग तरीके से पूछा है ( stackoverflow.com/a/43280282/685341 ) - शायद इस सवाल का स्वीकृत जवाब आपकी मदद करेगा; आप बस अपनी बिल्ड स्क्रिप्ट में /p:ध्वज को पास कर सकते हैं dotnet msbuildऔर संस्करण, कंपनी, कॉपीराइट ... सभी अच्छे सामान सेट कर सकते हैं।
— Jay
2
जानकारी के लिए धन्यवाद। बस अतिरिक्त विकल्प खोलें।
— जेसन एच
पहले * विधानसभावर्सन के लिए समर्थन किया गया था, असेंबलीफाइल वर्जन के
— माइकल फ्रीजिम
4
विधानसभा संस्करण में एफडब्ल्यूआईडब्ल्यू वाइल्डकार्ड समर्थित नहीं है क्योंकि इन नए प्रोजेक्ट के लिए, कंपाइलर का "नियतात्मक" मोड डिफ़ॉल्ट रूप से सक्रिय है। चूंकि ऑटो-इन्क्रीमेंट निर्धारणवाद (उसी इनपुट> समान आउटपुट) को तोड़ देगा, यह उस मोड में अस्वीकृत है। आप <Deterministic>False</Deterministic>इसे उपयोग करने के लिए csproj में सेट कर सकते हैं । (या गणना करने के लिए किसी अन्य MSbuild तर्क का उपयोग करें ) <VersionPrefix>/<Version>
— मार्टिन Ullrich

जवाबों:

23

मैं csproj कॉन्फ़िगरेशन प्रारूप का उपयोग करके VS2017 में नेट कोर ऐप के लिए एक वर्जन इन्क्रीमेंटर की तलाश कर रहा हूं।

मुझे डॉटनेट बम्प नामक एक प्रोजेक्ट मिला, जो प्रोजेक्ट के लिए काम करता था। json फॉर्मेट लेकिन .csproj प्रारूप के लिए एक समाधान खोजने के लिए संघर्ष किया। डॉटनेट बम्प लेखक वास्तव में .csproj प्रारूप के लिए समाधान के साथ आया था और इसे MSBump कहा जाता है।

इसके लिए GitHub पर एक परियोजना है:

https://github.com/BalassaMarton/MSBump

जहाँ आप Nuget पर कोड और उसके उपलब्ध भी देख सकते हैं। बस Nuget पर MSBump खोजें।

— ravetroll
स्रोत
1
मैं MSBump के नवीनतम 2.1.0 रिलीज का उपयोग करने की सलाह देता हूं, यह स्विचिंग कॉन्फ़िगरेशन को बेहतर ढंग से समर्थन करता है, और वर्तमान बिल्ड के लिए संस्करण भी सेट करता है, न कि अगले एक (पिछले संस्करण की तरह)।
— मॉर्टन Balassa
मैं देख रहा हूं कि अब यह MSBuild को भी सपोर्ट करता है जबकि इससे पहले इसे विजुअल स्टूडियो की आवश्यकता थी।
— नवविवाहिता
2
हां, और यह बहु-लक्ष्यीकरण परियोजनाओं का भी समर्थन करता है।
— मेर्टन बलासा
4
GitVersioning का उपयोग करने पर विचार करें। यह आपके CI वातावरण पर चलने के लिए उपयुक्त हो सकता है। github.com/AArnott/Nerdbank.GitVersioning
— हेनरिक
1
MSBump हर बिल्ड पर वर्जन बढ़ाता है, भले ही आपने कुछ भी नहीं बदला हो, इससे लॉन्ग टर्म में काफी समस्याएँ आती हैं। और कभी-कभी संस्करण सिंक से बाहर जाते हैं और एक संस्करण दूसरे के पीछे होता है।
— कोनराड
68

<Deterministic>False</Deterministic><PropertyGroup>.Csproj के एक सेक्शन के अंदर जोड़ें 

असेंबली विड्रॉल * बनाने के लिए वर्कअराउंड में वर्णित किया गया है, "। नेट कोर # 22660 में [असेंबली वर्जन] में वाइल्डकार्ड के लिए भ्रामक त्रुटि संदेश"।

वाइल्डकार्ड को केवल तभी अनुमति दी जाती है जब बिल्ड निर्धारक नहीं होता है, जो .Net कोर परियोजनाओं के लिए डिफ़ॉल्ट है। <Deterministic>False</Deterministic> Csproj में जोड़ने  से समस्या ठीक हो जाती है।

.नेट कोर डेवलपर्स ने http://blog.paranoidcoding.com/2016/04/05/deterministic-builds-in-roslyn.html में वर्णित लाभकारी बिल्ड को लाभकारी माना है और कंपाइलर्स को निर्धारक होना चाहिए: एक ही इनपुट # आउटपुट उत्पन्न करता है 372

हालाँकि यदि आप टीमसिटी, टीएफएस या अन्य सीआई / सीडी टूल का उपयोग कर रहे हैं, तो संभवतः संस्करण संख्या को उनके द्वारा नियंत्रित और संवर्धित रखना और एक पैरामीटर के रूप में बनाने के लिए बेहतर होगा (जैसा कि अन्य उत्तरों में सुझाया गया था), जैसे। 

msbuild /t:build /p:Version=YourVersionNumber /p:AssemblyVersion=YourVersionNumber

NuGet पैकेज के लिए पैकेज नंबर

msbuild /t:pack /p:Version=YourVersionNumber
— माइकल फ्रीजिम
स्रोत
धन्यवाद! मुझे पता था कि खजाना कमरे को खोलने के लिए एक छिपा हुआ लीवर था! मैं नए .NET SDK के लिए एक पुराने प्रोजेक्ट को माइग्रेट कर रहा हूं, और मैं वास्तव में यह तेजी से करना चाहता था, स्वचालित संस्करण वेतन वृद्धि समाधान खोजने की परेशानी के बिना। वास्तव में, पुराने तरीकों से अधिक संगत मेरे मामले के लिए बेहतर है।
— Ivaylo Slavov
यह सबसे अच्छा उत्तर IMO है। यह बिल्ड टूलिंग को ठीक से काम करने की अनुमति देता है। कम से कम मैं एक बाहरी तंत्र का उपयोग कर सकता हूं ताकि अब बिल्ड में संख्या को फीड किया जा सके।
— माइकल यानी
कृपया अपने उत्तर का विस्तार थोड़ा और करें: सुझाए गए अतिरिक्त को <संपत्ति समूह> .csproj के अनुभाग में जाने की आवश्यकता है। और इस महान जवाब के लिए धन्यवाद, ऑफ कोर्स!
— गेरार्डव
1
@gerardv, किया गया, लेकिन आप अपने आप से संपादन सुधार कर सकते हैं stackoverflow.com/help/editing
— माइकल फ्रीजिम
62

यदि आप Visual Studio Team Services / TFS या कुछ अन्य CI बिल्ड प्रक्रिया का उपयोग कर रहे हैं, जिसमें अंतर्निहित वर्ज़निंग है, तो आप msbuild की Conditionविशेषता का उपयोग कर सकते हैं , उदाहरण के लिए:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' == '' ">0.0.1-local</Version>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' != '' ">$(BUILD_BUILDNUMBER)</Version>
    <TargetFramework>netcoreapp1.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Folder Include="wwwroot\" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.0.0" />
    <PackageReference Include="Microsoft.AspNetCore" Version="1.1.2" />
    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="1.1.2" />
  </ItemGroup>

</Project>

यह .NET कोर कंपाइलर को यह बताएगा कि BUILD_BUILDNUMBERयदि वह मौजूद है, तो पर्यावरण चर में जो भी है उसका उपयोग करने के लिए , या 0.0.1-localयदि आप अपनी स्थानीय मशीन पर निर्माण कर रहे हैं , तो उसे वापस ले लेंगे।

— joelsand
स्रोत
अच्छा है, मुझे यह तरीका पसंद है क्योंकि एनवायरनमेंट वेरिएबल्स को केवल बिल्ड सर्वर पर सेट किया जा सकता है, जबकि ये कंडीशन बायनेरिज़ में असेंबली सेट को डैमेज करते हैं।
— जुकर
टीएफएस 2010 पर काम करने के लिए प्रतीत नहीं होता है, लेकिन उम्मीद है कि हम जल्द ही आगे बढ़ रहे हैं!
— मार्क एडम्सन
एक बुरा समाधान नहीं है, हालांकि समाधान का एक बहुत कुछ हो सकता है अगर समाधान में बहुत सारी परियोजनाएं हैं।
— टोफुटिम
अच्छा समाधान। हालांकि मुझे एक बिल्ड अपवाद मिला। मुझे इसे ठीक करने के लिए कॉन्फ़िगरेशन को थोड़ा बदलना पड़ा। stackoverflow.com/a/59858009/106227
— स्टु हार्पर
यह .NET कोर 2.1.2 और TFS2017U3
— डेव जॉनसन
16

मैं समाधान है कि लगभग वर्ष के रूप में ही काम किया के साथ आया था AssemblyVersion स्टार (*) से विशेषता - ( "। 1.0 AssemblyVersion ") *

के लिए मान AssemblyVersion और AssemblyFileVersion MSBuild परियोजना में है .csproj फ़ाइल (में नहीं AssemblyInfo.cs ) संपत्ति के रूप में FileVersion (उत्पन्न AssemblyFileVersionAttribute ) और AssemblyVersion (उत्पन्न AssemblyVersionAttribute )। MSBuild प्रक्रिया में हम संस्करण संख्या उत्पन्न करने के लिए हमारे कस्टम MSBuild कार्य का उपयोग करें और फिर हम इनमें से मूल्यों को भी पार FileVersion और AssemblyVersion कार्य से नए मूल्यों के साथ गुण।

तो पहले हम अपने कस्टम MSBuild कार्य GetCurrentBuildVersion बनाएँ :

public class GetCurrentBuildVersion : Task
{
    [Output]
    public string Version { get; set; }
 
    public string BaseVersion { get; set; }
 
    public override bool Execute()
    {
        var originalVersion = System.Version.Parse(this.BaseVersion ?? "1.0.0");
 
        this.Version = GetCurrentBuildVersionString(originalVersion);
 
        return true;
    }
 
    private static string GetCurrentBuildVersionString(Version baseVersion)
    {
        DateTime d = DateTime.Now;
        return new Version(baseVersion.Major, baseVersion.Minor,
            (DateTime.Today - new DateTime(2000, 1, 1)).Days,
            ((int)new TimeSpan(d.Hour, d.Minute, d.Second).TotalSeconds) / 2).ToString();
    }
}

टास्क क्लास को Microsoft.Build.Utilities.Task से विरासत में मिला है । Microsoft.Build.Utilities.Core NuGet पैकेज से। यह BaseVersion संपत्ति (वैकल्पिक) इनपुट पर लेता है और संस्करण आउटपुट संपत्ति में उत्पन्न संस्करण देता है। संस्करण संख्याओं को प्राप्त करने का तर्क .NET ऑटोमैटिक वर्जनिंग के समान है (बिल्ड नंबर दिन की गिनती 1/1/2000 के बाद से है और संशोधन आधी रात के बाद से आधा सेकंड है)।

इस MSBuild कार्य को बनाने के लिए, हम इस वर्ग के साथ .NET मानक 1.3 वर्ग पुस्तकालय परियोजना प्रकार का उपयोग करते हैं।

.csproj फ़ाइल इस तरह दिख सकती है:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard1.3</TargetFramework>
    <AssemblyName>DC.Build.Tasks</AssemblyName>
    <RootNamespace>DC.Build.Tasks</RootNamespace>
    <PackageId>DC.Build.Tasks</PackageId>
    <AssemblyTitle>DC.Build.Tasks</AssemblyTitle>
  </PropertyGroup>
 
  <ItemGroup>
    <PackageReference Include="Microsoft.Build.Framework" Version="15.1.1012" />
    <PackageReference Include="Microsoft.Build.Utilities.Core" Version="15.1.1012" />
  </ItemGroup>
</Project>

यह कार्य परियोजना मेरे GitHub Holajan / DC.Build.Tasks में भी उपलब्ध है

अब हम MSBuild को इस कार्य का उपयोग करने के लिए सेटअप करते हैं और FileVersion और AssemblyVersion गुण सेट करते हैं। .Csproj फ़ाइल में ऐसा दिखता है:

<Project Sdk="Microsoft.NET.Sdk">
  <UsingTask TaskName="GetCurrentBuildVersion" AssemblyFile="$(MSBuildThisFileFullPath)\..\..\DC.Build.Tasks.dll" />
 
  <PropertyGroup>
    ...
    <AssemblyVersion>1.0.0.0</AssemblyVersion>
    <FileVersion>1.0.0.0</FileVersion>
  </PropertyGroup>
 
  ...
 
  <Target Name="BeforeBuildActionsProject1" BeforeTargets="BeforeBuild">
    <GetCurrentBuildVersion BaseVersion="$(FileVersion)">
      <Output TaskParameter="Version" PropertyName="FileVersion" />
    </GetCurrentBuildVersion>
    <PropertyGroup>
      <AssemblyVersion>$(FileVersion)</AssemblyVersion>
    </PropertyGroup>
  </Target>
 
</Project>

यहाँ महत्वपूर्ण बातें:

  • का उपयोग कर उल्लेख किया गया। आयात से DCCBuild.Tasks.dll से GetCurrentBuildVersion कार्य आयात करता है । यह मानता है कि यह dll फ़ाइल आपके .csproj फ़ाइल से मूल निर्देशिका पर स्थित है।
  • हमारा पहलाBBildActionsProject1 लक्ष्य जो कॉल कार्य को प्रति प्रोजेक्ट में अद्वितीय नाम होना चाहिए, यदि हमारे पास समाधान में अधिक परियोजनाएँ हैं जो GetCurrentBuildVersion कार्य को कॉल करती हैं।

इस समाधान का लाभ यह है कि यह न केवल बिल्ड सर्वर पर बिल्ड से काम करता है, बल्कि डॉटनेट बिल्ड या विजुअल स्टूडियो से मैनुअल बिल्ड में भी काम करता है ।

— HolaJan
स्रोत
4
मैं विशेष रूप से विधि के DateTime.UtcNowबजाय उपयोग करने की सलाह दूंगा यदि कोड का निर्माण स्वचालित मशीनों पर किया जाता है। वे दिन में 2 बजे या 3 बजे तब चल सकते हैं जब आपका कंप्यूटर दिन के समय की बचत से / स्विच करता है। साथ उस स्थिति में आप संस्करण के मामले में पीछे की ओर जा रहे हैं। बेशक, यह एक कोने का मामला है और मैं यह भी स्वीकार करता हूं कि मैं योग्य हूं। :-) इसके अलावा, समस्या तब भी दूर हो जाती है जब आप सभी बिल्ड मशीनों पर एक ही टाइमज़ोन को कॉन्फ़िगर करते हैं और डेलाइट सेविंग टाइम को समायोजित नहीं करते हैं। DateTime.NowGetCurrentBuildVersionString()DateTime.Now
— मैनफ़्रेड
क्या अभी तक इसके लिए कोई न्यूगेट पैकेज है?
— जोनाथन एलन
@ जोनाथन एलन नहीं, मेरे पास प्रत्येक परियोजना में अलग-अलग नाम होने के कारण नगेट पैकेज की कोई योजना नहीं है। आप संकलित निर्माण कार्य को github.com/holajan/DC.Build.Tasks/tree/master/dist फ़ोल्डर में डाउनलोड कर सकते हैं
— होलाजन
हम एक सर्वर से हमारे संस्करण को खींचने के लिए एक कस्टम कंसोल ऐप का उपयोग कर रहे हैं और बिल्ड होने से पहले असेंबलीइन्फो.एक्स फ़ाइल उत्पन्न करते हैं। हम जो करते हैं, उसके लिए यह दृष्टिकोण सही है। क्या आप नई परियोजनाओं के पैक फीचर के "संस्करण" में संस्करण को आगे बढ़ाने के लिए इस पद्धति का उपयोग करने में सक्षम हैं? यह अच्छा होगा, लेकिन मुझे लगता है कि हम पैकेज में nuget.exe का उपयोग करने के लिए वापस गिर सकते हैं क्योंकि हमें इसे प्रकाशित करने की भी आवश्यकता होगी।
— डेविड रिची
15

वर्तमान तिथि के आधार पर संस्करण प्रत्यय सेट करने के लिए आप MSBuild संपत्ति फ़ंक्शन का उपयोग कर सकते हैं:

<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
  <VersionSuffix>pre$([System.DateTime]::UtcNow.ToString(yyyyMMdd-HHmm))</VersionSuffix>
</PropertyGroup>

यह एक नाम के साथ एक पैकेज का उत्पादन करेगा: PackageName.1.0.0-pre20180807-1711.nupkg ।

MSBuild संपत्ति कार्यों के बारे में अधिक जानकारी: https://docs.microsoft.com/en-us/visualstudio/msbuild/property-functions

Versionके संयोजन से बना है VersionPrefixऔर VersionSuffix, या यदि VersionSuffixखाली है, VersionPrefixकेवल।

<PropertyGroup>
  <VersionPrefix>1.0.0</VersionPrefix>
</PropertyGroup>
— फैब्रिकियो गोडॉय
स्रोत
यह वास्तव में आसान है
— जेरी निक्सन
12

मैंने उपरोक्त उत्तर स्वीकार कर लिया क्योंकि @ गीगी सही है (अब के रूप में) लेकिन मैं नाराज था और निम्नलिखित PowerShell लिपियों के साथ आया था।

पहले मेरे पास मेरे सॉल्यूशन फोल्डर की स्क्रिप्ट है (UpdateBuildVersion.ps1):

#Get Path to csproj
$path = "$PSScriptRoot\src\ProjectFolder\ProjectName.csproj"

#Read csproj (XML)
$xml = [xml](Get-Content $path)

#Retrieve Version Nodes
$assemblyVersion = $xml.Project.PropertyGroup.AssemblyVersion
$fileVersion = $xml.Project.PropertyGroup.FileVersion

#Split the Version Numbers
$avMajor, $avMinor, $avBuild  = $assemblyVersion.Split(".")
$fvMajor, $fvMinor, $fvBuild = $fileVersion.Split(".")

#Increment Revision
$avBuild = [Convert]::ToInt32($avBuild,10)+1
$fvBuild = [Convert]::ToInt32($fvBuild,10)+1

#Put new version back into csproj (XML)
$xml.Project.PropertyGroup.AssemblyVersion = "$avMajor.$avMinor.$avBuild"
$xml.Project.PropertyGroup.FileVersion = "$fvMajor.$fvMinor.$fvBuild"

#Save csproj (XML)
$xml.Save($path)

मैंने इसे csproj फ़ाइल में जोड़ा:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <AssemblyVersion>0.0.1</AssemblyVersion>
    <FileVersion>0.0.1</FileVersion>
    <PreBuildEvent>powershell.exe –NonInteractive –ExecutionPolicy Unrestricted -command "& {$(SolutionDir)UpdateBuildVersion.ps1}"</PreBuildEvent>
  </PropertyGroup>
</Project>

यहां तक ​​कि इसके सेट के माध्यम से एक PreBuildEvent होने के बावजूद, तथ्य यह है कि संस्करण संख्याओं को तब तक अपडेट नहीं किया जाता है जब तक कि फ़ाइल को मेमोरी में लोड नहीं किया गया है ताकि संस्करण संख्या अगले बिल्ड तक प्रतिबिंबित न हो। वास्तव में, आप इसे PostBuildEvent में बदल सकते हैं और इसका समान प्रभाव होगा।

मैंने निम्नलिखित दो स्क्रिप्ट भी बनाई: (UpdateMinorVersion.ps1)

#Get Path to csproj
$path = "$PSScriptRoot\src\ProjectFolder\ProjectName.csproj"

#Read csproj (XML)
$xml = [xml](Get-Content $path)

#Retrieve Version Nodes
$assemblyVersion = $xml.Project.PropertyGroup.AssemblyVersion
$fileVersion = $xml.Project.PropertyGroup.FileVersion

#Split the Version Numbers
$avMajor, $avMinor, $avBuild  = $assemblyVersion.Split(".")
$fvMajor, $fvMinor, $fvBuild = $fileVersion.Split(".")

#Increment Minor Version - Will reset all sub nodes
$avMinor = [Convert]::ToInt32($avMinor,10)+1
$fvMinor = [Convert]::ToInt32($fvMinor,10)+1
$avBuild = 0
$fvBuild = 0

#Put new version back into csproj (XML)
$xml.Project.PropertyGroup.AssemblyVersion = "$avMajor.$avMinor.$avBuild"
$xml.Project.PropertyGroup.FileVersion = "$fvMajor.$fvMinor.$fvBuild"

#Save csproj (XML)
$xml.Save($path)

(UpdateMajorVersion.ps1)

#Get Path to csproj
$path = "$PSScriptRoot\src\ProjectFolder\ProjectName.csproj"

#Read csproj (XML)
$xml = [xml](Get-Content $path)

#Retrieve Version Nodes
$assemblyVersion = $xml.Project.PropertyGroup.AssemblyVersion
$fileVersion = $xml.Project.PropertyGroup.FileVersion

#Split the Version Numbers
$avMajor, $avMinor, $avBuild  = $assemblyVersion.Split(".")
$fvMajor, $fvMinor, $fvBuild = $fileVersion.Split(".")

#Increment Major Version - Will reset all sub nodes
$avMajor = [Convert]::ToInt32($avMajor,10)+1
$fvMajor = [Convert]::ToInt32($fvMajor,10)+1
$avMinor = 0
$fvMinor = 0
$avBuild = 0
$fvBuild = 0

#Put new version back into csproj (XML)
$xml.Project.PropertyGroup.AssemblyVersion = "$avMajor.$avMinor.$avBuild"
$xml.Project.PropertyGroup.FileVersion = "$fvMajor.$fvMinor.$fvBuild"

#Save csproj (XML)
$xml.Save($path)
— जेसन एच
स्रोत
10

डॉटनेट बिल्ड /p:AssemblyVersion=1.2.3.4

मैं जवाब दे रहा था: "किसी को भी पता लगा है कि .NET कोर (या उस मामले के लिए .NET मानक) में संस्करण को कैसे नियंत्रित किया जाए।" मैंने इस प्रश्न को CI बिल्ड के संदर्भ में इस समस्या को हल करने का प्रयास किया। मैं CI संस्करण संख्या के लिए विधानसभा संस्करण सेट करना चाहता था।

— क्रिस मैकेंजी
स्रोत
1
शीर्षक "दृश्य स्टूडियो 2017 (.NET कोर) में ऑटो संस्करण" कहता है। जहां वास्तव में इसका निर्माण मैन्युअल रूप से "विज़ुअल स्टूडियो 2017" का अनुपालन करता है?
— JCKödel
4
मैं जवाब दे रहा था: "किसी को भी पता लगा है कि .NET कोर (या उस मामले के लिए .NET मानक) में संस्करण को कैसे नियंत्रित किया जाए।" मैंने इस प्रश्न को CI बिल्ड के संदर्भ में इस समस्या को हल करने का प्रयास किया। मैं CI संस्करण संख्या के लिए विधानसभा संस्करण सेट करना चाहता था। मुझे खेद है कि अगर आपको लगता है कि यह सवाल पर प्रासंगिक नहीं था।
— क्रिस मैकेंजी
यह मेरे लिए एक सहायक घटक है धन्यवाद। मैं इसे एक सीआई समाधान के भाग के रूप में उपयोग करूंगा
— मार्क एडमसन
1
@ChrisMcKenzie: आपकी टिप्पणी आपके इरादे को स्पष्ट करने के लिए आपके जवाब में शामिल होनी चाहिए
— माइकल फ्रीजिम
** असेंबली प्रोजेक्ट्स पर यह मेरे लिए काम नहीं करता है जब असेंबली एफ.ओ.सी. निर्दिष्ट नहीं होता है और संस्करण csproj में होता है ...
— tofutim
9

ये मान अब .csprojफ़ाइल में सेट किए गए हैं:

<PropertyGroup>
    <TargetFramework>netcoreapp1.1</TargetFramework>
    <AssemblyVersion>1.0.6.0</AssemblyVersion>
    <FileVersion>1.0.6.0</FileVersion>
    <Version>1.0.1</Version>
</PropertyGroup>

ये वही मान हैं जिन्हें आप प्रोजेक्ट सेटिंग्स में पैकेज टैब पर जाते हैं। जब तक मुझे नहीं लगता कि आप *संस्करण को ऑटोइन्क्रिमेंट करने के लिए उपयोग कर सकते हैं , तो आप जो कर सकते हैं वह एक पोस्ट-प्रोसेसिंग कदम है जो आपके लिए संस्करणों को बदलता है (जैसे आपके निरंतर एकीकरण के भाग के रूप में)।

— गीगी
स्रोत
6
मुझे डर था कि यह जवाब होगा। मैं देखूंगा कि क्या मैं इसे बढ़ाने के लिए एक पूर्व-निर्मित कदम कर सकता हूं।
— जेसन एच
3
जैसा कि एक और सूत्र में बताया गया है, नया csproj प्रारूप आपको असेंबली-फाई फाइल के ऑटो-जनरेशन को बंद करने की अनुमति देता है और आपके लिए खुद को निर्दिष्ट करने के लिए। मैंने यहाँ natemcmaster के उत्तर की सलाह का पालन किया और एक मानक असेम्बलीInfo.cs फ़ाइल का उपयोग किया: stackoverflow.com/questions/42138418/…
— जेम्स एबी
5
उन्होंने ऑटो-इंक्रीमेंट क्यों हटाया? यह वास्तव में अच्छी तरह से और बहुत ही सरलता से मेरे लिए वर्षों तक काम किया। मैं मास्टर को धक्का देता हूं, CI बनाता है और वेतन वृद्धि करता है, फिर संस्करण को सीधे कुछ DL स्क्रिप्ट का उपयोग करके अंतर्निहित DLL से पढ़ा जाता है, फिर NuGet पर धकेलने पर उस संस्करण को एक arg के रूप में उपयोग करें। बहुत आसन। अब टूट गया।
— ल्यूक पुप्लेट
1
@LukePuplett यहाँ भी। कितना निराशाजनक!
— शिमी वेइटहैंडलर
@LukePuplett: देखें ["असेंबली में वाइल्डकार्ड के लिए भ्रामक त्रुटि संदेश। नेट कोर # 22660"] ( github.com/dotnet/roslyn/issues/22660 ), वे कारण जिन्हें वे इनस्टॉलिस्टिक बिल्ड्स के ब्लॉग में वर्णित लाभकारी मानते हैं। /
— 2016/04/05
5

मैंने यहाँ .csproj .NET कोर वर्जन स्ट्रिंग्स की स्थापना के लिए एक सरल सीएलआई टूल बनाया । आप सीआई बिल्ड के दौरान ऑटोमैटिक वर्जन बंपिंग के लिए GitVersion जैसे टूल के साथ इसे जोड़ सकते हैं, यदि आप इसके बाद हैं।

— Tagc
स्रोत
@ जेसन धन्यवाद, मुझे बताएं कि क्या आपके पास इसके साथ कोई समस्या है।
— टैग
भगवान की प्रतिभा। इसे प्यार करना!
— pms1969
4

अपने .net Core / .net के संस्करण को सक्षम करने के लिए GIT सेटअप के आधार पर जो भी प्रोजेक्ट है, वह GIT के टैग / कार्यक्षमता का वर्णन करता है।

मैं एक Prebuild.targets.xml फ़ाइल का उपयोग कर रहा हूं, जो परियोजना के लिए रूट फ़ोल्डर में स्थित है और जैसे csproj फ़ाइल में शामिल है:

<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="PreBuild.targets.xml" />
  ...
  <PropertyGroup>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>

स्वत: असेंबली जानकारी पीढ़ी को अक्षम करने के लिए "GenerateAssembyInfo" टैग का उपयोग करें।

फिर Prebuild.targets.xml एक CommonAssemblyInfo.cs फ़ाइल उत्पन्न करेगा जहाँ आप अपने GIT संस्करण के आधार पर अपने इच्छित संस्करण टैग शामिल कर सकते हैं

ध्यान दें: मैंने Prebuilds.targets.xml को कहीं और पाया है, इसलिए havent ने इसे साफ करने में परेशान किया है।)

Prebuild.targets.xml फ़ाइल:

    <?xml version="1.0" encoding="utf-8" ?>
    <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

      <UsingTask
        TaskName="GetVersion"
        TaskFactory="CodeTaskFactory"
        AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
        <ParameterGroup>
          <VersionString ParameterType="System.String" Required="true" />
          <Version ParameterType="System.String" Output="true" />
          <Commit ParameterType="System.String" Output="true" />
          <VersionSuffix ParameterType="System.String" Output="true" />
        </ParameterGroup>
        <Task>
          <!--<Reference Include="" />-->
          <Using Namespace="System"/>
          <Using Namespace="System.IO"/>
          <Using Namespace="System.Text.RegularExpressions" />
          <Code Type="Fragment" Language="cs">
            <![CDATA[
              var match = Regex.Match(VersionString, @"^(?<major>\d+)\.(?<minor>\d+)(\.?(?<patch>\d+))?-(?<revision>\d+)-(?<commit>[a-z0-9-]+)$");
              int major, minor, patch, revision;
              Int32.TryParse(match.Groups["major"].Value, out major);
              Int32.TryParse(match.Groups["minor"].Value, out minor);
              Int32.TryParse(match.Groups["patch"].Value, out patch);
              Int32.TryParse(match.Groups["revision"].Value, out revision);
              _Version = new Version(major, minor, patch, revision).ToString();
              _Commit = match.Groups["commit"].Value;
            ]]>
          </Code>
        </Task>
      </UsingTask>

      <UsingTask
        TaskName="GitExistsInPath"
        TaskFactory="CodeTaskFactory"
        AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
        <ParameterGroup>
          <Exists ParameterType="System.Boolean" Output="true" />
        </ParameterGroup>
        <Task>
          <!--<Reference Include="" />-->
          <Using Namespace="System"/>
          <Using Namespace="System.IO"/>
          <Using Namespace="System.Text.RegularExpressions" />
          <Code Type="Fragment" Language="cs">
            <![CDATA[
            var values = Environment.GetEnvironmentVariable("PATH");
            foreach (var path in values.Split(';')) {
                var exeFullPath = Path.Combine(path, "git.exe");
                if (File.Exists(exeFullPath)) {
                    Exists = true;
                    return true;
                }
                var cmdFullPath = Path.Combine(path, "git.cmd");
                if (File.Exists(cmdFullPath)) {
                    Exists = true;
                    return true;
            }
            }
            Exists = false;
            ]]>
          </Code>
        </Task>
      </UsingTask>

      <Target Name="CreateCommonVersionInfo" BeforeTargets="CoreCompile">
        <Message Importance="high" Text="CreateCommonVersionInfo" />

        <GitExistsInPath>
          <Output TaskParameter="Exists" PropertyName="GitExists"/>
        </GitExistsInPath>
        <Message Importance="High" Text="git not found!" Condition="!$(GitExists)"/>

        <Exec Command="git describe --tags --long --dirty > $(ProjectDir)version.txt" Outputs="$(ProjectDir)version.txt" WorkingDirectory="$(SolutionDir)" IgnoreExitCode="true" Condition="$(GitExists)">
          <Output TaskParameter="ExitCode" PropertyName="ExitCode" />
        </Exec>
        <Message Importance="high" Text="Calling git failed with exit code $(ExitCode)" Condition="$(GitExists) And '$(ExitCode)'!='0'" />

        <ReadLinesFromFile File="$(ProjectDir)version.txt" Condition="$(GitExists) And '$(ExitCode)'=='0'">
          <Output TaskParameter="Lines" ItemName="OutputLines"/>
        </ReadLinesFromFile>
        <Message Importance="High" Text="Tags: @(OutputLines)" Condition="$(GitExists) And '$(ExitCode)'=='0'"/>

        <Delete Condition="Exists('$(ProjectDir)version.txt')" Files="$(ProjectDir)version.txt"/>

        <GetVersion VersionString="@(OutputLines)" Condition="$(GitExists) And '$(ExitCode)'=='0'">
          <Output TaskParameter="Version" PropertyName="VersionString"/>
          <Output TaskParameter="Commit" PropertyName="Commit"/>
        </GetVersion>

        <PropertyGroup>
          <VersionString Condition="'$(VersionString)'==''">0.0.0.0</VersionString>
        </PropertyGroup>

        <Message Importance="High" Text="Creating CommonVersionInfo.cs with version $(VersionString) $(Commit)" />

        <WriteLinesToFile Overwrite="true" File="$(ProjectDir)CommonAssemblyInfo.cs" Encoding="UTF-8" Lines='using System.Reflection%3B

    // full version: $(VersionString)-$(Commit)

    [assembly: AssemblyVersion("$(VersionString)")]
    [assembly: AssemblyInformationalVersion("$(VersionString)")] 
    [assembly: AssemblyFileVersion("$(VersionString)")]' />

      </Target>
    </Project>

संपादित करें: यदि आप MSBUILD का उपयोग कर निर्माण कर रहे हैं 

 $(SolutionDir)

आपको परेशानी का कारण हो सकता है, उपयोग करें

 $(ProjectDir)

बजाय

— Tue Skeltved
स्रोत
अच्छा! क्या VersionSuffix का अंत सेट या उपयोग हो रहा है? यह प्रतीत नहीं होता है
— मार्क एडम्सन
4

आप नीचे, csproj फ़ाइल में कर सकते हैं। मैंने गणित का पता नहीं लगाया। मैंने पाया कि स्टैकओवरफ्लो पर कहीं और। लेकिन यह काम करता है और आपको संस्करण के लिए 1.0 से कुछ के अनुरूप होगा।

<PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <FileVersion>1.0.$([System.DateTime]::UtcNow.Date.Subtract($([System.DateTime]::Parse("2000-01-01"))).TotalDays).$([System.Math]::Floor($([MSBuild]::Divide($([System.DateTime]::UtcNow.TimeOfDay.TotalSeconds), 1.32))))</FileVersion>
    <Version>1.0.$([System.DateTime]::UtcNow.Date.Subtract($([System.DateTime]::Parse("2000-01-01"))).TotalDays)</Version>
</PropertyGroup>
— Clarke76
स्रोत
3

Visual Studio के लिए स्वचालित संस्करण एक्सटेंशन अब .Net कोर और .Net मानक को एक साधारण उपयोगकर्ता इंटरफ़ेस में ऑटोइन्क्रिमेंटिंग का समर्थन करता है।

https://marketplace.visualstudio.com/items?itemName=PrecisionInfinity.AutomaticVersions

— madamission
स्रोत
1
मैंने डेमो सॉल्यूशन (विंडोज़ ऐप) के साथ एक त्वरित परीक्षण किया है और यह .net मानक परियोजना के साथ भी काम करता है। यह एक त्वरित परीक्षण था ताकि अगर हम चाहते हैं कि सब कुछ जांचने के लिए गहराई से गोता लगाना पड़े। लेकिन आपको यकीन है कि यह एक कोशिश कर सकता है।
— ArieKanarie
3

मुझे सही दिशा में इशारा करने के लिए @joelsand का धन्यवाद।

मुझे अपना उत्तर थोड़ा बदलना पड़ा, जब DevOps Build चला, मुझे निम्नलिखित अपवाद मिला 

The specified version string does not conform to the recommended format - major.minor.build.revision

मुझे प्रमुख .minor.build अनुभाग के अंत में $ (BUILD_BUILDNUMBER) जोड़ना पड़ा। वास्तविक संस्करण को डी-डुप्लिकेट करने के लिए, मैं एक संस्करण-उपसर्ग का भी उपयोग करता हूं:

<PropertyGroup>
    <VersionPrefix>1.0.3</VersionPrefix>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' == '' ">$(VersionPrefix)-local</Version>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' != '' ">$(VersionPrefix)-$(BUILD_BUILDNUMBER)</Version>
</PropertyGroup>
— स्टु हार्पर
स्रोत
मुझे वही सटीक समस्या थी और आपके उत्तर ने इसे ठीक कर दिया। धन्यवाद।
— मीटिंग अटेंडर
2

हम के लिए विशेष पैरामीटर का उपयोग कर सकते हैं dotnet publish -- version-suffix 1.2.3

फ़ाइल संस्करण के लिए:

<AssemblyVersion Condition=" '$(VersionSuffix)' == '' ">0.0.1.0</AssemblyVersion>
<AssemblyVersion Condition=" '$(VersionSuffix)' != '' ">$(VersionSuffix)</AssemblyVersion>

संस्करण के लिए:

<Version Condition=" '$(VersionSuffix)' == '' ">0.0.1</Version>
<Version Condition=" '$(VersionSuffix)' != '' ">$(VersionSuffix)</Version>

https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-publish?tabs=netcore21

--version-suffix <VERSION_SUFFIX>     Defines the value for the $(VersionSuffix) property in the project.
— अनातोली कलेमर
स्रोत
1

मुझे लगता है कि @joelsand का यह उत्तर VSTS पर चलने वाले डॉटनेट कोर के लिए संस्करण संख्या निर्धारित करने के लिए सही उत्तर है

इस उत्तर के लिए और जानकारी जोड़ने के लिए,

BUILD_BUILDNUMBERवास्तव में एक पूर्वनिर्धारित चर है ।

यह पता चला है कि पूर्वनिर्धारित चर के 2 संस्करण हैं।

एक build.xxxx है, दूसरा BUILD_XXXX है।

आप केवल Environment Variable Namecproj में उपयोग कर सकते हैं ।

— maxisam
स्रोत
build.xxxxपाइपलाइन के भीतर संदर्भित करने के लिए सामने के छोर पर उपयोग नहीं किया जाता BUILD_XXXXहै और समान मूल्य है लेकिन PS में चर को संदर्भित करने के लिए थोड़ा संशोधित सिंटैक्स आवश्यक है?
— dst3p
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.