17. Jul 2023
Lesedauer 12 Min.
Git-Kommandos in C#
Frameworks: LibGit2Sharp
Die Versionsverwaltung Git ist aus der Softwareentwicklung nicht mehr wegzudenken. Mit LibGit2Sharp steuern Sie sie.

Mit der Version 2013 hat Microsoft Unterstützung für Git im Team Foundation Server angeboten. Das inzwischen in Azure DevOps Server umbenannte Produkt setzt dabei auf die Bibliothek libgit2 – genauso wie die .NET-Bibliothek LibGit2Sharp, um die es in dieser Ausgabe von Frameworks und mehr gehen soll.LibGit2Sharp implementiert die Git-Core-Methoden, erleichtert die Integration von Git-Funktionen in .NET-Projekte erheblich und bietet so die Möglichkeit, Git in .NET zu automatisieren. Dieser Artikel führt in die verschiedenen Aspekte von LibGit2Sharp ein, angefangen bei der Installation über die Kernfunktionen und den Zugriff auf Repositories bis hin zu spezifischen Git-Befehlen wie status, add, commit, pull, push und diff. Auch die Arbeit mit Branches und weiteren Operationen steht auf dem Programm.
Herausforderungen und Lösungen bei der Git-Automatisierung
Git hat sich als De-facto-Standard für die Versionskontrolle in der Softwareentwicklung etabliert. Millionen von Entwicklern weltweit nutzen Git tagtäglich über die Kommandozeile oder in Tools wie Entwicklungsumgebungen. Die Automatisierung von Git, notwendig zur Vereinfachung von Workflows, kann jedoch mehrere Herausforderungen mit sich bringenGit wurde ursprünglich als Kommandozeilenwerkzeug entwickelt, und viele seiner Funktionen sind nach wie vor am besten über die Kommandozeile zugänglich. Das Erlernen und Beherrschen der vielen spezifischen Git-Kommandos kann für viele Entwickler, insbesondere für diejenigen ohne starke Erfahrung mit der Kommandozeile, eine Herausforderung darstellen. Gleichzeitig ist die Automatisierung über die Kommandozeilenaufrufe in vielen Situationen möglich, auch über kleinere Skripte, die gut lokal funktionieren.Während Git auf vielen verschiedenen Betriebssystemen funktioniert, kann die Art und Weise, wie es auf verschiedenen Plattformen läuft, variieren. Diese Unterschiede können die Automatisierung erschweren, insbesondere wenn es darum geht, Git-Operationen auf heterogenen Systemen zu standardisieren.Darüber hinaus ist Git ein äußerst mächtiges Werkzeug mit einer Vielzahl von Operationen und Optionen, die es zu beherrschen gilt. Einige dieser Operationen sind komplex und erfordern ein tiefes Verständnis der Interna von Git. Dies kann die Automatisierung bestimmter Arbeitsabläufe kompliziert und fehleranfällig machen.Abseits von Bibliotheken für die unterschiedlichen Plattformen und Programmiersprachen existieren auch andere Lösungen, die bei der Automatisierung von Git helfen.Tools für Continuous Integration und Continuous Deployment (CI/CD) wie Jenkins, CircleCI, GitLab CI/CD und GitHub Actions verfügen über eingebaute Funktionen für die Automatisierung von Git-Operationen. Diese Tools können eine Vielzahl von Aufgaben ausführen, wie das Auschecken von Code aus einem Repository, das automatische Durchführen von Tests bei jedem Push und das Bereitstellen von Anwendungen nach dem erfolgreichen Durchlaufen der Tests. Sie erlauben es somit, zahlreiche auf Git basierte Workflows zu automatisieren.Was ist LibGit2Sharp?
LibGit2Sharp ist ein .NET-Wrapper für libgit2, eine plattformübergreifende Bibliothek, die den Großteil der Git-Funktionalität implementiert. Weitere Informationen zu libgit2 finden Sie im Kasten libgit2: Die Basis von LibGit2Sharp. Durch die Verwendung von LibGit2Sharp bietet sich die Möglichkeit, Git-Operationen direkt aus C#- oder .NET-Code heraus auszuführen. Das Team rund um LibGit2Sharp hat die Bibliothek im Jahr 2011 ins Leben gerufen und diese seitdem ständig weiterentwickelt. Mit Stand Juni 2023 liegt die Version bei 0.27.2, die Mitte April 2023 veröffentlicht wurde. Der Quelltext ist Open Source und steht auf GitHub [1] zur Verfügung.libgit2: Die Basis von LibGit2Sharp
Die plattformübergreifende C-Bibliothek implementiert die Kernfunktionalität von Git. Im Gegensatz zu Git, das als eigenständiges Kommandozeilenwerkzeug ausgeführt wird, muss libgit2 als Softwarebibliothek innerhalb einer Anwendung eingebunden werden. Die Bibliothek unterstützt eine breite Palette von Git-Operationen, darunter das Arbeiten mit Repositories, Commits, Branches, Tags, Blobs und vieles mehr. Da sie in C geschrieben ist, kann libgit2 auf fast jeder Plattform und in jeder Umgebung verwendet werden, in der C-Code ausgeführt werden kann. libgit2 ist die Grundlage für mehrere höherstufige Git-Bibliotheken in verschiedenen Programmiersprachen, einschließlich LibGit2Sharp für .NET, Rugged für Ruby, NodeGit für Node.js und ObjectiveGit für Objective-C. Hier kommt libgit2 als Binding zum Einsatz und ermöglicht so die Nutzung auf vielen verschiedenen Plattformen und in unterschiedlichsten Programmiersprachen.
Installation
Die Installation von LibGit2Sharp in ein .NET-Projekt ist dank des NuGet-Paketmanagers ein einfacher Prozess. Beispielsweise über die Befehlszeile:dotnet add <span class="hljs-keyword">package</span> <span class="hljs-title">LibGit2Sharp</span>
oder über die Paketmanager-Konsole in Visual Studio:
Install-<span class="hljs-keyword">Package</span> <span class="hljs-title">LibGit2Sharp</span>
Wir müssen noch sicherstellen, dass das Projekt auf eine
.NET-Version abzielt, die mit LibGit2Sharp kompatibel ist. Zum Zeitpunkt des Schreibens dieses Artikels unterstützt LibGit2Sharp .NET Framework 4.6 und höher sowie .NET Core 2.0 und höher.
.NET-Version abzielt, die mit LibGit2Sharp kompatibel ist. Zum Zeitpunkt des Schreibens dieses Artikels unterstützt LibGit2Sharp .NET Framework 4.6 und höher sowie .NET Core 2.0 und höher.
Hauptfunktionen von LibGit2Sharp
LibGit2Sharp bietet eine breite Palette an Funktionen, die das gesamte Spektrum der Git-Funktionalität abdecken. Im Folgenden sind einige der wichtigsten Funktionen und Features aufgeführt, die die Bibliothek zu einer robusten und vielseitigen Lösung für die Arbeit mit Git in .NET-Anwendungen machen. Die Bibliothek erlaubt es, auf lokale und entfernte Git-Repositories zuzugreifen.Wir können diese Repositories klonen oder direkt initialisieren. Des Weiteren lässt sich der Status von Repositories abfragen und es ist möglich, diese zu aktualisieren und die darin enthaltenen Dateien und Verzeichnisse zu verwalten.Mit LibGit2Sharp lassen sich zudem neue Commits erstellen, vorhandene Commits abrufen sowie bearbeiten und Informationen über einzelne Commits, wie den Autor, das Datum und die Commit-Nachricht, abrufen.Auch die Arbeit mit Branches ist problemlos möglich. Die Bibliothek bietet Funktionen an, um neue Branches zu erstellen, bestehende Branches zu löschen oder umzubenennen, zwischen Branches zu wechseln und Informationen über einzelne Branches abzurufen.Darüber hinaus sind in LibGit2Sharp Features zur Verwaltung von Tags zu Commits eingebaut, um vorhandene Tags zu löschen oder zu bearbeiten und Informationen über einzelne Tags abzurufen.LibGit2Sharp ermöglicht es zudem, Diffs zwischen verschiedenen Versionen eines Repositorys zu erzeugen und zu analysieren. Sie können Diffs auf Datei- oder Commit-Ebene erstellen und detaillierte Informationen über jede Änderung abrufen, die in einem Diff enthalten ist.Zusätzlich bietet die Bibliothek umfangreiche Unterstützung für Remote-Operationen, einschließlich fetch, push und pull. Wir können somit auf entfernte Repositories zugreifen, Änderungen von einem Remote-Repository abrufen oder Änderungen an dieses senden und Informationen über entfernte Repositories und Branches abrufen.Merge-Operationen stehen ebenfalls zur Verfügung, um Änderungen aus einem Branch in einen anderen zu übernehmen. Die Bibliothek bietet auch Unterstützung für das Lösen von Merge-Konflikten.Zu guter Letzt ist die Unterstützung für Submodule erwähnenswert. LibGit2Sharp unterstützt die Arbeit mit Git-Submodulen, was die Einbindung und Verwaltung von Abhängigkeiten in einem Git-Repository erleichtert.Zusätzlich zu diesen Kernfunktionen bietet LibGit2Sharp eine Vielzahl von weiteren Funktionen und Utilities an, um die Arbeiten mit Git in .NET-Anwendungen einfacher und effizienter zu machen. Durch die Kombination all dieser Funktionen ist LibGit2Sharp eine umfassende Lösung für die Integration von Git-Funktionalität in .NET-Softwareprojekte.Zugriff auf Repositories
Mit LibGit2Sharp ist der Zugriff auf Git-Repositories auf unterschiedliche Arten möglich. In den meisten Fällen geschieht dies durch Erstellen eines Repository-Objekts, das als Ausgangspunkt für die Interaktion mit dem Repository dient. Um auf ein bestehendes lokales Repository zuzugreifen, verwenden wir die Repository-Klasse und geben den Pfad zum Repository an:<span class="hljs-keyword">const</span> <span class="hljs-keyword">string</span> repoPath = @<span class="hljs-string">"E:\git\<repository>"</span>;
<span class="hljs-keyword">using</span> (var repo = <span class="hljs-keyword">new</span> Repository(repoPath))
{
<span class="hljs-built_in">Console</span>.WriteLine(repo.Head.FriendlyName);
}
In diesem Beispiel öffnet die Repository-Klasse das angegebene Repository und gibt ein Repository-Objekt zurück, das wir nutzen können, um mit dem Repository zu interagieren. Ähnlich funktioniert das beim Klonen eines entfernten Repositorys. Hier kommt die Clone-Methode der Repository-Klasse zum Einsatz:
<span class="hljs-keyword">const</span> <span class="hljs-built_in">string</span> remoteUrl =
<span class="hljs-string">"https://github.com/"</span> +
<span class="hljs-string">"fdeitelhoff/rxtx"</span>;
<span class="hljs-keyword">const</span> <span class="hljs-built_in">string</span> localPath =
@<span class="hljs-string">"E:\git\2"</span> +
<span class="hljs-string">"LibGit2SharpDemo-checkout"</span>;
Repository.Clone(remoteUrl,
localPath);
Dieses Beispiel nutzt die Clone-Methode, um das angegebene entfernte Repository in das lokale Verzeichnis zu klonen und dabei ein neues Git-Repository zu erstellen. Für den Zugriff auf geschützte Repositories sind Authentifizierungsdaten anzugeben. Ist das lokale Verzeichnis bereits vorhanden, erscheint eine nicht sonderlich hilfreiche Exception:
Fatal <span class="hljs-keyword">error</span>. System.AccessViolationException: Attempted <span class="hljs-keyword">to</span> <span class="hljs-built_in">read</span> <span class="hljs-keyword">or</span> <span class="hljs-built_in">write</span> protected memory. This <span class="hljs-keyword">is</span> often an indication <span class="hljs-keyword">that</span> other memory <span class="hljs-keyword">is</span> corrupt.
Die Fehlermeldung hilft uns nicht wirklich weiter; sie scheint aus dem darunterliegenden libgit2 zu stammen.Die dritte Variante
<span class="hljs-keyword">const</span> <span class="hljs-built_in">string</span> initRepoPath =
@<span class="hljs-string">"E:\git\LibGit2SharpDemo-init"</span>;
Repository.Init(initRepoPath);
verdeutlicht, wie ein neues lokales Repository initialisiert wird. Die Init-Methode erstellt das neue Git-Repository im angegebenen Verzeichnis.
Git status und Git add
Mit LibGit2Sharp können wir zudem die Git-Befehle status und add einfach und effizient nutzen. Diese beiden Befehle sind grundlegend für den Workflow mit Git, da sie das Verwalten und Vorbereiten von Änderungen für Commits ermöglichen. git status gibt den aktuellen Status des Arbeitsverzeichnisses aus, einschließlich aller neuen, geänderten und gelöschten Dateien. Mit LibGit2Sharp funktioniert das so:<span class="hljs-function"><span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">ShowStatus</span>(<span class="hljs-params"><span class="hljs-keyword">string</span> repoPath</span>)</span>
{
<span class="hljs-keyword">using</span> <span class="hljs-keyword">var</span> repo = <span class="hljs-keyword">new</span> Repository(repoPath);
<span class="hljs-keyword">var</span> status = repo.RetrieveStatus(<span class="hljs-keyword">new</span> StatusOptions());
<span class="hljs-keyword">foreach</span> (<span class="hljs-keyword">var</span> change <span class="hljs-keyword">in</span> status)
{
Console.WriteLine(<span class="hljs-string">"{0} {1}"</span>,
change.State, change.FilePath);
}
}
ShowStatus(repoPath);
Dieses Beispiel nutzt das Repository-Objekt, das den Pfad zu Ihrem Git-Repository enthält, um mit der Methode RetrieveStatus den aktuellen Status des Repositorys abzurufen und die Änderungen aufzulisten. Knackpunkt hier ist die zurückgelieferte RepositoryStatus-Instanz. Sie enthält die verschiedenen Informationen zu allen möglichen Änderungen, die im Repository durchgeführt wurden – beispielsweise zu hinzugefügten, gelöschten oder modifizierten Dateien. Einen kleinen Überblick dieser Klasse gibt Bild 1.

