C# NuGet dotnet CLI: Pakete & Projekte einfach erklärt

Stell dir vor: Es ist dein erster Tag im Entwicklerteam und dein Kollege ruft dir zu: „Installier doch mal das Newtonsoft.Json-Paket per NuGet!" Wenn du darauf nur Bahnhof verstehst, bist du hier genau richtig. Du lernst in diesem Artikel, wie du mit der dotnet CLI ein C#-Projekt anlegst, NuGet-Pakete installierst, aktualisierst und wieder entfernst. Am Ende steht ein kleines, lauffähiges Programm, das JSON-Daten mit einem echten Fremd-Paket verarbeitet.

Was sind NuGet und die dotnet CLI?

NuGet ist der Paketmanager für .NET - quasi der App Store für C#-Bibliotheken. Ein NuGet-Paket ist eine gepackte Datei (eigentlich ein ZIP-Archiv) mit vorkompiliertem Code, den andere Entwickler bereitgestellt haben. Statt einen JSON-Parser selbst zu schreiben, lädst du einfach ein fertiges Paket herunter. Warum? Weil bewährte Pakete getestet, dokumentiert und sicherer gepflegt sind als Eigenbauten.

Die dotnet CLI ist das Kommandozeilenwerkzeug im .NET SDK (Software Development Kit). Denk daran wie an ein Schweizer Taschenmesser: ein Werkzeug, das Projekte erstellt, Pakete verwaltet, Code baut und startet - ganz ohne Visual Studio. Die offizielle Referenz findest du auf Microsoft Learn, den Paket-Katalog auf nuget.org.

Die wichtigsten Befehle im Überblick:

Merke: NuGet ist der Paketmanager, die dotnet CLI ist dein Werkzeug dafür - beides kommt kostenlos mit dem .NET SDK.

Welche Voraussetzungen brauchst du?

Du brauchst drei Dinge:

1. Das .NET SDK, kostenlos auf dotnet.microsoft.com. Prüfe die Installation im Terminal mit `dotnet --version`. Gibt der Befehl eine Versionsnummer aus, bist du startklar.

2. Grundlagen in C#: Variablen, Klassen und Methoden solltest du kennen. Falls du bei Datentypen wie Records nachschlagen willst, wirf einen Blick in unseren Beitrag zu C# Records.

3. Ein Terminal deiner Wahl: PowerShell unter Windows, die Bash unter Linux oder macOS - die Befehle sind überall identisch.

Übrigens: In der Ausbildung, im Studium oder im ersten Job wirst du fast immer mit genau dieser Kombination arbeiten - Visual Studio ist komfortabel, aber die CLI läuft überall, auch auf Servern und in CI-Pipelines.

Schritt 1: Wie legst du ein Projekt an?

Mit `dotnet new` erstellst du ein Projekt aus einer Vorlage (englisch: Template). Für ein simples Konsolenprogramm nutzt du die Vorlage `console`:

# Neues Konsolenprojekt im Ordner PaketDemo anlegen
dotnet new console -n PaketDemo

# In den Projektordner wechseln
cd PaketDemo

# Projekt starten
dotnet run

Nach `dotnet run` erscheint `Hello, World!` in der Konsole. Im Ordner liegen jetzt zwei wichtige Dateien: `Program.cs` mit deinem Code und `PaketDemo.csproj`, die Projektdatei. Merk dir die `.csproj` - sie wird gleich zentral.

Schritt 2: Wie installierst du ein NuGet-Paket?

Die Installation läuft über `dotnet add package`. Vorher suchst du am besten auf nuget.org nach einem passenden Paket - zum Beispiel nach Newtonsoft.Json, dem beliebtesten JSON-Paket für .NET. Neuere Versionen des .NET CLI bieten dafür auch den Befehl `dotnet package search` an.

dotnet add package Newtonsoft.Json

Der Befehl macht zwei Dinge: Er trägt das Paket als PackageReference in deine `.csproj` ein und lädt es sofort herunter. Danach findest du in der Projektdatei etwa Folgendes:

<ItemGroup>
  <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
</ItemGroup>

Merke: Die `.csproj` ist deine Einkaufsliste - dort steht, welche Pakete in welcher Version das Projekt braucht. Die Paketdateien selbst liegen global im NuGet-Cache, nicht im Projektordner.

Schritt 3: Wie verwendest du das Paket im Code?

Nach der Installation bindest du die Klassen des Pakets per `using`-Anweisung ein. So serialisierst du ein Objekt nach JSON (einem Textformat zum Datenaustausch):

using Newtonsoft.Json;

var person = new { Name = "Anna", Alter = 28 };
string json = JsonConvert.SerializeObject(person, Formatting.Indented);
Console.WriteLine(json);

Schritt 4: Wie verwaltest du Pakete - auflisten, aktualisieren, entfernen?

Drei Befehle brauchst du ständig:

# Zeigt alle installierten Pakete inkl. Version
dotnet list package

# Prueft, ob Updates verfuegbar sind
dotnet list package --outdated

# Entfernt ein Paket wieder aus dem Projekt
dotnet remove package Newtonsoft.Json

