Ich erstelle eine C # -Anwendung und verwende Git als Versionskontrolle.

Gibt es eine Möglichkeit, den letzten Commit-Hash beim Erstellen meiner Anwendung automatisch in die ausführbare Datei einzubetten?

Das Drucken des Commit-Hashs auf die Konsole sieht beispielsweise folgendermaßen aus:

class PrintCommitHash
{
    private String lastCommitHash = ?? // What do I put here?
    static void Main(string[] args)
    {
        // Display the version number:
        System.Console.WriteLine(lastCommitHash );
    }
}

Beachten Sie, dass dies zur Erstellungszeit und nicht zur Laufzeit erfolgen muss , da für meine bereitgestellte ausführbare Datei das Git-Repo nicht verfügbar ist.

Eine verwandte Frage zu C ++ finden Sie hier .

EDIT

Pro @ mattanja Verlangen Ich poste das git Haken Skript , das ich in meinen Projekten verwenden. Die Einrichtung:

• Die Hooks sind Linux-Shell-Skripte, die unter: path_to_project \ .git \ hooks abgelegt werden
• Wenn Sie msysgit verwenden , enthält der Hooks- Ordner bereits einige Beispielskripte. Entfernen Sie die Erweiterung '.sample' aus dem Skriptnamen, damit git sie aufruft.
• Die Namen der Hook-Skripte stimmen mit dem Ereignis überein, das sie aufruft. In meinem Fall habe ich Post-Commit und Post-Merge geändert .
• Meine AssemblyInfo.cs- Datei befindet sich direkt unter dem Projektpfad (dieselbe Ebene wie der .git- Ordner). Es enthält 23 Zeilen und ich benutze git, um die 24. zu generieren.

Da mein Linux-Shelling etwas verrostet ist, liest das Skript einfach die ersten 23 Zeilen von AssemblyInfo.cs in eine temporäre Datei, gibt den Git-Hash in die letzte Zeile zurück und benennt die Datei wieder in AssemblyInfo.cs um . Ich bin sicher, es gibt bessere Möglichkeiten, dies zu tun:

