Automatische Versionierung in Visual Studio 2017 (.NET Core)

Ich habe den größten Teil einiger Stunden damit verbracht, einen Weg zu finden, um Versionen in einer .NETCoreApp 1.1 (Visual Studio 2017) automatisch zu inkrementieren.

Ich weiß, dass die AssemblyInfo.cs dynamisch im Ordner erstellt wird: obj/Debug/netcoreapp1.1/

Es akzeptiert nicht die alte Methode von: [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.*")]

Wenn ich das Projekt auf Paket setze, kann ich dort Versionen festlegen, aber dies scheint verwendet zu werden, um die AssemblyInfo.cs-Datei zu erstellen.

Meine Frage ist, hat jemand herausgefunden, wie die Version in .NET Core-Projekten (oder .NETStandard-Projekten) gesteuert werden kann?

Ich habe nach einem Versionsinkrementierer für eine Net Core-App in VS2017 mit dem Konfigurationsformat csproj gesucht.

Ich fand ein Projekt namens Dotnet Bump, das für das Format project.json funktionierte, aber Schwierigkeiten hatte, eine Lösung für das Format .csproj zu finden. Der Autor des Dotnet-Bumps hat tatsächlich die Lösung für das .csproj-Format entwickelt, die als MSBump bezeichnet wird.

Es gibt ein Projekt auf GitHub dafür unter:

https://github.com/BalassaMarton/MSBump

Hier können Sie den Code und seine Verfügbarkeit auch auf Nuget sehen. Suchen Sie einfach auf Nuget nach MSBump.

Fügen Sie <Deterministic>False</Deterministic> innerhalb eines <PropertyGroup>Abschnitts von .csproj hinzu

Die Problemumgehung, damit AssemblyVersion * funktioniert, wird unter „Verwirrende Fehlermeldung für Platzhalter in [AssemblyVersion] auf .Net Core # 22660“ beschrieben.

Platzhalter sind nur zulässig, wenn der Build nicht deterministisch ist. Dies ist die Standardeinstellung für .NET Core-Projekte. Das Hinzufügen  <Deterministic>False</Deterministic> zu csproj behebt das Problem.

Die Gründe, warum .Net Core-Entwickler deterministische Builds für vorteilhaft halten, wie in http://blog.paranoidcoding.com/2016/04/05/deterministic-builds-in-roslyn.html und Compiler beschrieben, sollten deterministisch sein: Dieselben Eingaben erzeugen dieselben Ausgaben # 372

Wenn Sie jedoch TeamCity, TFS oder ein anderes CI / CD-Tool verwenden, ist es wahrscheinlich besser, die Versionsnummer von diesen zu kontrollieren und zu erhöhen und als Parameter zu übergeben (wie in anderen Antworten vorgeschlagen), z

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

Paketnummer für NuGet-Pakete

msbuild /t:pack /p:Version=YourVersionNumber   

Wenn Sie Visual Studio Team Services / TFS oder einen anderen CI-Erstellungsprozess verwenden, um eine integrierte Versionierung zu haben, können Sie das ConditionAttribut von msbuild verwenden , zum Beispiel:

<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>

Dadurch wird der .NET Core-Compiler angewiesen, alle in der BUILD_BUILDNUMBERUmgebungsvariablen enthaltenen Elemente zu verwenden, sofern diese vorhanden sind, oder darauf zurückzugreifen, 0.0.1-localwenn Sie einen Build auf Ihrem lokalen Computer ausführen.

Ich habe eine Lösung gefunden, die fast genauso funktioniert wie das alte AssemblyVersion- Attribut mit star (*) - AssemblyVersion ("1.0. ") *

Die Werte für AssemblyVersion und AssemblyFileVersion befinden sich in der .csproj- Datei des MSBuild-Projekts (nicht in AssemblyInfo.cs ) als Eigenschaft FileVersion (generiert AssemblyFileVersionAttribute ) und AssemblyVersion (generiert AssemblyVersionAttribute ). Im MSBuild-Prozess verwenden wir unsere benutzerdefinierte MSBuild-Task, um Versionsnummern zu generieren, und überschreiben dann die Werte dieser FileVersion- und AssemblyVersion- Eigenschaften mit neuen Werten aus der Task.

Zuerst erstellen wir unsere benutzerdefinierte MSBuild-Aufgabe 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();
    }
}

