Como ya comentó Lasse V. Karslen, su código activará un error de compilación CS0182 . El siguiente problema es el formato requerido para AssemblyVersion: major[.minor[.build[.revision]]], hay otros campos de metadatos de ensamblaje que se pueden usar para cadenas, por ejemplo, InformationalVersion .

Hay más de una forma de agregar metadatos de ensamblaje durante la construcción... probablemente haya más de estas cinco:

• atributo de ensamblaje
• parámetro dotnet-cli
• parámetro msbuild
• entrada de configuración csproj
• Build Events / Scripting también es una forma de alcanzar su objetivo, pero es más complicado.

Usando el atributo de ensamblaje

El problema con el atributo de ensamblaje es que debe ser una expresión constante. Eso no es sencillo de lograr, pero Gitinfo logró ofrecer una solución. Otra desventaja es la necesidad de deshabilitar el compilador para generar el AssemblyInfo.cs que interrumpirá la escritura de algunos valores configurados en csproj en el ensamblado final.

Instalar gitinfo

 PM> Install-Package GitInfo

Establecer en su archivo csproj

 <GenerateAssemblyInfo>false</GenerateAssemblyInfo>

Agregar/Crear AssemblyInfo .cs

 [assembly: AssemblyInformationalVersion(ThisAssembly.Git.Commit)]

Usando dotnet-cli (usando powershell)

Eso es sencillo.

 $GitHash=git describe --always dotnet build -p:InformationalVersion=$GitHash

Usando csproj modificado

Los archivos csproj modificados son un enfoque común utilizado en ci.

Agregue 'InformationVersion' a su csproj:

 <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <InformationalVersion>$(GitHash)</InformationalVersion> </PropertyGroup> </Project>

Establezca la variable de entorno 'GitHash' antes de generar la salida de 'git describe --always':

 $env:GitHash=git describe --always dotnet build

Por ejemplo, GithubactionsHellowWord es un ejemplo de proyecto que utiliza acciones de github integradas en la variable de entorno para escribir hash sha1 en los metadatos del ensamblado .

El explorador mostrará el valor de informationalVersion en el campo 'Versión del producto'.

No es una sola línea, pero este artículo https://galdin.dev/blog/show-git-commit-sha-in-net-applications/ muestra una forma sencilla de ejecutar el comando y acceder al resultado. Los pasos descritos en este artículo son los siguientes,

Para hacer esto, creamos un evento precompilado que ejecutará un comando git y lo guardará en un archivo de texto. Luego agregamos ese archivo de texto generado como un recurso de cadena. Ahora se podrá acceder al recurso desde C#.

1. Haga clic derecho en la aplicación web y haga clic en propiedades.

2. Vaya a la pestaña de eventos de compilación y escriba lo siguiente en la línea de comando del evento previo a la compilación:

    git rev-parse HEAD --short > "$(ProjectDir)\CurrentCommit.txt"

   Obviamente, el comando puede ser reemplazado por cualquier cosa que crea conveniente.

3. Guarde y compile el proyecto. (Ctrl+Mayús+S, Ctrl+Mayús+B)

4. Se debe crear un nuevo archivo llamado CurrentCommit.txt en la raíz de su proyecto.

5. Continúe y exclúyalo del Control de código fuente

6. En la página de propiedades de los proyectos, vaya a la pestaña Recursos y agregue el archivo existente CurrentCommit.txt como recurso.

Ahora se puede acceder al contenido del archivo generado como:

 Your.NameSpace.Properties.Resources.CurrentCommit;

En lugar de usar AssemblyVersionAttribute , ahora puede usar las propiedades de MsBuild para establecer la versión (entre otros atributos). La ventaja de usar MsBuild es que puede calcular estos valores como parte del proceso de compilación.

Esto funcionará para cualquier proyecto de "estilo nuevo"/"estilo SDK" .

Echa un vistazo a: Propiedades de atributo de ensamblaje .

Terminarás con algo a lo largo de estas líneas:

 ConsoleApp5.csproj:

 <Project Sdk="Microsoft.NET.Sdk"> <PropertyGroup> <OutputType>Exe</OutputType> <TargetFramework>net6.0</TargetFramework> <ImplicitUsings>enable</ImplicitUsings> <Nullable>enable</Nullable> </PropertyGroup> <!-- Add the property group and the target below to your project file --> <PropertyGroup> <GenerateAssemblyVersionAttribute>true</GenerateAssemblyVersionAttribute> <GenerateAssemblyFileVersionAttribute>true</GenerateAssemblyFileVersionAttribute> <GenerateAssemblyInformationalVersionAttribute>true</GenerateAssemblyInformationalVersionAttribute> </PropertyGroup> <Target Name="AddGitShaToAssemblyVersions" BeforeTargets="GetAssemblyVersion" Returns="AssemblyVersion, FileVersion, InformationalVersion"> <Exec ConsoleToMsBuild="true" Command="git describe --always"> <Output TaskParameter="ConsoleOutput" PropertyName="GitSha" /> </Exec> <PropertyGroup> <AssemblyVersion>1.1.1.1</AssemblyVersion> <FileVersion>1.1.1.1-$(GitSha)</FileVersion> <InformationalVersion>1.1.1.1-$(GitSha)</InformationalVersion> </PropertyGroup> </Target> <!-- Ignore the warning generated for the AssemblyFileVersion --> <PropertyGroup> <NoWarn>$(NoWarn);7035</NoWarn> </PropertyGroup> </Project>

Se genera un archivo en la carpeta obj y se incluye automáticamente en la compilación. Puede abrir este archivo en su editor para ver el contenido generado:

Contenido generado:

 //------------------------------------------------------------------------------ // <auto-generated> // This code was generated by a tool. // Runtime Version:4.0.30319.42000 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // </auto-generated> //------------------------------------------------------------------------------ using System; using System.Reflection; [assembly: System.Reflection.AssemblyCompanyAttribute("ConsoleApp5")] [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")] [assembly: System.Reflection.AssemblyFileVersionAttribute("1.1.1.1-3654148")] [assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.1.1.1-3654148")] [assembly: System.Reflection.AssemblyProductAttribute("ConsoleApp5")] [assembly: System.Reflection.AssemblyTitleAttribute("ConsoleApp5")] [assembly: System.Reflection.AssemblyVersionAttribute("1.1.1.1")] // Generated by the MSBuild WriteCodeFragment class.

Para mí, la ventaja es que toda la lógica está bien encapsulada en los archivos de compilación y no dependerá de que tenga que ejecutar ningún comando antes de compilar o poner la lógica de compilación en otro script, como un script de PowerShell, scripts que Visual Studio no es consciente de.

Asegúrese de eliminar sus atributos existentes, agregados manualmente, AssemblyVersion , etc. de su proyecto, o terminará con una advertencia de que el atributo se especificó dos veces.