Where should I store project related properties in visual studio 2022 ? (AssemblyInfo)

I'm trying to understand where I should store data regarding the project that I might manually edit or programmaticaly change outside of execution of the project itself (ex: during build, after a git commit or after a nugetPackage deployement).

A concrete exemple would be to manage version numbers.

I would like to create 4 variable, that would be used to set the $(VersionPrefix) :

• Major (manually updated)
• Minor (manually updated)
• LastGitHash (After git push)
• BuildNumber (Incremented at each build, reset at new git push)

It seems it used to be done in some way in AssemblyInfo but that it is deprecated.

I could add a custom file somewhere... but there are probably more standard solutions...
I found Resources.resx as there is a link from the project Properties, it seems it could be the solution i'm looking for but I've not found the way to access those variables at build.

Update:

My project structure:

Original Answer:

First, project related properties should be stored in the Property of .csproj like this:

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IncludeBuildOutput>true</IncludeBuildOutput>
<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
<major>1</major>
<minor>1</minor>
<patch>2</patch>
<LastGitHash>0</LastGitHash>
<BuildNumber>0</BuildNumber>
<Version>$(major).$(minor).$(patch)</Version>
</PropertyGroup>
<!--output message-->
<Target Name="OutputMessage" AfterTargets="Build">
<Message Importance="high" Text="Version: $(Version)" />
</Target>
</Project>

1, Major and minor.

> Major (manually updated)

> Minor (manually updated)

For these requirement, you can use msbuild command to replace the content like this:

msbuild NET6_AssemblyInfo.csproj /p:major=2 /p:minor=2 /t:OutputMessage

Also you can manually edit the values of these two settings in the .csproj file.

2, LastGitHash (After git push)

For this requirement, you can use git hooks to achieve your requirement:

See the official document.

Git Hooks

You can use the hook 'post-receive'.

Above is the auto method.

If you don't have enough permission in the server, then above method is unable to achieve(Because post-receive is a Server-Side Hook, these doesn't have a local host to achieve your requirements.). You need write your script to change the value.

See the below step about changing the value.

3, BuildNumber (Incremented at each build, reset at new git push)

For this requirement, you can use post build event to run script after build to change the content of the file. And call script after new git push.

I will right powershell scripts to achieve your requirements.

1'' Incremented at each build:

change_value.ps1

#find the .csproj file
$csproj_file = Get-ChildItem -Path . -Filter *.csproj
$csproj_file
#read xml content from xxx.csproj
$csproj = [xml](Get-Content $csproj_file)
#get the value of the property
$BN = $csproj.Project.PropertyGroup.BuildNumber
$LGH
$BN
#increment the BN value
$BN = [int]$BN + 1
#replace the BN value in the .csproj file
$csproj.Project.PropertyGroup.BuildNumber = [string]$BN
#save the .csproj file
$csproj.Save($csproj_file)

You can set this powershell file in here:

right click project, click properties:

Of course, you need to configure the powershell.exe root path to the env vars before the above step:

And then, build operation will auto increase the build number:

2'' reset at new git push

If you don't need after git push, you can use git hook 'pre-push'.

Go to your local project, then click in .git->hooks, then create a file named 'pre-push':

content:

#!/bin/sh
powershell -File reset_value.ps1

reset_value.ps1

#find the .csproj file
$csproj_file = Get-ChildItem -Path . -Filter *.csproj
$csproj_file
#read xml content from xxx.csproj
$csproj = [xml](Get-Content $csproj_file)
#get the value of the property
$BN = $csproj.Project.PropertyGroup.BuildNumber
$LGH
$BN
#reset the BN value
$BN = 0
#replace the BN value in the .csproj file
$csproj.Project.PropertyGroup.BuildNumber = [string]$BN
#save the .csproj file
$csproj.Save($csproj_file)

Then the content of the build number will be reset:

By the way, if you can make sure each git push step on your side is success, then the second step can also use pre-push hook. In your situation, pre-push and post-push are same.

There are two different 'project systems' that build on MSBuild: 'legacy' and 'SDK style'. The SDK style was introduced with .Net Core/.Net.

If the Project element in the project file has an Sdk attribute, then the project is an SDK style project. Given that the project is C# and .Net 6, the project is highly likely an SDK style project.

.NET SDK project Assembly attribute and Version properties

Assembly Info is not deprecated and SDK projects directly support assembly info with a set of properties. See Assembly attribute properties.

In Windows 11 in the file explorer, the 'Details' tab of the properties dialog for an executable file will show 'File version' which is the AssemblyFileVersionAttribute, which is set from the $(FileVersion) property. 'Product version' is the AssemblyInformationalVersionAttribute, which is the $(InformationalVersion) property.