Die Task-Klasse erbt von der Microsoft.Build.Utilities.Task- Klasse vom Microsoft.Build.Utilities.Core NuGet-Paket. Es übernimmt die BaseVersion-Eigenschaft (optional) für die Eingabe und gibt die generierte Version in der Version-Ausgabeeigenschaft zurück. Die Logik zum Abrufen von Versionsnummern entspricht der automatischen Versionierung von .NET (Build-Nummer ist die Anzahl der Tage seit dem 1.1.2000 und Revision ist eine halbe Sekunde seit Mitternacht).

Zum Erstellen dieser MSBuild-Aufgabe verwenden wir den Projekttyp der .NET Standard 1.3-Klassenbibliothek mit dieser Klasse.

Die .csproj-Datei kann folgendermaßen aussehen:

<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>

Dieses Aufgabenprojekt ist auch in meinem GitHub holajan / DC.Build.Tasks verfügbar

Jetzt richten wir MSBuild für diese Aufgabe ein und legen die Eigenschaften FileVersion und AssemblyVersion fest . In der .csproj-Datei sieht es so aus:

<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>

Wichtige Dinge hier:

• Erwähnt UsingTask importiert die GetCurrentBuildVersion-Task aus DC.Build.Tasks.dll . Es wird davon ausgegangen, dass sich diese DLL-Datei im übergeordneten Verzeichnis Ihrer .csproj-Datei befindet.
• Unser BeforeBuildActionsProject1- Ziel, das die Aufgabe aufruft, muss einen eindeutigen Namen pro Projekt haben, falls die Lösung mehr Projekte enthält, die die Aufgabe GetCurrentBuildVersion aufrufen.

Der Vorteil dieser Lösung besteht darin, dass sie nicht nur mit Builds auf dem Build-Server funktioniert, sondern auch mit manuellen Builds aus Dotnet Build oder Visual Studio.

Sie können eine MSBuild-Eigenschaftsfunktion verwenden, um das Versionssuffix basierend auf dem aktuellen Datum festzulegen:

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

Dadurch wird ein Paket mit einem Namen wie dem folgenden ausgegeben : PackageName.1.0.0-pre20180807-1711.nupkg .

Weitere Details zu den MSBuild-Eigenschaftsfunktionen: https://docs.microsoft.com/en-us/visualstudio/msbuild/property-functions

Das Versionwird nur aus der Kombination von VersionPrefixund gebildet VersionSuffix, oder wenn VersionSuffixes leer ist VersionPrefix.

<PropertyGroup>
  <VersionPrefix>1.0.0</VersionPrefix>
</PropertyGroup>

Ich habe die obige Antwort akzeptiert, weil @Gigi (ab sofort) korrekt ist, aber ich war verärgert und habe die folgenden PowerShell-Skripte entwickelt.

Zuerst habe ich das Skript in meinem Lösungsordner (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)

Ich habe dies zur csproj-Datei hinzugefügt:

<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>

Selbst wenn es sich um ein PreBuildEvent handelt, werden die Versionsnummern erst aktualisiert, nachdem die Datei in den Speicher geladen wurde, sodass die Versionsnummer erst beim nächsten Build wiedergegeben wird. Tatsächlich könnten Sie es in ein PostBuildEvent ändern und es hätte den gleichen Effekt.

Ich habe auch die folgenden zwei Skripte erstellt: (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)

dotnet build /p:AssemblyVersion=1.2.3.4

