Ik heb het grootste deel van een paar uur besteed aan het zoeken naar een manier om versies automatisch te verhogen in een .NETCoreApp 1.1 (Visual Studio 2017).
Ik weet dat de AssemblyInfo.cs dynamisch wordt aangemaakt in de map: obj/Debug/netcoreapp1.1/
Het accepteert niet de oude methode van:
[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.*")]
Als ik het project op package instel, kan ik daar versies instellen, maar dit lijkt te worden gebruikt om het bestand AssemblyInfo.cs te bouwen.
Mijn vraag is, heeft iemand ontdekt hoe je de versie in .NET Core (of .NETStandard) projecten kunt beheren.
Antwoord 1, autoriteit 100%
Voeg <Deterministic>False</Deterministic>toe in een <PropertyGroup>sectie van .csproj
De oplossing om AssemblyVersion * te laten werken, wordt beschreven in “Verwarrende foutmelding voor wildcard in [AssemblyVersion] op .Net Core#22660”
Wildcards zijn alleen toegestaan als de build niet deterministisch is, wat:
is de standaard voor .Net Core-projecten.
Het toevoegen van<Deterministic>False</Deterministic>aan csproj lost de
probleem.
De redenen waarom .Net Core-ontwikkelaars Deterministic Builds als gunstig beschouwen, beschreven in http://blog.paranoidcoding.com/2016/04/05/deterministic-builds-in-roslyn.html
en Compilers moeten deterministisch zijn: dezelfde invoer genereert dezelfde uitvoer #372
Als u echter TeamCity, TFS of een andere CI/CD-tool gebruikt, is het waarschijnlijk beter om het versienummer onder controle te houden en door hen te verhogen en door te geven om als parameter te bouwen (zoals in andere antwoorden werd gesuggereerd), b.v.
msbuild /t:build /p:Version=YourVersionNumber /p:AssemblyVersion=YourVersionNumber
Pakketnummer voor NuGet-pakketten
msbuild /t:pack /p:Version=YourVersionNumber
Antwoord 2, autoriteit 84%
Als u Visual Studio Team Services/TFS of een ander CI-buildproces gebruikt om versiebeheer ingebouwd te hebben, kunt u het kenmerk Conditionvan msbuild gebruiken, bijvoorbeeld:
<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>
Dit vertelt de .NET Core-compiler om te gebruiken wat zich in de omgevingsvariabele BUILD_BUILDNUMBERbevindt, als deze aanwezig is, of terug te vallen op 0.0.1-localals je een build doen op uw lokale computer.
Antwoord 3, autoriteit 35%
Ik ben op zoek geweest naar een versie-incrementer voor een .NET Core-app in VS2017 met behulp van de csproj-configuratie-indeling.
Ik vond een project met de naam dotnet bump dat werkte voor het project.json-formaat, maar moeite had om een oplossing te vinden voor het .csproj-formaat. De schrijver van dotnet bump kwam met de oplossing voor het .csproj-formaat en het heet MSBump.
Er is een project op GitHub voor op:
https://github.com/BalassaMarton/MSBump
waar je de code kunt zien en deze is ook beschikbaar op NuGet. Zoek gewoon naar MSBump op Nuget.
Antwoord 4, autoriteit 23%
U kunt een MSBuild-eigenschapsfunctie gebruiken om het versieachtervoegsel in te stellen op basis van de huidige datum:
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<VersionSuffix>pre$([System.DateTime]::UtcNow.ToString(yyyyMMdd-HHmm))</VersionSuffix>
</PropertyGroup>
Hiermee wordt een pakket uitgevoerd met een naam als: PackageName.1.0.0-pre20180807-1711.nupkg.
Meer details over MSBuild-eigenschapsfuncties: https://docs. microsoft.com/en-us/visualstudio/msbuild/property-functions
De Versionwordt gevormd door de combinatie van VersionPrefixen VersionSuffix, of als VersionSuffixleeg is, VersionPrefixalleen.
<PropertyGroup>
<VersionPrefix>1.0.0</VersionPrefix>
</PropertyGroup>
Antwoord 5, autoriteit 21%
Ik kwam met een oplossing die bijna hetzelfde werkte als het oude AssemblyVersion-kenmerk met ster (*) – AssemblyVersion(“1.0.*”)
Waarden voor AssemblyVersionen AssemblyFileVersionbevinden zich in het .csproj-bestand van het MSBuild-project (niet in AssemblyInfo.cs) als eigenschap FileVersion(genereert AssemblyFileVersionAttribute) en AssemblyVersion(genereert AssemblyVersionAttribute).
In het MSBuild-proces gebruiken we onze aangepaste MSBuild-taak om versienummers te genereren en dan overschrijven we de waarden van deze FileVersionen AssemblyVersioneigenschappen met nieuwe waarden van de taak.
Dus eerst maken we onze aangepaste MSBuild-taak 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();
}
}
Taakklasse erven van Microsoft.Build.Utilities.Taskklasse van Microsoft.Build.Utilities.CoreNuGet-pakket.
Het neemt de eigenschap BaseVersion (optioneel) op invoer en retourneert de gegenereerde versie in de eigenschap Version output. De logica om versienummers te krijgen is hetzelfde als .NET automatische versiebeheer (Build-nummer is het aantal dagen sinds 1/1/2000 en Revisie is een halve seconde sinds middernacht).
Om deze MSBuild-taak te bouwen, gebruiken we het .NET Standard 1.3 klassenbibliotheekprojecttype met deze klasse.
.csproj-bestand kan er als volgt uitzien:
<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>
Dit taakproject is ook beschikbaar in mijn GitHub holajan/DC.Build.Tasks
Nu hebben we MSBuild ingesteld om deze taak te gebruiken en de eigenschappen FileVersionen AssemblyVersionin te stellen.
In het .csproj-bestand ziet het er als volgt uit:
<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>
Belangrijke dingen hier:
- Vermelde UsingTaskimporteert de GetCurrentBuildVersion-taak uit DC.Build.Tasks.dll. Het gaat ervan uit dat dit dll-bestand zich in de bovenliggende map van uw .csproj-bestand bevindt.
- Ons BeforeBuildActionsProject1Doel dat de taak aanroept, moet een unieke naam per project hebben voor het geval we meer projecten in de oplossing hebben die de GetCurrentBuildVersion-taak aanroepen.
Het voordeel van deze oplossing is dat het niet alleen werkt vanaf builds op build-server, maar ook in handmatige builds van dotnet buildof Visual Studio.
Antwoord 6, autoriteit 19%
Ik accepteerde het bovenstaande antwoord omdat @Gigi gelijk heeft (vanaf nu), maar ik was geïrriteerd en kwam met de volgende PowerShell-scripts.
Eerst heb ik het script in mijn oplossingsmap (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)
Ik heb dit toegevoegd aan het csproj-bestand:
<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>
Zelfs al is het ingesteld als een PreBuildEvent, het feit is dat de versienummers pas worden bijgewerkt NADAT het bestand in het geheugen is geladen, zodat het versienummer pas bij de volgende build wordt weergegeven. Je zou het zelfs kunnen veranderen in een PostBuildEvent en het zou hetzelfde effect hebben.
Ik heb ook de volgende twee scripts gemaakt:
(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)
Antwoord 7, autoriteit 14%
Deze waarden zijn nu ingesteld in het bestand .csproj:
<PropertyGroup>
<TargetFramework>netcoreapp1.1</TargetFramework>
<AssemblyVersion>1.0.6.0</AssemblyVersion>
<FileVersion>1.0.6.0</FileVersion>
<Version>1.0.1</Version>
</PropertyGroup>
Dit zijn dezelfde waarden die u ziet als u naar het tabblad Pakketgaat in de projectinstellingen. Hoewel ik denk dat je *niet kunt gebruiken om de versie automatisch te verhogen, kun je wel een nabewerkingsstap introduceren die de versies voor je vervangt (bijvoorbeeld als onderdeel van je continue integratie).
Antwoord 8, autoriteit 13%
U kunt het als volgt doen, in het csproj-bestand. Ik heb de wiskunde niet door. Ik vond dat ergens anders op Stack Overflow, maar dit werkt en geeft je iets vergelijkbaars met 1.0.* voor versie.
<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>
Antwoord 9, autoriteit 13%
heeft iemand ontdekt hoe je de versie in .NET Core (of .NETStandard) projecten kunt beheren.
Gebruik:
dotnet build /p:AssemblyVersion=1.2.3.4
Ik vond deze vraag om dit probleem op te lossen in de context van een CI-build. Ik wilde de assembly-versie instellen op het CI-buildnummer.
Antwoord 10, autoriteit 8%
Ik heb hiereen eenvoudige CLI-tool gemaakt om .csproj .NET Core-versiestrings in te stellen. Je kunt het combineren met tools zoals GitVersion voor automatische versie-bumping tijdens CI-builds, als dat is wat je zoekt.
Antwoord 11, autoriteit 8%
Dank aan @joelsand voor het wijzen in de goede richting.
Ik moest zijn antwoord enigszins wijzigen, want toen de DevOps Build werd uitgevoerd, kreeg ik de volgende uitzondering
De opgegeven versietekenreeks komt niet overeen met het aanbevolen formaat – major.minor.build.revision
Ik moest de $(BUILD_BUILDNUMBER) toevoegen aan het einde van de sectie major.minor.build. Om de daadwerkelijke versie te dedupliceren, gebruik ik ook een versie-prefix:
<PropertyGroup>
<VersionPrefix>1.0.3</VersionPrefix>
<Version Condition=" '$(BUILD_BUILDNUMBER)' == '' ">$(VersionPrefix)-local</Version>
<Version Condition=" '$(BUILD_BUILDNUMBER)' != '' ">$(VersionPrefix)-$(BUILD_BUILDNUMBER)</Version>
</PropertyGroup>
Antwoord 12, autoriteit 8%
Om alles hierboven samen te vatten: je kunt terugkeren naar het oude AssemblyInfo.cs-gedrag met dit:
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
<Deterministic>false</Deterministic>
Maar deze aanpak wordt niet aanbevolen, omdat het uitschakelen van GenerateAssemblyInfokan leiden tot problemen met infra, bijvoorbeeld.
Selectievere aanpak:
<Deterministic>false</Deterministic>
<GenerateAssemblyFileVersionAttribute>false</GenerateAssemblyFileVersionAttribute>
<GenerateAssemblyInformationalVersionAttribute>false</GenerateAssemblyInformationalVersionAttribute>
<AssemblyVersion>1.2.*</AssemblyVersion>
en je hebt AssemblyInfo.csniet meer nodig.
Antwoord 13, autoriteit 5%
Om versiebeheer van uw .NET Core / .NET Welk project dan ook mogelijk te maken op basis van uw GIT-configuratie, met behulp van de tags/describe-functionaliteit van GIT.
Ik heb een Prebuild.targets.xml-bestand gebruikt dat zich in de hoofdmap van het project bevindt en is opgenomen in het csproj-bestand, zoals:
<Project Sdk="Microsoft.NET.Sdk">
<Import Project="PreBuild.targets.xml" />
...
<PropertyGroup>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
Gebruik de tag “GenerateAssembyInfo” om het automatisch genereren van assemblagegegevens uit te schakelen.
Vervolgens genereert Prebuild.targets.xml een CommonAssemblyInfo.cs-bestand waarin u de gewenste versietags kunt opnemen op basis van uw GIT-versie
OPMERKING: ik heb de Prebuilds.targets.xml ergens anders gevonden, dus ik heb niet de moeite genomen om het op te ruimen.)
Het Prebuild.targets.xml-bestand:
<?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>
EDIT: als je bouwt met MSBUILD, is de
$(SolutionDir)
Dit kan problemen veroorzaken, gebruik
$(ProjectDir)
in plaats daarvan
Antwoord 14, autoriteit 3%
We kunnen een speciale parameter gebruiken voor dotnet publish -- version-suffix 1.2.3
Voor bestandsversie:
<AssemblyVersion Condition=" '$(VersionSuffix)' == '' ">0.0.1.0</AssemblyVersion>
<AssemblyVersion Condition=" '$(VersionSuffix)' != '' ">$(VersionSuffix)</AssemblyVersion>
Voor versie:
<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.
Antwoord 15, autoriteit 3%
Als alternatief kunt u een vast hoofdnummer proberen met een achtervoegsel op basis van de huidige datum:
<PropertyGroup>
<VersionPrefix>1</VersionPrefix>
<VersionSuffix>$([System.DateTime]::UtcNow.ToString(yyMM)).$([System.DateTime]::UtcNow.ToString(ddHH)).$([System.DateTime]::UtcNow.ToString(mmss))</VersionSuffix>
<Version Condition=" '$(VersionSuffix)' == '' ">$(VersionPrefix).0.0.1</Version>
<Version Condition=" '$(VersionSuffix)' != '' ">$(VersionPrefix).$(VersionSuffix)</Version>
</PropertyGroup>
Antwoord 16, autoriteit 3%
<PropertyGroup>
<SecondsSinceEpoch>$([System.DateTime]::UtcNow.Subtract($([System.DateTime]::MinValue)).TotalSeconds)</SecondsSinceEpoch>
<Revision>$([System.Math]::Truncate($([System.Decimal]::Remainder($(SecondsSinceEpoch), 100000))))</Revision>
<Version>1.7.0.$(Revision)</Version>
<AssemblyVersion>$(Version)</AssemblyVersion>
<FileVersion>$(Version)</FileVersion>
</PropertyGroup>
Mijn mening over het instellen van een behoorlijke waarde via .csproj. Helaas, als uw volgende herbouw een interval van 100000seconden later is, zal het dezelfde waarde zijn. Beter dan MSBumpwaardoor elke Buildeen Rebouwenechter.
Kan TotalMinutes, TotalDays, enz. gebruiken bij langzame of geautomatiseerde builds.
Antwoord 17
Ik denk dat dit Antwoordvan @joelsand het juiste antwoord is voor het instellen van het versienummer voor dotnet core die op VSTS draait
Als u meer informatie voor dit antwoord wilt toevoegen,
BUILD_BUILDNUMBERis eigenlijk een voorgedefinieerde variabele.
Het blijkt dat er 2 versies van voorgedefinieerde variabelen zijn.
De ene is build.xxxx, de andere is BUILD_XXXX.
U kunt alleen Environment Variable Namegebruiken in cproj.
Antwoord 18
Wat voor mij werkte, was om Patch en Revision te definiëren met behulp van een PropertyGroup, dan kun je deze variabelen gewoon gebruiken voor versie (en prefix indien nodig). Versienummers moeten korte nummers zijn, dus ik gebruik YearMonth voor Patch en MinutesOfDay voor Revisie. Voeg deze regels toe aan je csproj-bestand:
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<VersionMajor>0</VersionMajor>
<VersionMinor>9</VersionMinor>
<VersionPatch Condition="'$(VersionPatch)' == ''">$([System.DateTime]::UtcNow.ToString("yyMM"))</VersionPatch>
<VersionRevision Condition="'$(VersionRevision)' == ''">$([System.DateTime]::UtcNow.TimeOfDay.TotalMinutes.ToString("0"))</VersionRevision>
</PropertyGroup>
<PropertyGroup>
<OutputType>...</OutputType>
<TargetFramework>net5.0</TargetFramework>
<Title>Software Title</Title>
<Description>...</Description>
<Authors>...</Authors>
<Version>$(VersionMajor).$(VersionMinor).$(VersionPatch).$(VersionRevision)</Version>
</PropertyGroup>
....
</Project>
Het kan op een generieke manier worden bereikt door gebruik te maken van het bestand Directory.build.props. Meer info hier: https:// docs.microsoft.com/en-us/visualstudio/msbuild/customize-your-build?view=vs-2019
Voeg gewoon een bestand met deze naam toe aan de projectmap en plaats daar deze regels.
Ik kwam hier op zoek naar een oplossing voor gedeelde projecten. In mijn geval heb ik het opgelost door een bestand Version.build.propstoe te voegen in mijn gedeelde project met de hierboven getoonde structuur, en slechts één nieuwe regel in elk csproj-bestand voor projecten die mijn gedeelde code gebruiken:
<!-- Shared project import -->
<Import Project="..\Shared\Shared.projitems" Label="Shared" />
<!-- Version number generator -->
<Import Project="$([MSBuild]::GetPathOfFileAbove('Version.Build.props', '$(MSBuildThisFileDirectory)../Shared/'))" />
Ik zal deze code hier achterlaten voor het geval iemand hem nodig heeft.
*Oplossing getest voor .Net5 maar zou moeten werken voor eerdere versies.
Antwoord 19
Mijn OSS-project “RelaxVersioner”kan volledig automatisch worden ingevoegd met de attributen en constante literals aan git repository alleen NuGet-pakket geïnstalleerd zonder enige tool-afhankelijke bewerking.
Voorbeeld voor toegepaste informatie:
sing System.Reflection;
[assembly: AssemblyVersion("1.0.21")]
[assembly: AssemblyFileVersion("2020.12.20.33529")]
[assembly: AssemblyInformationalVersion("1.0.21-561387e2f6dc90046f56ef4c3ac501aad0d5ec0a")]
[assembly: AssemblyMetadata("Date","Sun, 20 Dec 2020 09:37:39 GMT")]
[assembly: AssemblyMetadata("Branch","master")]
[assembly: AssemblyMetadata("Tags","")]
[assembly: AssemblyMetadata("Author","Kouji Matsui <[email protected]>")]
[assembly: AssemblyMetadata("Committer","Kouji Matsui <[email protected]>")]
[assembly: AssemblyMetadata("Message","Merge branch 'devel'")]
[assembly: AssemblyMetadata("Build","")]
[assembly: AssemblyMetadata("Generated","Sun, 20 Dec 2020 09:37:43 GMT")]
[assembly: AssemblyMetadata("Platform","AnyCPU")]
[assembly: AssemblyMetadata("BuildOn","Unix")]
[assembly: AssemblyMetadata("SdkVersion","5.0.101")]
namespace YourApp
{
internal static class ThisAssembly
{
public const string AssemblyVersion = "1.0.21";
public const string AssemblyFileVersion = "2020.12.20.33529";
public const string AssemblyInformationalVersion = "1.0.21-561387e2f6dc90046f56ef4c3ac501aad0d5ec0a";
public static class AssemblyMetadata
{
public const string Date = "Sun, 20 Dec 2020 09:37:39 GMT";
public const string Branch = "master";
public const string Tags = "";
public const string Author = "Kouji Matsui <[email protected]>";
public const string Committer = "Kouji Matsui <[email protected]>";
public const string Message = "Merge branch 'devel'";
public const string Build = "";
public const string Generated = "Sun, 20 Dec 2020 09:37:43 GMT";
public const string Platform = "AnyCPU";
public const string BuildOn = "Unix";
public const string SdkVersion = "5.0.101";
}
}
}