The AssemblyVersionAttribute and AssemblyFileVersionAttribute are expected to be of type Version. A Version has the format major.minor[.build[.revision]] and, with the exception of the '.' delimiter, cannot contain non-numeric characters. The Version type predates SemVer.

Only the AssemblyInformationalVersionAttribute can contain alpha version information.

To better support SemVer, there are three properties that are 'under-explained' in the official Microsoft documentation: $(VersionPrefix), $(VersionSuffix), and $(Version). $(VersionPrefix) corresponds to <version core> in the SemVar Backus–Naur Form Grammar.

These properties build from each other. From the source code:

  <PropertyGroup Condition=" '$(Version)' == '' ">
    <VersionPrefix Condition=" '$(VersionPrefix)' == '' ">1.0.0</VersionPrefix>
    <Version Condition=" '$(VersionSuffix)' != '' ">$(VersionPrefix)-$(VersionSuffix)</Version>
    <Version Condition=" '$(Version)' == '' ">$(VersionPrefix)</Version>
  </PropertyGroup>

The default value for $(InformationalVersion) is $(Version).

The default value for $(FileVersion) and $(AssemblyVersion) is effectively $(VersionPrefix).

(Note that a git hash would need to be in the $(VersionSuffix).)

These various properties can be overridden and the overriding definitions can be in separate files that are imported into the project.

Setting the Version

The Major and Minor version numbers can be stored in their own file that can be modified independently of any other file. A default for BuildNumber could also be set.

As an example, a ProjectVersion.props file may define the values of $(Major) and $(Minor).

<!-- ProjectVersion.props -->
<Project>
  <PropertyGroup>
    <Major Condition=" '$(Major)' == '' ">1</Major>
    <Minor Condition=" '$(Minor)' == '' ">0</Minor>
  </PropertyGroup>
</Project>

Instead of modifying the project, a Directory.Build.props file can be created which, if present, will be automatically imported. Directory.Build.props can import a file that defines the Major and Minor values, which in this example is the ProjectVersion.props file.

<!-- Directory.Build.props -->
<Project>
  <Import Project="$([MSBuild]::GetPathOfFileAbove('$(MSBuildThisFile)', '$(MSBuildThisFileDirectory)../'))" />

  <!-- Import ProjectVersion.props from the folder containing the project if the file exists -->
  <Import Project="$(MSBuildProjectDirectory)/ProjectVersion.props" Condition="Exists('$(MSBuildProjectDirectory)/ProjectVersion.props')" />
  <!-- Set SDK version properties -->
  <PropertyGroup>
    <VersionPrefix Condition=" '$(Major)' != '' and '$(Minor)' != '' and '$(BuildNumber)' != ''">$(Major).$(Minor).$(BuildNumber)</VersionPrefix>
    <VersionPrefix Condition=" '$(Major)' != '' and '$(Minor)' != '' and '$(BuildNumber)' == ''">$(Major).$(Minor)</VersionPrefix>
    <VersionSuffix Condition=" '$(LastGitHash)' != '' ">$(LastGitHash)</VersionSuffix>
  </PropertyGroup>
</Project>

The first Import will search up the directory tree for another Directory.Build.props file and import it if one is found. This is not related to the question but it a good practice.

The second Import gets the content of the ProjectVersion.props file from the directory that contains the project file. The Directory.Build.props file can be shared across multiple projects and each project can have its own ProjectVersion.props file.

$(VersionPrefix) is set based on $(Major), $(Minor), and $(BuildNumber).

$(VersionSuffix) is set based on $(LastGitHash).

Getting BuildNumber and LastGitHash

Where do the values of $(BuildNumber) and $(LastGitHash) come from? Those values are external to the source code and must be provided by the build system and passed to MSBuild when the project is built.

The original question doesn't identify the build system.

Some tips:

• The 'project' should have no knowledge of the version control system. Don't couple the source code to the version control system. Don't run git commands from inside the project.
• Don't store build state in version control. Don't try to persist a build number in a file in the source. Within a given build, the source should never be changed by the build. Builds should be as deterministic as possible, repeatable, and distributable.
• The 'project' should have no knowledge of the build system.
• Whatever build system is in use, will need to know the version control system because it will need to clone or pull the repo to build. It can determine an appropriate revision identifier and pass that to MSBuild for use within the build. The /p or /property option switch can be used to pass values into MSBuild; e.g. /p:LastGitHash=1234.
• Likewise the BuildNumber is an artifact of the build system and should be determined by the build system and passed to MSBuild. Most build systems support counters for implementing incrementing build numbers.