Ich antwortete: "Hat jemand herausgefunden, wie die Version in .NET Core-Projekten (oder .NETStandard-Projekten) gesteuert werden kann?" Ich fand diese Frage beim Versuch, dieses Problem im Kontext eines CI-Builds zu lösen. Ich wollte die Assembly-Version auf die CI-Build-Nummer setzen.

Diese Werte werden jetzt in der .csprojDatei festgelegt:

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

Dies sind die gleichen Werte, die Sie sehen, wenn Sie in den Projekteinstellungen auf die Registerkarte Paket gehen . Ich glaube nicht, dass Sie *die Version automatisch inkrementieren können. Sie können jedoch einen Nachbearbeitungsschritt einführen, der die Versionen für Sie ersetzt (z. B. im Rahmen Ihrer kontinuierlichen Integration).

Ich habe ein einfaches CLI - Tool CSPROJ .NET Core - Version Strings für die Einstellung hier . Sie können es mit Tools wie GitVersion für das automatische Versions-Bumping während CI-Builds kombinieren, wenn Sie danach suchen.

So aktivieren Sie die Versionierung Ihres .Net Core / .Net Whatever-Projekts basierend auf Ihrem GIT-Setup mithilfe der Tags / Description-Funktionen von GIT.

Ich habe eine Prebuild.targets.xml-Datei verwendet, die sich im Stammordner des Projekts befindet und in der csproj-Datei enthalten ist, wie:

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

Verwenden Sie das Tag "GenerateAssembyInfo", um die automatische Generierung von Baugruppeninformationen zu deaktivieren.

Anschließend generiert die Datei Prebuild.targets.xml eine CommonAssemblyInfo.cs-Datei, in die Sie die gewünschten Versions-Tags basierend auf Ihrer GIT-Version einfügen können

HINWEIS: Ich habe die Prebuilds.targets.xml woanders gefunden, habe mich also nicht darum gekümmert, sie zu bereinigen.)

Die Datei 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>

BEARBEITEN: Wenn Sie mit MSBUILD erstellen, wird die

 $(SolutionDir)

Könnte Ihnen Probleme bereiten

 $(ProjectDir)

stattdessen

Sie können das Folgende in der csproj-Datei tun. Ich habe die Mathematik nicht herausgefunden. Ich habe das irgendwo anders im Stackoverflow gefunden. Dies funktioniert jedoch und gibt Ihnen etwas Ähnliches wie 1.0. * Für die Version.

<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>

Die Erweiterung "Automatische Versionen" für Visual Studio unterstützt jetzt die automatische Inkrementierung von .Net Core und .Net Standard in einer einfachen Benutzeroberfläche.

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

Wir können spezielle Parameter für verwenden dotnet publish -- version-suffix 1.2.3

Für die Dateiversion:

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

Für die Version:

<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.

Vielen Dank an @joelsand, der mich in die richtige Richtung gelenkt hat.

Ich musste seine Antwort leicht ändern, da ich beim Ausführen des DevOps Build die folgende Ausnahme bekam

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

Ich musste das $ (BUILD_BUILDNUMBER) am Ende des Abschnitts major.minor.build hinzufügen. Um die aktuelle Version zu de-duplizieren, verwende ich auch ein Versionspräfix:

<PropertyGroup>
    <VersionPrefix>1.0.3</VersionPrefix>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' == '' ">$(VersionPrefix)-local</Version>
    <Version Condition=" '$(BUILD_BUILDNUMBER)' != '' ">$(VersionPrefix)-$(BUILD_BUILDNUMBER)</Version>
</PropertyGroup>

Ich denke, diese Antwort von @joelsand ist die richtige Antwort zum Festlegen der Versionsnummer für den auf VSTS laufenden Dotnet-Kern

Um weitere Informationen zu dieser Antwort hinzuzufügen,

BUILD_BUILDNUMBERist eigentlich eine vordefinierte Variable .

Es stellt sich heraus, dass es 2 Versionen der vordefinierten Variablen gibt.

Einer ist build.xxxx, der andere ist BUILD_XXXX.

Sie können nur Environment Variable Namein cproj verwenden.