Zum Inhalt springen

.NET in GitHub Actions beschleunigen

Zuletzt aktualisiert am

Um .NET in GitHub Actions zu beschleunigen, cachen Sie den NuGet-Paketordner mit actions/setup-dotnet, führen Sie das Restore einmal aus und bauen und testen Sie dann mit --no-restore und --no-build, sodass jeder Schritt nur seine eigene Aufgabe erledigt. Viele langsame .NET-Pipelines führen Restore und Build dreimal aus, ohne dass es auffällt, weil dotnet test standardmäßig Restore und Build ausführt.

Dieser Leitfaden behandelt Caching, die Build- und Testbefehle, parallele Tests und Datenbank-Services. Die allgemeine Version finden Sie unter so beschleunigen Sie GitHub Actions.

Wiederholtes Restore und Build vermeiden

dotnet build führt zuerst dotnet restore aus. dotnet test führt den Build aus, der wiederum Restore ausführt. Wenn Ihr Workflow getrennte Schritte für Restore, Build, Test und Publish ohne Flags enthält, wiederholt jeder Schritt Arbeit. Führen Sie jede Phase einmal aus:

- run: dotnet restore --locked-mode
- run: dotnet build --no-restore -c Release
- run: dotnet test --no-build -c Release
- run: dotnet publish src/Api -c Release --no-build -o out

--no-restore überspringt das implizite Restore. --no-build überspringt den impliziten Build und verwendet die bereits vorhandene Ausgabe, daher muss die Konfiguration (-c Release) über alle Schritte hinweg gleich sein. Bei einer Solution mit vielen Projekten spart allein das oft mehrere Minuten.

NuGet-Paketordner cachen

actions/setup-dotnet bietet integriertes Caching. Laut README ist es standardmäßig deaktiviert und wird mit cache: true aktiviert. Es cacht den globalen Paketordner von NuGet, und der Schlüssel wird aus packages.lock.json erzeugt. Das README besagt, dass die Action einen Fehler wirft, wenn keine Lock-Datei existiert, Sie benötigen also Lock-Dateien. Verwenden Sie cache-dependency-path, wenn sie in Unterverzeichnissen liegen.

- uses: actions/checkout@v7
- uses: actions/setup-dotnet@v6
  with:
    dotnet-version: 9.0.x
    cache: true
    cache-dependency-path: "**/packages.lock.json"

Um Lock-Dateien zu erzeugen, fügen Sie <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile> zu Ihrem Projekt oder einer Directory.Build.props hinzu, führen Sie dotnet restore einmal lokal aus und committen Sie die packages.lock.json-Dateien. In der CI schlägt dotnet restore --locked-mode dann fehl, wenn die Lock-Datei veraltet ist, was Builds außerdem reproduzierbar macht. Das README weist darauf hin, dass nur der Paketordner wiederhergestellt wird, sodass ein Restore die Warnung NU1403 ausgeben kann, sofern Sie nicht die dort beschriebene Einstellung anwenden; lesen Sie diesen Abschnitt, wenn Sie darauf stoßen.

Wenn Sie keine Lock-Dateien verwenden möchten, nutzen Sie actions/cache für ~/.nuget/packages mit einem Schlüssel aus **/*.csproj und Directory.Packages.props:

- uses: actions/cache@v6
  with:
    path: ~/.nuget/packages
    key: nuget-${{ runner.os }}-${{ hashFiles('**/*.csproj', '**/Directory.Packages.props') }}
    restore-keys: nuget-${{ runner.os }}-

Parallelität bei Build und Test

  • Build. MSBuild baut Projekte mit -m (--maxcpucount) parallel. dotnet build aktiviert dies standardmäßig und nutzt alle Kerne. Wenn Sie msbuild direkt aufrufen, übergeben Sie -m.
  • Tests über Assemblies hinweg. dotnet test führt Testprojekte gemäß den MSBuild-Einstellungen parallel aus und Tests innerhalb einer Assembly nach den Regeln des Frameworks.
  • xUnit. Testklassen sind eigene Collections und laufen standardmäßig parallel zueinander; Tests innerhalb einer Klasse laufen nacheinander. Passen Sie dies in xunit.runner.json mit maxParallelThreads an. Tests, die Zustand teilen, sollten in eine [Collection] gelegt werden, damit sie seriell laufen.
  • NUnit und MSTest. Fügen Sie [Parallelizable] oder [assembly: Parallelize] hinzu; standardmäßig laufen sie seriell.