#!/bin/sh
cmt=$(git rev-list --max-count=1 HEAD)
head -23 AssemblyInfo.cs > AssemblyInfo.cs.tmp
echo [assembly: AssemblyFileVersion\(\"$cmt\"\)] >> AssemblyInfo.cs.tmp
mv AssemblyInfo.cs.tmp AssemblyInfo.cs

Hoffe das hilft.

Wir verwenden Tags in Git, um Versionen zu verfolgen.

git tag -a v13.3.1 -m "version 13.3.1"

Sie können die Version mit Hash von git erhalten über:

git describe --long

Unser Erstellungsprozess fügt den Git-Hash in das AssemblyInformationalVersion-Attribut der AssemblyInfo.cs-Datei ein:

[assembly: AssemblyInformationalVersion("13.3.1.74-g5224f3b")]

Nach dem Kompilieren können Sie die Version im Windows Explorer anzeigen:

Sie können es auch programmgesteuert über Folgendes abrufen:

var build = ((AssemblyInformationalVersionAttribute)Assembly
  .GetAssembly(typeof(YOURTYPE))
  .GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false)[0])
  .InformationalVersion;

Dabei ist YOURTYPE ein beliebiger Typ in der Assembly, der das Attribut AssemblyInformationalVersion hat.

Sie können eine version.txt- Datei in die ausführbare Datei einbetten und dann die version.txt aus der ausführbaren Datei lesen . Verwenden Sie zum Erstellen der Datei version.txtgit describe --long

Hier sind die Schritte:

Verwenden Sie ein Build-Ereignis, um git aufzurufen

• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Eigenschaften

• Fügen Sie unter Build-Ereignisse ein Pre-Build-Ereignis hinzu, das Folgendes enthält (beachten Sie die Anführungszeichen):

  "C: \ Programme \ Git \ bin \ git.exe" beschreiben --long> "$ (ProjectDir) \ version.txt"

  Dadurch wird eine version.txt- Datei in Ihrem Projektverzeichnis erstellt.

Betten Sie die version.txt in die ausführbare Datei ein

• Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Vorhandenes Element hinzufügen
• Fügen Sie die Datei version.txt hinzu (ändern Sie den Filter für die Dateiauswahl, damit Sie alle Dateien sehen können).
• Nachdem version.txt hinzugefügt wurde, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste darauf und wählen Sie Eigenschaften
• Ändern Sie die Build-Aktion in Embedded Resource
• Ändern Sie "Kopieren in Ausgabeverzeichnis" in "Immer kopieren"
• In version.txt auf Ihre .gitignore Datei

Lesen Sie die Versionszeichenfolge der eingebetteten Textdatei

Hier ist ein Beispielcode zum Lesen der Versionszeichenfolge für eingebettete Textdateien:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;

namespace TryGitDescribe
{
    class Program
    {
        static void Main(string[] args)
        {
            string gitVersion= String.Empty;
            using (Stream stream = Assembly.GetExecutingAssembly()
                    .GetManifestResourceStream("TryGitDescribe." + "version.txt"))
            using (StreamReader reader = new StreamReader(stream))
            {
                gitVersion= reader.ReadToEnd();
            }

            Console.WriteLine("Version: {0}", gitVersion);
            Console.WriteLine("Hit any key to continue");
            Console.ReadKey();
        }
    }
}

AKTUALISIEREN:

Die Dinge haben sich weiterentwickelt, seit ich diese Frage ursprünglich beantwortet habe. Das Microsoft.NET.Sdk(dh Sie müssen ein Projekt im SDK-Stil verwenden) unterstützt jetzt das Hinzufügen des Commit-Hashs sowohl zur Assembly-Informationsversion als auch zu den Metadaten des Nuget-Pakets, wenn einige Bedingungen erfüllt sind:

1. Die <SourceRevisionId>Eigenschaft muss definiert werden. Dies kann durch Hinzufügen eines Ziels wie folgt erfolgen:

<Target Name="InitializeSourceControlInformation" BeforeTargets="AddSourceRevisionToInformationalVersion">
    <Exec 
      Command="git describe --long --always --dirty --exclude=* --abbrev=8"
      ConsoleToMsBuild="True"
      IgnoreExitCode="False"
      >
      <Output PropertyName="SourceRevisionId" TaskParameter="ConsoleOutput"/>
    </Exec>
  </Target>

Dieses Ziel führt einen Befehl aus, SourceRevisionIdder als abgekürzter (8 Zeichen) Hash festgelegt wird. Die BeforeTargets bewirken, dass dies ausgeführt wird, bevor die Assembly-Informationsversion erstellt wird.

2. Um den Hash in die Metadaten des Nuget-Pakets aufzunehmen, <RepositoryUrl>muss auch der Hash definiert werden.

3. <SourceControlInformationFeatureSupported>Eigenschaft muss sein true, dies bewirkt, dass die Nuget-Pack-Task auch die SourceRevisionId aufnimmt.

Ich würde Leute davon abhalten, das MSBuildGitHash-Paket zu verwenden, da diese neue Technik sauberer und beständiger ist.

ORIGINAL:

Ich habe ein einfaches Nuget-Paket erstellt, das Sie in Ihr Projekt aufnehmen können und das dies für Sie erledigt: https://www.nuget.org/packages/MSBuildGitHash/

Dieses Nuget-Paket implementiert eine "reine" MSBuild-Lösung. Wenn Sie sich nicht auf ein Nuget-Paket verlassen möchten, können Sie diese Ziele einfach in Ihre csproj-Datei kopieren. Der Git-Hash sollte als benutzerdefiniertes Assembly-Attribut enthalten sein:

<Target Name="GetGitHash" BeforeTargets="WriteGitHash" Condition="'$(BuildHash)' == ''">
  <PropertyGroup>
    <!-- temp file for the git version (lives in "obj" folder)-->
    <VerFile>$(IntermediateOutputPath)gitver</VerFile>
  </PropertyGroup>

  <!-- write the hash to the temp file.-->
  <Exec Command="git -C $(ProjectDir) describe --long --always --dirty &gt; $(VerFile)" />

  <!-- read the version into the GitVersion itemGroup-->
  <ReadLinesFromFile File="$(VerFile)">
    <Output TaskParameter="Lines" ItemName="GitVersion" />
  </ReadLinesFromFile>
  <!-- Set the BuildHash property to contain the GitVersion, if it wasn't already set.-->
  <PropertyGroup>
    <BuildHash>@(GitVersion)</BuildHash>
  </PropertyGroup>    
</Target>

<Target Name="WriteGitHash" BeforeTargets="CoreCompile">
  <!-- names the obj/.../CustomAssemblyInfo.cs file -->
  <PropertyGroup>
    <CustomAssemblyInfoFile>$(IntermediateOutputPath)CustomAssemblyInfo.cs</CustomAssemblyInfoFile>
  </PropertyGroup>
  <!-- includes the CustomAssemblyInfo for compilation into your project -->
  <ItemGroup>
    <Compile Include="$(CustomAssemblyInfoFile)" />
  </ItemGroup>
  <!-- defines the AssemblyMetadata attribute that will be written -->
  <ItemGroup>
    <AssemblyAttributes Include="AssemblyMetadata">
      <_Parameter1>GitHash</_Parameter1>
      <_Parameter2>$(BuildHash)</_Parameter2>
    </AssemblyAttributes>
  </ItemGroup>
  <!-- writes the attribute to the customAssemblyInfo file -->
  <WriteCodeFragment Language="C#" OutputFile="$(CustomAssemblyInfoFile)" AssemblyAttributes="@(AssemblyAttributes)" />
</Target>

Hier gibt es zwei Ziele. Der erste, "GetGitHash", lädt den Git-Hash in eine MSBuild-Eigenschaft namens BuildHash. Dies geschieht nur, wenn BuildHash noch nicht definiert ist. Auf diese Weise können Sie es in der Befehlszeile an MSBuild übergeben, wenn Sie dies bevorzugen. Sie können es wie folgt an MSBuild weitergeben:

MSBuild.exe myproj.csproj /p:BuildHash=MYHASHVAL

Das zweite Ziel, "WriteGitHash", schreibt den Hashwert in eine Datei im temporären Ordner "obj" mit dem Namen "CustomAssemblyInfo.cs". Diese Datei enthält eine Zeile, die wie folgt aussieht:

[assembly: AssemblyMetadata("GitHash", "MYHASHVAL")]

Diese CustomAssemblyInfo.cs-Datei wird in Ihre Assembly kompiliert, sodass Sie mithilfe der Reflektion nach der AssemblyMetadataLaufzeit suchen können . Der folgende Code zeigt, wie dies durchgeführt werden kann, wenn die AssemblyInfoKlasse in derselben Assembly enthalten ist.

using System.Linq;
using System.Reflection;

public static class AssemblyInfo
{
    /// <summary> Gets the git hash value from the assembly
    /// or null if it cannot be found. </summary>
    public static string GetGitHash()
    {
        var asm = typeof(AssemblyInfo).Assembly;
        var attrs = asm.GetCustomAttributes<AssemblyMetadataAttribute>();
        return attrs.FirstOrDefault(a => a.Key == "GitHash")?.Value;
    }
}

Einige Vorteile dieses Designs sind, dass es keine Dateien in Ihrem Projektordner berührt. Alle mutierten Dateien befinden sich im Ordner "obj". Ihr Projekt wird auch in Visual Studio oder über die Befehlszeile identisch erstellt. Es kann auch einfach an Ihr Projekt angepasst werden und wird zusammen mit Ihrer csproj-Datei quellgesteuert.

Eine andere Möglichkeit, dies zu tun, besteht darin, das NetRevisionTool mit etwas On-Board Visual Studio-Magie zu verwenden. Ich werde dies hier für Visual Studio 2013 Professional Edition vorstellen, aber dies wird auch mit anderen Versionen funktionieren.

Laden Sie also zuerst das NetRevisionTool herunter. Sie fügen die Datei NetRevisionTool.exe in Ihren PATH ein oder checken sie in Ihr Repository ein, erstellen eine Visual Studio-Vor- und eine Nacherstellungsaktion und ändern Ihre AssemblyInfo.cs.

Ein Beispiel, das Ihren Git-Hash zu Ihrer AssemblyInformationVersion hinzufügen würde, wäre das Folgende: In Ihren Projekteinstellungen:

In den AssemblyInfo.cs Ihres Projekts ändern / fügen Sie die folgende Zeile hinzu:

[Assembly: AssemblyInformationalVersion ("1.1. {dmin: 2015}. {chash: 6} {!} - {branch}")]

Im gezeigten Screenshot habe ich in NetRevisionTool.exe im Ordner External / bin nachgesehen

Wenn Sie nach dem Erstellen mit der rechten Maustaste auf Ihre Binärdatei klicken und zu den Eigenschaften wechseln, sollte Folgendes angezeigt werden:

Hoffe das hilft jemandem da draußen

Ich denke, diese Frage ist es wert, Schritt für Schritt vollständig beantwortet zu werden. Die Strategie hierfür besteht darin, ein Powershell-Skript aus den Pre-Build-Ereignissen auszuführen, das eine Vorlagendatei aufnimmt und eine AssemblyInfo.cs-Datei mit den enthaltenen Informationen zum Git-Tag + Commit-Anzahl generiert.

Schritt 1: Erstellen Sie eine AssemblyInfo_template.cs-Datei im Ordner Project \ Properties, basierend auf Ihrer ursprünglichen AssemblyInfo.cs-Datei, die jedoch Folgendes enthält:

[assembly: AssemblyVersion("$FILEVERSION$")]
[assembly: AssemblyFileVersion("$FILEVERSION$")]
[assembly: AssemblyInformationalVersion("$INFOVERSION$")]

Schritt 2: Erstellen Sie ein Powershell-Skript mit dem Namen InjectGitVersion.ps1, dessen Quelle lautet:

# InjectGitVersion.ps1
#
# Set the version in the projects AssemblyInfo.cs file
#


# Get version info from Git. example 1.2.3-45-g6789abc
$gitVersion = git describe --long --always;

# Parse Git version info into semantic pieces
$gitVersion -match '(.*)-(\d+)-[g](\w+)$';
$gitTag = $Matches[1];
$gitCount = $Matches[2];
$gitSHA1 = $Matches[3];

# Define file variables
$assemblyFile = $args[0] + "\Properties\AssemblyInfo.cs";
$templateFile =  $args[0] + "\Properties\AssemblyInfo_template.cs";

# Read template file, overwrite place holders with git version info
$newAssemblyContent = Get-Content $templateFile |
    %{$_ -replace '\$FILEVERSION\$', ($gitTag + "." + $gitCount) } |
    %{$_ -replace '\$INFOVERSION\$', ($gitTag + "." + $gitCount + "-" + $gitSHA1) };

# Write AssemblyInfo.cs file only if there are changes
If (-not (Test-Path $assemblyFile) -or ((Compare-Object (Get-Content $assemblyFile) $newAssemblyContent))) {
    echo "Injecting Git Version Info to AssemblyInfo.cs"
    $newAssemblyContent > $assemblyFile;       
}

Schritt 3: Speichern Sie die Datei InjectGitVersion.ps1 in Ihrem Lösungsverzeichnis in einem BuildScripts-Ordner

Schritt 4: Fügen Sie den Pre-Build-Ereignissen des Projekts die folgende Zeile hinzu

powershell -ExecutionPolicy ByPass -File  $(SolutionDir)\BuildScripts\InjectGitVersion.ps1 $(ProjectDir)

Schritt 5: Erstellen Sie Ihr Projekt.

Schritt 6: Fügen Sie optional AssemblyInfo.cs zu Ihrer Git-Ignorierdatei hinzu

Da in der anderen Antwort bereits das Git-Bit erwähnt wird, können Sie nach dem SHA die AssemblyInfo.csDatei Ihres Projekts in einem Pre-Build-Hook generieren .

Eine Möglichkeit, dies zu tun, besteht darin, eine AssemblyInfo.cs.tmplVorlagendatei mit einem Platzhalter für Ihre SHA in beispielsweise $$ GITSHA $$ zu erstellen, z

[assembly: AssemblyDescription("$$GITSHA$$")]

Ihr Pre-Build-Hook muss dann diesen Platzhalter ersetzen und die AssemblyInfo.cs-Datei ausgeben, damit der C # -Compiler sie abrufen kann.

In dieser Antwort erfahren Sie, wie dies mit SubWCRev für SVN möglich ist . Es sollte nicht schwer sein, etwas Ähnliches für Git zu tun.

Andere Möglichkeiten wären eine "Make Stage", wie erwähnt, dh das Schreiben einer MSBuild-Aufgabe, die etwas Ähnliches tut. Eine weitere Möglichkeit besteht darin, die DLL irgendwie nachzubearbeiten (z. B. ildasm + ilasm), aber ich denke, die oben genannten Optionen sind wahrscheinlich am einfachsten.

Mit .NET Revision Task für MSBuild und der Arbeit mit Visual Studio 2019 ist dies jetzt sehr einfach .

Installieren Sie einfach das NuGet- Paket Unclassified.NetRevisionTask und konfigurieren Sie die gewünschten Informationen in der AssemblyInfo.csDatei wie in der GitHub-Dokumentation beschrieben .

Wenn Sie nur den Hash des letzten Commits (Länge = 8) möchten:

[assembly: AssemblyInformationalVersion("1.0-{chash:8}")]

Erstellen Sie Ihr Projekt / Ihre Lösung und Sie haben ungefähr Folgendes:

Für eine vollautomatische und flexible Methode checken Sie https://github.com/Fody/Stamp . Wir haben dies erfolgreich für unsere Git-Projekte verwendet (sowie diese Version für SVN-Projekte).

Update: Dies ist veraltet, da Stamp.Fody nicht mehr gepflegt wird

Sie können einen Powershell-Einzeiler verwenden, um alle Assemblyinfo-Dateien mit dem Commit-Hash zu aktualisieren.

$hash = git describe --long --always;gci **/AssemblyInfo.* -recurse | foreach { $content = (gc $_) -replace "\[assembly: Guid?.*", "$&`n[assembly: AssemblyMetadata(`"commithash`", `"$hash`")]" | sc $_ }