Dazu kommt `dotnet restore`: Dieser Befehl liest die `.csproj` und lädt alle fehlenden Pakete nach. Das passiert beim Bauen normalerweise automatisch - aber wenn du ein frisch geklontes Git-Repository aufsetzt, ist ein manueller `dotnet restore` oft die schnelle Lösung. Die Details erklärt die NuGet-Dokumentation auf Microsoft Learn.

Guter Stil: Aktualisiere Pakete bewusst und einzeln, nicht blind alles auf einmal. Neue Hauptversionen (Major Versions) können Verhaltensänderungen mitbringen, die deinen Code brechen können.

Vollständiges Beispiel: Alle Schritte zusammen

Hier das komplette Vorgehen von null bis lauffähigem Programm:

dotnet new console -n PaketDemo
cd PaketDemo
dotnet add package Newtonsoft.Json

Ersetze danach den Inhalt von `Program.cs` durch diesen Code:

using System;
using System.Collections.Generic;
using Newtonsoft.Json;

namespace PaketDemo
{
  // Ein Record haelt die Daten einer Person
  public record Person(string Name, int Alter);

  class Program
  {
    static void Main(string[] args)
    {
      var leute = new List<Person>
      {
        new Person("Anna", 28),
        new Person("Ben", 35)
      };

      // Objektliste nach JSON serialisieren
      string json = JsonConvert.SerializeObject(leute, Formatting.Indented);
      Console.WriteLine(json);

      // JSON wieder zurueck in Objekte umwandeln
      var zurueck = JsonConvert.DeserializeObject<List<Person>>(json);
      Console.WriteLine($"Anzahl Personen: {zurueck.Count}");
    }
  }
}

Starten tust du das Ganze mit `dotnet run`. Die Ausgabe:

[
  {
    "Name": "Anna",
    "Alter": 28
  },
  {
    "Name": "Ben",
    "Alter": 35
  }
]
Anzahl Personen: 2

Falls du die JSON-Daten dauerhaft in einer Datei speichern willst, passt unser Beitrag zu C# Datei lesen und schreiben perfekt dazu.

Häufige Probleme & Lösungen

Problem 1: Fehler NU1102 - „Unable to find package ... with version"

Meist ein Tippfehler im Paketnamen oder eine Version, die es gar nicht gibt. Prüfe die exakte Schreibweise und die verfügbaren Versionen auf nuget.org. Mit `--version` pinst du eine konkrete Version fest:

dotnet add package Newtonsoft.Json --version 13.0.1

Problem 2: Nach dem Klonen eines Repos baut das Projekt nicht

Auf deinem Rechner fehlen die im Projekt referenzierten Pakete. Führe `dotnet restore` aus - das lädt alles nach, was in der `.csproj` steht.

Problem 3: Fehler NU1202 - Paket ist nicht kompatibel

Das kann passieren, wenn ein Paket neuere .NET-Versionen voraussetzt als dein Projekt nutzt (z. B. Paket für .NET 8, dein Projekt zielt auf .NET 6). Schau auf der Paketseite unter „Frameworks" nach, welche Versionen unterstützt werden, und wähle bei Bedarf eine ältere Paketversion. Andersrum klappt es meist: Alte Pakete laufen in der Regel auch auf neuen .NET-Versionen.

FAQ: Häufige Fragen zu NuGet und dotnet CLI

Was ist NuGet genau?

NuGet ist der offizielle Paketmanager für .NET. Er verwaltet externe Bibliotheken (Pakete) - vom Herunterladen über das Auflösen von Abhängigkeiten bis zum Einbinden ins Projekt.

Was macht `dotnet restore`?

Der Befehl liest die Projektdatei (`.csproj`) und lädt alle dort gelisteten Pakete in den lokalen Cache, falls sie fehlen. Denk an einen Einkauf anhand deiner Einkaufsliste.

Wo werden NuGet-Pakete auf meinem Rechner gespeichert?

Zentral im globalen Cache - unter Windows in `%userprofile%\.nuget\packages`, unter Linux/macOS in `~/.nuget/packages`. Alle Projekte teilen sich diesen Cache, was Speicher spart.

Muss ich NuGet-Pakete in Git einchecken?

Nein. Da die `.csproj` alle Pakete mit Version dokumentiert, kann jeder Mitentwickler sie per `dotnet restore` selbst laden. Der Cache gehört nicht ins Repository.

Geht das auch ohne Visual Studio?

Ja, vollständig. Die dotnet CLI deckt alles ab - Anlegen, Installieren, Bauen und Starten. Visual Studio oder VS Code sind komfortable Zusätze, aber keine Pflicht.

Fazit: Mit wenigen Befehlen zu echten C#-Projekten

NuGet und die dotnet CLI klingen erstmal nach Trockenübung - sind aber das Handwerkszeug, das dich durch Ausbildung, Studium und Berufseinstieg begleitet. Mit `dotnet new`, `dotnet add package`, `dotnet list package` und `dotnet run` hast du den kompletten Zyklus im Griff: Projekt anlegen, Bibliothek einbinden, verwalten, starten. Genau solche Grundlagen werden in Prüfungen und im Alltag ständig abverlangt.

Wenn du bei C#, NuGet oder einem anderen IT-Thema festhängst, hol dir Unterstützung bei study-it.education - individuelle Nachhilfe, die sich deinem Tempo anpasst.