Prüfen Sie die CPU-Auslastung während des Testschritts. Liegt sie nahe bei einem Kern, verschenken Sie Geschwindigkeit.

Services für Integrationstests

Eine ASP.NET-Core-App mit SQL Server nutzt oft einen Service-Container:

services:
  sql:
    image: mcr.microsoft.com/mssql/server:2022-latest
    env:
      ACCEPT_EULA: "Y"
      MSSQL_SA_PASSWORD: "Your_password123"
    ports: ["1433:1433"]
    options: >-
      --health-cmd "/opt/mssql-tools18/bin/sqlcmd -C -S localhost -U sa -P Your_password123 -Q 'SELECT 1'"
      --health-interval 10s --health-timeout 5s --health-retries 12

SQL Server benötigt mindestens 2 GB Arbeitsspeicher und startet langsamer als Postgres, daher ist ein Health-Check unverzichtbar. Der Pfad zu sqlcmd im Image hat sich zwischen Versionen geändert, prüfen Sie ihn also für den von Ihnen fixierten Tag. Wenn Sie Testcontainers verwenden, gelten dieselben Startkosten pro Container; teilen Sie sich einen Container pro Testlauf über einen Collection-Fixture und lassen Sie jeden Test seine eigene Datenbank oder sein eigenes Schema anlegen.

Ein vollständiger Workflow

name: dotnet
on:
  pull_request:
  push:
    branches: [main]

concurrency:
  group: dotnet-${{ github.ref }}
  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

env:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-dotnet@v6
        with:
          dotnet-version: 9.0.x
          cache: true
          cache-dependency-path: "**/packages.lock.json"
      - run: dotnet restore --locked-mode
      - run: dotnet build --no-restore -c Release
      - run: dotnet test --no-build -c Release --logger "trx;LogFileName=test.trx"

Die DOTNET_*-Variablen deaktivieren die Arbeit beim ersten Start und die Telemetrie, was auf jeder frischen VM etwas spart. Für Release-Builds kosten ReadyToRun und Trimming spürbar Zeit, reservieren Sie sie daher für den Publish-Job auf main.

Was mehr CPU-Kerne bringen

MSBuild und der Roslyn-Compiler nutzen alle Kerne, und parallele Testframeworks tun das ebenfalls. Unsere Benchmarks umfassen React + ASP.NET Core + SQL Server: 3m34s auf einem GitHub-gehosteten Runner und 1m41s auf compiler.dev (2.1x). Dabei handelte es sich um einen vollständigen CI-Lauf mit 10 Test-Shards und einer echten Datenbank, gemessen am 8. Oktober 2026. Der Speicherbedarf von SQL Server ist ein Grund, warum eine Maschine mit 16 GB hilft; ein Runner mit 7 GB lässt weniger Platz für Datenbank und Build.

Um Ihren eigenen Workflow auszuprobieren, ändern Sie eine Zeile zu runs-on: [self-hosted, Linux, compiler-ci]; siehe Preise und Vergleich. Verwandte Themen: die .NET-Vorlage, das Caching in GitHub Actions und Test-Sharding.

FAQ

Cacht setup-dotnet NuGet-Pakete?

Ja, mit cache: true. Es benötigt eine packages.lock.json und bricht ohne sie mit einem Fehler ab. Verwenden Sie cache-dependency-path für Lock-Dateien in Unterordnern.

Was macht dotnet test --no-build?

Es führt Tests aus der vorhandenen Build-Ausgabe aus, ohne erneut zu bauen. Das Konfigurations-Flag muss mit dem vorherigen Build übereinstimmen.

Warum ist dotnet restore in der CI langsam?

Eine frische VM hat einen leeren NuGet-Cache und lädt jedes Paket herunter. Cachen Sie den Paketordner und verwenden Sie --locked-mode für reproduzierbare Restores.

Kann ich .NET-Tests parallel ausführen?

Ja. xUnit parallelisiert Test-Collections standardmäßig; NUnit und MSTest benötigen ein Attribut. Isolieren Sie zuvor gemeinsam genutzten Zustand.

Diesen Workflow auf compiler.dev ausführen Keine Karte nötig · 200 kostenlose Minuten

Kostenlos testen