1. Ich hoffe, Sie wissen, wie Sie externe Programme aufrufen und die Ausgabe während der Erstellung abfangen können.
2. Ich hoffe, Sie wissen, wie man im Arbeitsverzeichnis von git nicht versionierte Dateien ignoriert.

Wie von @ learath2 angegeben, erhalten Sie bei der Ausgabe von git rev-parse HEADeinen einfachen Hash.

Wenn Sie Tags im Git-Repository verwenden (und Tags verwenden, ist dies nicht aussagekräftiger und lesbarer als git rev-parse), kann die Ausgabe von empfangen werden git describe(während sie später auch erfolgreich verwendet wird git checkout).

Sie können rev-parse | description aufrufen in:

• Einige machen Bühne
• im Post-Commit-Hook
• im Wischfilter, wenn Sie die Art der Implementierung für Wisch- / Reinigungsfilter auswählen

Ich verwende eine Kombination aus der akzeptierten Antwort und einer kleinen Ergänzung. Ich habe die AutoT4-Erweiterung installiert ( https://marketplace.visualstudio.com/items?itemName=BennorMcCarthy.AutoT4 ), um die Vorlagen vor dem Erstellen erneut auszuführen.

Version von GIT bekommen

Ich habe git -C $(ProjectDir) describe --long --always > "$(ProjectDir)git_version.txt"in meinem Pre-Build-Event Projekteigenschaften. Das Hinzufügen von git_version.txt und VersionInfo.cs zu .gitignore ist eine gute Idee.

Einbettung der Version in Metadaten

Ich habe VersionInfo.ttmeinem Projekt eine Vorlage hinzugefügt :

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.IO" #>
<#@ output extension=".cs" #>

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

<#
if (File.Exists(Host.ResolvePath("git_version.txt")))
{
    Write("[assembly: AssemblyInformationalVersion(\""+ File.ReadAllText(Host.ResolvePath("git_version.txt")).Trim() + "\")]");
}else{
    Write("// version file not found in " + Host.ResolvePath("git_version.txt"));
}

#>

Jetzt habe ich mein Git-Tag + Hash in "ProductVersion".

Unter Bezugnahme auf die andere Antwort ( https://stackoverflow.com/a/44278482/4537127 ) habe ich auch die VersionInfo.ttTextvorlage verwendet, um AssemblyInformationalVersionohne AutoT4 zu generieren .

(Mindestens funktioniert in meiner C # WPF-Anwendung)

Das Problem war, dass die Pre-Build-Ereignisse nach Vorlagentransformationen ausgeführt wurden. Nach dem Klonen war die git_version.txtDatei nicht vorhanden und der Build schlägt fehl. Nachdem es manuell erstellt wurde, damit die Transformation einmal bestanden werden kann, wurde es nach der Transformation aktualisiert und war immer ein Commit dahinter .

Ich musste zwei Anpassungen an der .csproj-Datei vornehmen (dies gilt zumindest für Visual Studio Community 2017).

1) Importieren Sie die Texttransformationsziele und führen Sie Vorlagentransformationen durch, die bei jedem Build ausgeführt werden sollen: (Siehe https://msdn.microsoft.com/en-us/library/ee847423.aspx )

<PropertyGroup>
    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">15.0</VisualStudioVersion>
    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
    <TransformOnBuild>true</TransformOnBuild>
    <TransformOutOfDateOnly>false</TransformOutOfDateOnly>
</PropertyGroup>

und danach <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

<Import Project="$(VSToolsPath)\TextTemplating\Microsoft.TextTemplating.targets" />

2) git describeFühren Sie den Lauf vor den Template-Transformationen durch (damit er vorhanden git_version.txtist, wenn er VersionInfo.tttransformiert wird):

<Target Name="PreBuild" BeforeTargets="ExecuteTransformations">
  <Exec Command="git -C $(ProjectDir) describe --long --always --dirty &gt; $(ProjectDir)git_version.txt" />
</Target>

..Und den C # -Code, um den zu erhalten AssemblyInformationalVersion(Ref https://stackoverflow.com/a/7770189/4537127 )

public string AppGitHash
{
    get
    {
        AssemblyInformationalVersionAttribute attribute = (AssemblyInformationalVersionAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false).FirstOrDefault();

        return attribute.InformationalVersion;
    }
}

..Und fügen Sie die generierten Dateien zu .gitignore hinzu

VersionInfo.cs
git_version.txt

Eine andere Möglichkeit wäre, eine Version.cs-Datei aus einem Pre-Build-Schritt zu generieren. Ich habe dies in einem kleinen Proof-of-Concept-Projekt untersucht, in dem der aktuelle Commit-Hash ausgedruckt wird.

Das Projekt wird auf https://github.com/sashoalm/GitCommitHashPrinter hochgeladen .

Der Stapelcode, der die Datei Version.cs erstellt, lautet wie folgt:

@echo off

echo "Writing Version.cs file..."

@rem Pushd/popd are used to temporarily cd to where the BAT file is.
pushd $(ProjectDir)

@rem Verify that the command succeeds (i.e. Git is installed and we are in the repo).
git rev-parse HEAD || exit 1

@rem Syntax for storing a command's output into a variable (see https://stackoverflow.com/a/2340018/492336).
@rem 'git rev-parse HEAD' returns the commit hash.
for /f %%i in ('git rev-parse HEAD') do set commitHash=%%i

@rem Syntax for printing multiline text to a file (see https://stackoverflow.com/a/23530712/492336).
(
echo namespace GitCommitHashPrinter
echo {
echo     class Version
echo     {
echo         public static string CommitHash { get; set; } = "%commitHash%";
echo     }
echo }
)>"Version.cs"

popd    

Platz

<Target Name="UpdateVersion" BeforeTargets="CoreCompile">
  <Exec Command="php &quot;$(SolutionDir)build.php&quot; $(SolutionDir) &quot;$(ProjectDir)Server.csproj&quot;" />
</Target>

im YOUR_PROJECT_NAME.csproj

<?php

function between(string $string, string $after, string $before, int $offset = 0) : string{
    return substr($string, $pos = strpos($string, $after, $offset) + strlen($after),
        strpos($string, $before, $pos) - $pos);
}

$pipes = [];
$proc = proc_open("git rev-parse --short HEAD", [
    0 => ["pipe", "r"],
    1 => ["pipe", "w"],
    2 => ["pipe", "w"]
], $pipes, $argv[1]);

if(is_resource($proc)){
    $rev = stream_get_contents($pipes[1]);
    proc_close($proc);
}

$manifest = file_get_contents($argv[2]);
$version = between($manifest, "<Version>", "</Version>");
$ver = explode("-", $version)[0] . "-" . trim($rev);
file_put_contents($argv[2], str_replace($version, $ver, $manifest));

echo "New version generated: $ver" . PHP_EOL;