dotnet set semantic version

Question

Is there a way to actively modify the versioning of the .csproj files using the dotnet CLI? In the same way we can update the npm version.

I need to modify the files, I'm not looking for dotnet build -p:Version=1.2.3.4.

OR for example with maven you can do this: mvn versions:set -DnewVersion=1.2.3.4 which actually updates your pom.xml.

Answer 1

Try this one: https://github.com/TAGC/dotnet-setversion

It uses XDocument to load, modify and save the csproj file.

Answer 2

For clarity, are you looking to set the Assembly Version or Semantic Version? A semantic version only has 3 numeric parts: <major>.<minor>.<patch>.

For reference, these are the relevant MSBuild properties that you can set or pass via the CLI:

• Version: overall version; defaults to 1.0.0.0 if unset
• AssemblyVersion: the assembly version; defaults to Version
• FileVersion: the Win32 file version; defaults to AssemblyVersion if unset
• VersionPrefix: the version prefix; meant to serve as the numeric part of the semantic version; defaults to Version if unset
• VersionSuffix: the version suffix; meant to serve as the label part of the semantic version
• PackageVersion: the NuGet package (e.g. semantic) version; defaults to $(VersionPrefix)-$(VersionSuffix) if both are set; otherwise, VersionPrefix, which may default to Version

dotnet pack --version-suffix beta.1 is equivalent to dotnet pack -p:VersionSuffix=beta.1

Regardless of which version you are trying to set (maybe even both), I would recommend just using native MSBuild if possible because it simplifies the process. If you want to manage the versions in one place, you can easily do this with Directory.Build.targets.

For example, let's assume your source layout is:

└─ src
    ├─ Project1
    ├─ Project2
    └─ Project3

By adding the file src/Directory.Build.targets, all projects will import the file automatically without any modification (e.g. zero-touch).

There's many ways you could configure it, but it could look something like:

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

  <PropertyGroup>
    
    <MajorVersion Condition=" '$(MajorVersion)' == '' ">1</MajorVersion>
    <MinorVersion Condition=" '$(MinorVersion)' == '' ">0</MinorVersion>
    <PatchVersion Condition=" '$(PatchVersion)' == '' ">0</PatchVersion>

    <VersionPrefix Condition=" '$(VersionPrefix)' == '' ">$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
    <AssemblyVersion Condition=" '$(AssemblyVersion)' == '' ">$(VersionPrefix).0</AssemblyVersion>
    
    <!-- replicates the old behavior of <major>.<minor>.* (ex: 1.0.*) in AssemblyInfo.cs -->
    <DaylightSavingTime>$([System.DateTime]::Now.IsDaylightSavingTime())</DaylightSavingTime>
    <FileBuildNumber>$([System.DateTime]::Today.Subtract($([System.DateTime]::Parse("1/1/2000"))).ToString("%d"))</FileBuildNumber>
    <FileBuildRevision Condition=" '$(DaylightSavingTime)' == 'True' " >$([System.Convert]::ToInt32($([MSBuild]::Divide($([System.DateTime]::Now.Subtract($([System.TimeSpan]::FromHours(1.0))).TimeOfDay.TotalSeconds),2))))</FileBuildRevision>
    <FileBuildRevision Condition=" '$(DaylightSavingTime)' == 'False' " >$([System.Convert]::ToInt32($([MSBuild]::Divide($([System.DateTime]::Now.TimeOfDay.TotalSeconds),2))))</FileBuildRevision>
    <FileVersion>$(MajorVersion).$(MinorVersion).$(FileBuildNumber).$(FileBuildRevision)</FileVersion>

  </PropertyGroup>

</Project>

Figure 1: Directory.Build.targets

This works really well if all of your projects use the same version numbers. A solution usually uses the same versions. If they don't, then it becomes a bit trickier. Although it would be possible to easily override just one part of version in a project (or projects), you indicated that was not an option. Another option would be to use an auto-generated value for patch; perhaps based on date. Then you'd never need to edit value.

If your versioning strategy is centrally managed this way, then IMHO, it's just as much effort to modify a single number with any text editor as it would be running some CLI command that you also have to install. The dotnet-setversion tool offers configuring a JSON file and that is same level of effort in updating a native MSBuild XML file albeit without requiring an additional tool.

Aside: Just my option, but I would not recommend setting a semantic version label as suggested by dotnet-setversion. Instead, I would stick to the built-in --version-suffix parameter. There are many ways to hook that up into your build process or use it imperatively on-demand as needed.

It's also worth noting that there are many guardrails that prevent you from going off the tracks. If you use non-numeric values, the build will fail. If accidentally forget to increment the version or use a duplicate label, publish will be rejected. There's no tool that will prevent you from forgetting to increment unless you use auto-generation method.