Ausschnitt der KlasseRepositoryStatus(Bild 1)
Autor
Mit git add lassen sich neue oder geänderte Dateien zur Staging-Area hinzufügen, damit diese im nächsten Commit enthalten sind.
static void AddFile(string repositoryPath,
string filePath)
{
using var repo = new Repository(repositoryPath);
Commands.Stage(repo, filePath);
}
Das Beispiel nutzt wie bisher üblich ein Repository-Objekt, um auf das Repository zuzugreifen. Über die Methode Commands.Stage wird die angegebene Datei zur Staging-Area hinzuzugefügt. Wir können zudem einen Pfad zu einem Verzeichnis oder ein globales Muster, wie beispielsweise *.cs, angeben, um mehrere Dateien auf einmal hinzuzufügen.
Git commit, pull, push und diff
Genauso einfach lassen sich die Git-Befehle commit, pull, push und diff in eigenen Anwendungen nutzen. Der git-commit-Befehl dient dazu, Änderungen im Repository zu speichern. Listing 1 zeigt dazu ein Beispiel, bei dem zuerst ein Signature-Objekt erstellt wird, das den Autor des Commits repräsentiert. Anschließend kommt die Commit-Methode zum Einsatz, um den Commit zu erstellen.Listing 1: Erstellen eines Commits
using (var repo = new Repository(repoPath))<br/>{<br/> // Stage<br/> repo.Index.Add("fileToCommit.txt");<br/> repo.Index.Write();<br/><br/> // Create the signature and commit<br/> var author = new Signature("Fabian", <br/> "fabian@deitelhoff.me", DateTime.Now);<br/> var committer = author;<br/><br/> // Commit to the repository<br/> var commit = repo.Commit("&lt;Commit Message&gt;", <br/> author, committer);<br/>}
Der Befehl git pull holt Änderungen aus einem Remote-Repository und verschmilzt diese Änderungen mit dem lokalen Repository. Listing 2 zeigt dazu ein Beispiel. Zum Pullen wird zunächst ein PullOptions-Objekt definiert, das die Authentifizierungsinformationen enthält. Anschließend rufen wir die Commands.Pull-Methode auf, um die Änderungen zu holen und zu verschmelzen.
Listing 2: Das Pullen von Änderungen mittels „git pull“
static void PullChanges(string repositoryPath, <br/> string username, string password)<br/>{<br/> using var repo = new Repository(repositoryPath);<br/> var options = new PullOptions<br/> {<br/> FetchOptions = new FetchOptions<br/> {<br/> CredentialsProvider = (_url, _user, _cred) =&gt; <br/> new UsernamePasswordCredentials<br/> { Username = username, <br/> Password = password }<br/> }<br/> };<br/><br/> var signature = new Signature(<br/> new Identity(username, "&lt;email&gt;"), <br/> DateTimeOffset.Now);<br/> Commands.Pull(repo, signature, options);<br/>}<br/><br/>PullChanges(repoPath, "&lt;username&gt;", "&lt;password&gt;");
Mittels git push senden wir Änderungen an ein Remote-Repository. Ein Beispiel für den push-Befehl mit LibGit2Sharp sieht wie in Listing 3 aus. In diesem Beispiel kommt erneut eine CredentialsProvider-Instanz zum Einsatz, um die Authentifizierung beim Remote-Repository zu übernehmen. Anschließend ist die Push-Methode im Einsatz, um die Änderungen zu senden.
Listing 3: Das Pushen von Änderungen
static void PushChanges(string repositoryPath, <br/> string remoteName, string username, <br/> string password)<br/>{<br/> using var repo = new Repository(repositoryPath);<br/> var options = new PushOptions<br/> {<br/> CredentialsProvider = (_url, _user, _cred) =&gt; <br/> new UsernamePasswordCredentials<br/> { Username = username, Password = password }<br/> };<br/> repo.Network.Push(<br/> repo.Network.Remotes[remoteName], <br/> @"refs/heads/main", options);<br/>}<br/><br/>PushChanges(repoPath, "&lt;remote-name&gt;", "&lt;username&gt;", <br/> "&lt;password&gt;");
git diff zeigt die Unterschiede zwischen Commits, dem Arbeitsverzeichnis und der Staging-Area an. Listing 4 enthält dazu ein Beispiel. Es nutzt die Compare<TreeChanges>-Methode, um die Unterschiede zwischen dem aktuellen Commit und dem Arbeitsverzeichnis zu ermitteln. Diese Änderungen werden in der Demo-Anwendung anschließend auf der Konsole ausgegeben.
Listing 4: Änderungen anzeigen über „gif diff“ und LibGit2Sharp.
static void ShowDiff(string repositoryPath)<br/>{<br/> using var repo = new Repository(repositoryPath);<br/> var changes = repo.Diff.Compare&lt;TreeChanges&gt;(<br/> repo.Head.Tip.Tree, DiffTargets.WorkingDirectory);<br/> foreach (var change in changes)<br/> {<br/> Console.WriteLine("{0} {1}", change.Status, <br/> change.Path);<br/> }<br/>}<br/><br/>ShowDiff(repoPath);
Die Arbeit mit Branches
Auch die Arbeit mit Branches ist in LibGit2Sharp möglich, wie die nachfolgenden Beispiele zeigen. Die CreateBranch-Methode dient beispielsweise dazu, einen Branch anzulegen:static void CreateBranch(
string repositoryPath, string branchName)
{
using var repo = new Repository(repositoryPath);
var newBranch =
repo.Branches.Add(branchName, repo.Head.Tip);
}
CreateBranch(repoPath, "<branch-name>");
Der neue Branch basiert dabei auf dem letzten Commit des aktuellen Branchs, dargestellt durch repo.Head.Tip.Existiert ein Branch schon, ist eine übliche Git-Operation, diesen auszuchecken. Das übernimmt die Checkout-Methode:
static void CheckoutBranch(
string repositoryPath, string branchName)
{
using var repo = new Repository(repositoryPath);
var branch = repo.Branches[branchName];
Commands.Checkout(repo, branch);
}
CheckoutBranch(repoPath, "<branch-name>");
Über die Eigenschaft Branches können wir auf alle Branches über den Namen als Index zugreifen. Damit ist eine einfache Suche möglich. Soll ein Branch umbenannt werden, greifen wir auf die Rename-Methode auf dem Branch-Objekt zurück:
static void RenameBranch(string repositoryPath,
string oldBranchName, string newBranchName)
{
using var repo = new Repository(repositoryPath);
var branch =
repo.Branches.Rename(oldBranchName, newBranchName);
}
RenameBranch(
repoPath, "<old-branch-name>", "<new-branch-name>");
Ähnlich simpel ist das Löschen eines vorhandenen Branchs, was über die Remove-Methode funktioniert:
static void DeleteBranch(
string repositoryPath, string branchName)
{
using var repo = new Repository(repositoryPath);
repo.Branches.Remove(branchName);
}
DeleteBranch(repoPath, "<branch-name>");
Diese Beispiele zeigen, wie einfach und intuitiv das Arbeiten mit Branches in LibGit2Sharp ist. Häufig ist ein einfacher Methodenaufruf genug, um die gewünschte Aktion durchzuführen.
Git checkout und fetch
Den Checkout haben wir bereits in einem vorherigen Beispiel gezeigt. Listing 5 verdeutlicht daher, wie Änderungen über einen Aufruf von Fetch abgerufen werden können. Im Beispiel wird zuerst eine FetchOptions-Instanz mit den Anmeldeinformationen definiert, um sich am Remote-Repository zu authentifizieren. Danach identifizieren wir das Remote-Repository mit dem Remote-Namen und verwenden schließlich die Commands.Fetch-Methode, um die Änderungen vom Remote-Repository zu holen.Listing 5: Änderungen abrufen mittels Fetch-Operation
static void FetchChanges(string repositoryPath, <br/> string remoteName, string username, <br/> string password)<br/>{<br/> using var repo = new Repository(repositoryPath);<br/> var options = new FetchOptions<br/> {<br/> CredentialsProvider = (_url, _user, _cred) =&gt; <br/> new UsernamePasswordCredentials<br/> { Username = username, Password = password }<br/> };<br/> var remote = repo.Network.Remotes[remoteName];<br/> Commands.Fetch(repo, remote.Name, <br/> Array.Empty&lt;string&gt;(), options, "");<br/>}<br/><br/>FetchChanges(repoPath, "&lt;remote-name&gt;", <br/> "&lt;username&gt;", "&lt;password&gt;");
Alternativen
Neben LibGit2Sharp gibt es weitere Lösungen, die nicht auf C# beschränkt sind oder andere Vorteile bieten:- JGit [2] ist eine rein Java-basierte Bibliothek, die die Kernfunktionalitäten von Git implementiert. Da sie in Java implementiert ist, ist sie plattformunabhängig und lässt sich auf jedem System nutzen, auf dem eine Java Virtual Machine (JVM) läuft. JGit bietet ein umfassendes API für die Interaktion mit Git-Repositories und unterstützt eine Vielzahl von Git-Operationen.
- GitPython [3] ist eine Python-Bibliothek, die es ermöglicht, Git-Direktiven in Python-Code zu integrieren. Damit lassen sich Git-Repositories erstellen und klonen, Commits, Branches und Tags erstellen sowie verwalten und vieles mehr. GitPython bietet auch Unterstützung für fortgeschrittenere Git-Funktionen, wie das Arbeiten mit Git-Submodulen und das Durchführen von diff- und merge-Operationen.
- NodeGit [4] ist eine Node.js-Bibliothek, die eine AJAX-Schnittstelle (Asynchronous JavaScript and XML) zur libgit2-Bibliothek bietet. Mit NodeGit lassen sich Git-Operationen aus einem Node.js-Code heraus ausführen, inklusive der Arbeit mit Repositories, Commits und Branches und der Durchführung von fetch-, push- und pull-Operationen.
- Rugged [5] ist eine Ruby-Bibliothek, die die libgit2-Bibliothek umschließt und eine Ruby-freundliche Schnittstelle zu ihren Funktionen bietet. Mit Rugged können wir Git-Repositories erstellen und klonen, Commits erstellen und abrufen, mit Branches und Tags arbeiten und viele andere Git-Operationen durchführen. Wer auf der Suche nach einer leistungsfähigen, Ruby-nativen Bibliothek zur Arbeit mit Git ist, für den könnte Rugged eine gute Wahl sein.
- Octokit.NET [6], das bereits vor einiger Zeit im Rahmen von Frameworks und mehr besprochen wurde [7], ist eine Client-Bibliothek für .NET, die es ermöglicht, mit dem GitHub-API zu interagieren und eine Vielzahl von Aktionen durchzuführen, darunter das Verwalten von Repositories, das Arbeiten mit Issues und Pull Requests und vieles mehr.
- NGit [8] ist eine .NET-Portierung der JGit-Bibliothek, die in Java geschrieben ist. NGit implementiert das gesamte Git-Protokoll und bietet ein leistungsstarkes API für die Arbeit mit Git-Repositories. NGit arbeitet ähnlich wie LibGit2Sharp.
- GitSharp [9] ist eine weitere .NET-Implementierung von Git. Es bietet ein umfassendes API für die Arbeit mit Git-Repositories und unterstützt eine breite Palette von Git-Operationen. Die Weiterentwicklung von GitSharp ist jedoch seit einigen Jahren nicht mehr aktiv, sodass möglicherweise Probleme mit den neuesten Versionen von Git oder .NET/C# auftreten können. Es kann dennoch eine geeignete Option sein, wenn eine einfache, leicht zu bedienende Bibliothek für grundlegende Git-Operationen notwendig ist.
- SharpGit [10] ist eine .NET-Bibliothek, die auf der libgit2-Bibliothek aufbaut und ein einfaches API für die Durchführung von Git-Operationen bietet. Obwohl sie nicht so umfangreich oder flexibel ist wie LibGit2Sharp, kann SharpGit eine gute Wahl sein, wenn nur grundlegende Git-Operationen gebraucht werden.
Fazit
LibGit2Sharp ist ein äußerst nützliches Werkzeug für alle, die eine tiefe Integration mit Git in ihre .NET-Anwendungen anstreben. Die Bibliothek bietet einen direkten Zugang zu den mächtigen Funktionen von Git, und das alles auf eine Weise, die sich nahtlos in den C#-Code einfügt.Unabhängig davon, ob Sie ein lokales Repository verwalten oder komplexe Operationen auf entfernten Repositories ausführen möchten: LibGit2Sharp bietet die notwendige Flexibilität und Kontrolle, um dies effektiv und effizient zu tun.Es ist jedoch wichtig, sich daran zu erinnern, dass keine Lösung alle Probleme behebt. Abhängig von den spezifischen Anforderungen und dem Kontext einer Anwendung können andere Git-Bibliotheken besser geeignet sein. Unter Umständen ist zudem eine andere Art der Automatisierung sinnvoll, beispielsweise über Skripte auf der Kommandozeile. In diesem Sinne dient dieser Artikel als Leitfaden und Ausgangspunkt, um die verschiedenen Optionen zu erkunden und diejenige zu wählen, die am besten zu den Bedürfnissen passt.Insgesamt ist LibGit2Sharp eine ausgezeichnete Bibliothek und verdient sich ein „Sehr gut“ inklusive Empfehlung. Wer auf der Suche nach einer guten Bibliothek für die Integration von Git in .NET-Anwendungen ist, findet bei LibGit2Sharp ein passendes Projekt.Fussnoten
- LibGit2Sharp auf GitHub, http://www.dotnetpro.de/SL2308Frameworks1
- JGit, http://www.eclipse.org/jgit
- GitPython, https://gitpython.readthedocs.io
- NodeGit, http://www.nodegit.org
- Rugged auf GitHub, http://www.dotnetpro.de/SL2308Frameworks2
- Octokit.NET auf GitHub, http://www.dotnetpro.de/SL2308Frameworks3
- Fabian Deitelhoff, Zugriff auf GitHub, dotnetpro 9/2015, Seite 94 ff., http://www.dotnetpro.de/A1509Frameworks
- NGit auf GitHub, http://www.dotnetpro.de/SL2308Frameworks4
- GitSharp auf GitHub, http://www.dotnetpro.de/SL2308Frameworks5
- SharpGit auf GitHub, http://www.dotnetpro.de/SL2308Frameworks6