In diesem Artikel
Wir klicken in unserer App auf Refresh, aber die Aufgabenliste wird erst nach mehreren Sekunden aktualisiert. Die API läuft. Trotzdem ist noch nicht klar, wo die Verzögerung entsteht.
Hat die App den richtigen Endpunkt aufgerufen? Wurde die Anfrage wiederholt? Oder hat die Verarbeitung auf dem Server einfach länger gedauert?
Genau hier kann uns Aspire unterstützen.
In diesem Beitrag zeige ich Schritt für Schritt, wie wir eine .NET MAUI App und eine ASP.NET Core API in einen gemeinsamen lokalen Entwicklungsablauf einbinden. Dafür verwenden wir TaskBoard, eine kleine Aufgabenverwaltung mit .NET 10, MVVM, einer Minimal API und SQLite.
Unser Ziel ist also:
- App und API über einen gemeinsamen AppHost starten
- die API-Adresse über Service Discovery bereitstellen
- Logs, Traces und Metriken im Aspire Dashboard untersuchen
- Wiederholungsversuche und Timeouts bewusst konfigurieren
- das Beispiel auch mit Android und Dev Tunnels verwenden
Anders als in den Beiträgen zu Android Builds , iOS Builds und Windows Builds geht es diesmal nicht um Release-Pakete, sondern um die lokale Entwicklung und Fehlersuche.
Warum sollten wir .NET MAUI und Aspire gemeinsam verwenden?
Wenn wir eine App zusammen mit ihrem Backend entwickeln, müssen normalerweise mehrere Dinge zusammenpassen: Die API muss laufen, der Client muss ihre Adresse kennen und für die Fehlersuche benötigen wir Informationen von beiden Seiten.
Aspire bringt diese Bestandteile in einen gemeinsamen Entwicklungsablauf.
Dabei sind vor allem drei Komponenten wichtig:
- AppHost: beschreibt Projekte, Ressourcen und ihre Beziehungen. Er startet die Entwicklungsumgebung und stellt Konfiguration wie die Service-Endpunkte bereit.
- Service Defaults: bündeln gemeinsame Einstellungen für Service Discovery, Health Checks und OpenTelemetry. Jedes Projekt verwendet die für seinen Zweck passenden Defaults.
- Aspire Dashboard: zeigt den Zustand der Ressourcen sowie ihre Logs, Traces und Metriken an.
In unserem Beispiel koordiniert der AppHost die ASP.NET Core API und die native .NET MAUI App. Über Service Discovery erhält der Client die API-Adresse. Die Telemetrie beider Anwendungen können wir anschließend gemeinsam untersuchen.
SQLite bleibt dabei eine lokale Datenbank der API. Wir benötigen für dieses Beispiel weder einen Datenbankcontainer noch Docker.
Wichtig ist die Abgrenzung: Aspire ersetzt weder .NET MAUI noch ASP.NET Core. Der gezeigte AppHost ist auch kein Produktionshost für unsere Anwendung.
Unser Beispiel: TaskBoard
Damit wir nicht nur einen einzelnen HTTP-Aufruf betrachten, verwenden wir eine kleine Aufgabenverwaltung mit drei Ansichten:
- Tasks: Aufgaben laden, erstellen, bearbeiten, abschließen und löschen
- Editor: Titel und optionale Beschreibung prüfen und über die API speichern
- Diagnostics: normale, verzögerte, fehlgeschlagene und durch Timeouts abgebrochene Anfragen auslösen
Die Oberfläche verwendet native MAUI Controls, Shell-Navigation, ein helles und dunkles Design sowie deutsche und englische Ressourcen.
Die API speichert die Aufgaben in SQLite. Beim ersten Erstellen einer Development-Datenbank werden zwei Beispielaufgaben angelegt. Löschen wir diese Aufgaben, erscheinen sie nicht bei jedem Neustart erneut.
Die Diagnostics-Ansicht macht das Beispiel besonders hilfreich: Wir können gezielt Verzögerungen und Fehler erzeugen und anschließend untersuchen, wie Service Discovery, Wiederholungsversuche und Telemetrie zusammenspielen.
Voraussetzungen
Die folgenden Beispiele beziehen sich auf das TaskBoard-Repository . Die Befehle führen wir jeweils im Root-Verzeichnis eines lokalen Checkouts aus.
Im hier verwendeten Repository-Stand sind unter anderem diese Versionen festgelegt:
| Komponente | Version im Beispiel |
|---|---|
| .NET SDK | 10.0.401 |
| Aspire AppHost SDK | 13.6.1 |
| Aspire MAUI Hosting | 13.6.1-preview.1.26506.6 |
| Aspire Dev Tunnels Hosting | 13.6.1 |
| MAUI Controls/Core | 10.0.110 |
| CommunityToolkit.Mvvm | 8.4.2 |
| EF Core SQLite | 10.0.12 |
Die SDK-Auswahl erfolgt über global.json. Die normalen NuGet-Paketversionen befinden sich zentral in Directory.Packages.props. Die Version des AppHost SDK steht dagegen direkt in der Projektdeklaration.
Die global.json sieht folgendermaßen aus:
{
"sdk": {
"version": "10.0.401",
"rollForward": "latestPatch",
"allowPrerelease": false
}
}
Zusätzlich benötigen wir die MAUI Workloads für die Plattformen, die wir bauen möchten. Unter Windows können wir diese über den Visual Studio Installer installieren oder die benötigten Workloads aus dem Repository wiederherstellen:
dotnet workload restore TaskBoard.slnx
Für lokale HTTPS-Endpunkte vertrauen wir außerdem dem Entwicklungszertifikat:
dotnet dev-certs https --trust
Unter Windows können wir die Windows- und Android-Ziele des Beispiels bauen. Android benötigt zusätzlich Android SDK, JDK und einen laufenden Emulator beziehungsweise ein geeignetes Gerät. Für iOS und Mac Catalyst benötigen wir macOS, eine kompatible Xcode-Version und die passenden Apple Workloads.
Für die mobilen Aspire-Ressourcen kommen die Dev Tunnels CLI, ein angemeldetes Benutzerkonto und eine Internetverbindung hinzu. Die Windows-Desktop-App benötigt dagegen keine Dev Tunnels.
Eine separate Aspire CLI ist für den hier verwendeten projektbasierten AppHost nicht erforderlich. Wir starten ihn später mit dotnet run.
Die MAUI-Integration von Aspire ist im verwendeten Beispielstand noch eine Preview; auch die Visual-Studio-Integration ist noch nicht vollständig. Prüft daher die Kompatibilität der SDK- und Paketversionen, bevor ihr diese aktualisiert.
Schritt 1: Projektstruktur verstehen
Das Repository trennt die eigentliche Anwendungslogik von Plattformcode und Entwicklungsinfrastruktur:
TaskBoard.slnx
Directory.Packages.props
src
TaskBoard.Contracts
TaskBoard.Api
TaskBoard.ClientCore
TaskBoard.Maui
TaskBoard.ServiceDefaults
TaskBoard.MauiServiceDefaults
TaskBoard.AppHost
tests
TaskBoard.ClientCore.Tests
TaskBoard.Api.Tests
TaskBoard.AppHost.Tests
Die Projekte haben folgende Aufgaben:
| Projekt | Aufgabe |
|---|---|
Contracts |
gemeinsame DTOs und Validierungsgrenzen |
Api |
REST-Endpunkte, EF Core und SQLite |
ClientCore |
HTTP-Client, ViewModels, Resilience und Lokalisierung |
Maui |
XAML-Seiten, Navigation und native Verbindungsinformationen |
ServiceDefaults |
Health Checks, Service Discovery und Telemetrie für das Backend |
MauiServiceDefaults |
Service Discovery und Telemetrieinitialisierung für die native App |
AppHost |
Registrierung und Start der Entwicklungsressourcen |
Der Weg einer Anfrage bleibt dabei überschaubar: Ein MAUI ViewModel ruft den typisierten HTTP-Client auf. Dieser sendet eine Anfrage an taskapi, und die API liest oder schreibt die Daten in SQLite.
Contracts und ClientCore haben keine Abhängigkeit vom Aspire Hosting. Dadurch können wir den REST-Vertrag und die Anwendungslogik auch dann verwenden, wenn die App unabhängig von Aspire gestartet wird.
Schritt 2: API und native App im AppHost registrieren
Zunächst schauen wir uns das AppHost-Projekt an. Es referenziert die API und die benötigten Hosting-Integrationen:
<Project Sdk="Aspire.AppHost.Sdk/13.6.1">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<AspireUseCliBundle>true</AspireUseCliBundle>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Aspire.Hosting.Maui" />
<PackageReference Include="Aspire.Hosting.DevTunnels" />
<ProjectReference Include="../TaskBoard.Api/TaskBoard.Api.csproj" />
</ItemGroup>
</Project>
Der Ausschnitt lässt die User-Secrets-ID und die Freigabe für die Testassembly weg. Die Paketversionen werden zentral bereitgestellt.
Für eine minimale Desktop-Konfiguration sieht AppHost.cs folgendermaßen aus:
var builder = DistributedApplication.CreateBuilder(args);
var api = builder.AddProject<Projects.TaskBoard_Api>("taskapi")
.WithHttpHealthCheck("/health");
var maui = builder.AddMauiProject(
"taskboard", "../TaskBoard.Maui/TaskBoard.Maui.csproj");
if (OperatingSystem.IsWindows())
{
maui.AddWindowsDevice().WithReference(api);
}
if (OperatingSystem.IsMacOS())
{
maui.AddMacCatalystDevice().WithReference(api);
}
builder.Build().Run();
taskapi ist der logische Service-Name, den AppHost und Client gemeinsam verwenden. Über WithReference(api) erhält die native Ressource die Endpunktkonfiguration der API.
Das MAUI-Projekt registrieren wir über den Pfad seiner .csproj-Datei. Eine direkte ProjectReference vom AppHost auf das MAUI-Projekt sollten wir hier nicht hinzufügen: Die Target Frameworks sind dafür nicht kompatibel.
Das Backend referenziert TaskBoard.ServiceDefaults und ruft builder.AddServiceDefaults() auf. Zusätzlich registriert es unter anderem Problem Details, seinen DbContext und einen Datenbank-Health-Check.
Nach dem Erstellen der Anwendung werden Exception Handling, Datenbankinitialisierung und API-Endpunkte eingerichtet. Über app.MapDefaultEndpoints() kommen die Standardendpunkte hinzu. In Development berücksichtigt /health auch die Datenbankbereitschaft; /alive dient als Liveness-Check.
Schritt 3: MAUI über Service Discovery mit der API verbinden
Ohne Aspire könnten wir unseren typisierten HTTP-Client zunächst mit einer festen Basisadresse registrieren:
builder.Services.AddHttpClient<ITaskApiClient, TaskApiClient>(client =>
client.BaseAddress = new Uri("https://your-api.example/"));
TaskBoard lädt dagegen zunächst seine eingebetteten Einstellungen und die Umgebungskonfiguration. Anschließend wählt die App die passende Adresse aus.
Der folgende Ausschnitt stammt aus MauiProgram.BuildApplication():
builder.AddServiceDefaults();
var hasDiscoveredApi = builder.Configuration
.GetSection("services:taskapi")
.GetChildren()
.Any();
var baseAddress = hasDiscoveredApi
? new Uri("https+http://taskapi")
: GetStandaloneAddress(builder.Configuration["TaskBoard:ApiBaseUrl"]);
builder.Services.AddTaskBoardClient(baseAddress);
AddServiceDefaults() ist hier die Erweiterungsmethode aus MauiServiceDefaults. Sie registriert Service Discovery für ausgehende HTTP-Clients und konfiguriert die native Telemetrie.
Wenn Aspire Service-Endpunkte bereitstellt, verwendet der Client die logische Adresse https+http://taskapi. Service Discovery löst diese in den konfigurierten Endpunkt auf und bevorzugt dabei HTTPS.
Bei einem unabhängigen Start wird stattdessen die Einstellung TaskBoard:ApiBaseUrl verwendet. Die Hilfsmethode GetStandaloneAddress() im Beispiel prüft, ob eine absolute HTTP- oder HTTPS-Adresse vorliegt, und ergänzt bei Bedarf den abschließenden Schrägstrich.
Der typisierte Client verwendet weiterhin relative Routen wie api/tasks. Die ViewModels arbeiten in beiden Fällen mit ITaskApiClient. Der Start über Aspire verändert also nicht unsere eigentlichen Aufgabenoperationen.
Schritt 4: Native Telemetrie initialisieren
Die Backend-Defaults registrieren unter anderem ASP.NET-Core- und HTTP-Instrumentierung, Runtime-Metriken und OpenTelemetry-Logging. Die nativen Defaults konfigurieren ebenfalls HTTP-Instrumentierung, Runtime-Metriken und Logging.
Bei einer MAUI App müssen die Provider zusätzlich passend zum nativen Start initialisiert werden.
Im Beispiel übernimmt das ein OpenTelemetryInitializer, der IMauiInitializeService implementiert. Seine Initialisierungsmethode sieht so aus:
public void Initialize(IServiceProvider services)
{
_ = services.GetService<MeterProvider>();
_ = services.GetService<TracerProvider>();
_ = services.GetService<LoggerProvider>();
}
Beide Defaults aktivieren den OTLP-Export, wenn OTEL_EXPORTER_OTLP_ENDPOINT konfiguriert ist. Beim Start über Aspire wird die benötigte Collector-Konfiguration bereitgestellt. Auch bei einem unabhängigen Start können wir einen Collector separat konfigurieren.
Im Dashboard finden wir damit nicht nur die Konsolenausgaben unserer Ressourcen:
Auch die strukturierten Logs der HTTP-Anfragen lassen sich gemeinsam untersuchen:
Die HTTP-Instrumentierung gibt den Trace-Kontext vom Client an die API weiter. Wenn wir die Aufgabenliste aktualisieren, können wir im Dashboard die ausgehende Client-Anfrage und die zugehörige Server-Anfrage innerhalb desselben Traces betrachten.
Damit lässt sich beispielsweise erkennen, wie lange die Verarbeitung auf dem Server dauert und welche Versuche fehlgeschlagen sind.
Die Diagnostics-Ansicht zeigt zusätzlich die Dauer der gesamten Client-Aktion an, einschließlich der Wartezeiten zwischen Wiederholungsversuchen. Diesen Wert sollten wir bei einer langsamen Operation zusammen mit den einzelnen Trace-Spans betrachten.
Schritt 5: Wiederholungsversuche und Timeouts bewusst konfigurieren
Unser Aufgaben-Client verwendet genau einen Standard-Resilience-Handler. Die nativen Defaults registrieren Service Discovery global, überlassen die konkrete Resilience-Konfiguration aber ClientCore.
Dadurch stapeln wir nicht versehentlich mehrere Handler mit eigenen Wiederholungsversuchen.
Die relevanten Aufrufe aus ClientServiceCollectionExtensions.AddTaskBoardClient() sehen folgendermaßen aus:
var http = services.AddHttpClient<ITaskApiClient, TaskApiClient>(client =>
{
client.BaseAddress = baseAddress;
});
http.AddStandardResilienceHandler(options =>
{
options.TotalRequestTimeout.Timeout = TimeSpan.FromSeconds(12);
options.AttemptTimeout.Timeout = TimeSpan.FromSeconds(3);
options.Retry.MaxRetryAttempts = 2;
options.Retry.Delay = TimeSpan.FromMilliseconds(500);
options.Retry.BackoffType = DelayBackoffType.Constant;
options.Retry.UseJitter = false;
options.Retry.DisableFor(
HttpMethod.Post, HttpMethod.Put,
HttpMethod.Delete, HttpMethod.Patch);
});
http.ConfigureHttpClient(client =>
client.Timeout = TimeSpan.FromSeconds(12));
Damit können GET-Anfragen bei vorübergehenden Fehlern bis zu drei Versuche durchlaufen: den ursprünglichen Aufruf und zwei Wiederholungen.
Schreibende Anfragen werden dagegen nicht automatisch wiederholt. Der Circuit Breaker und der Rate Limiter des Standard-Handlers bleiben aktiviert.
Der abschließende Aufruf von ConfigureHttpClient() ist bewusst nach der Registrierung des Handlers platziert. Der Standard-Handler deaktiviert bei der Einrichtung den eigenen Timeout von HttpClient.
TaskBoard setzt diesen anschließend wieder auf zwölf Sekunden. Dadurch wird auch das Puffern des Antwortinhalts begrenzt, das außerhalb des Timeout-Bereichs des Handlers stattfinden kann. Ein Regressionstest im Beispiel prüft genau den Fall, dass zwar die Antwortheader eintreffen, der Body aber nicht vollständig geliefert wird.
Wichtig ist außerdem: Eine fehlgeschlagene oder abgebrochene Schreiboperation kann auf dem Server bereits gespeichert worden sein. Aktualisiert deshalb die Aufgabenliste, bevor ihr eine solche Operation mit unklarem Ergebnis manuell erneut ausführt. Das Beispiel besitzt weder eine Offline-Schreibwarteschlange noch serverseitige Idempotency Keys.
Schritt 6: Beispiel unter Windows starten
Im Root-Verzeichnis des TaskBoard-Repositories führen wir folgende Befehle aus:
dotnet --version
dotnet restore TaskBoard.slnx
dotnet dev-certs https --trust
dotnet run --project src\TaskBoard.AppHost
Der AppHost gibt die Dashboard-URL aus und startet die API.
Im Dashboard wählen wir anschließend bei taskboard-windows die Aktion Start, um die native Anwendung zu bauen und zu starten. Die MAUI-Ressource wird also bei Bedarf gestartet und nicht bereits durch das bloße Öffnen des AppHost.
Die Standard-Startprofile verwenden die Development-Umgebung. Deshalb ist auch taskboard-android bereits registriert. Die zugehörigen Tunnels bleiben zunächst gestoppt, solange keine mobile Ressource gestartet wird.
Für einen ersten Test können wir:
- die Aufgabenliste aktualisieren
- eine Aufgabe erstellen oder bearbeiten
- im Dashboard den zugehörigen Client- und API-Trace suchen
- in der Diagnostics-Ansicht normale, verzögerte und fehlgeschlagene Anfragen auslösen
- die angezeigte Gesamtdauer mit den Logs und Trace-Spans vergleichen
Wenn ihr Ressourcenregistrierungen verändert, solltet ihr den AppHost neu bauen und starten, damit das Dashboard das aktualisierte Modell erhält.
Die Windows-App ist in diesem lokalen Beispiel als unpackaged konfiguriert. Release-Packaging und Signierung gehören weiterhin in einen separaten Verteilungsprozess.
Schritt 7: Android und mobile Dev Tunnels ergänzen
Für die mobile Konfiguration verwenden wir einen Tunnel für die API und einen weiteren für die OTLP-Telemetrie. Desktop-Ressourcen greifen dagegen direkt auf die Endpunkte des Entwicklungsrechners zu.
Installiert zunächst die Dev Tunnels CLI und meldet euch an:
devtunnel user login
Der folgende zusätzliche Block gehört im Desktop-AppHost vor builder.Build().Run().
Er verwendet die Hilfsklasse
MobileTunnelStarter aus dem Beispiel
. Für den Ausschnitt benötigen wir außerdem die Namespaces TaskBoard.AppHost, Aspire.Hosting.DevTunnels, Microsoft.Extensions.Configuration und Microsoft.Extensions.Hosting.
var prepareMobileTunnels = builder.Configuration
.GetValue<bool>("TaskBoard:EnableMobileTargets");
if (prepareMobileTunnels && !builder.Environment.IsDevelopment())
{
throw new InvalidOperationException(
"Mobile Dev Tunnels are only supported in Development.");
}
using var tunnelStarter = new MobileTunnelStarter();
if (builder.Environment.IsDevelopment())
{
var tunnel = builder.AddDevTunnel("taskapi-tunnel")
.WithAnonymousAccess()
.WithReference(api.GetEndpoint("https"));
var emulatorId = builder.Configuration["TaskBoard:AndroidEmulatorId"];
var android = maui.AddAndroidEmulator(
"taskboard-android",
string.IsNullOrWhiteSpace(emulatorId) ? null : emulatorId)
.WithOtlpDevTunnel()
.WithReference(api, tunnel);
var mobileTunnels = builder.Resources
.OfType<DevTunnelResource>().ToArray();
if (!prepareMobileTunnels)
{
foreach (var mobileTunnel in mobileTunnels)
{
builder.CreateResourceBuilder(mobileTunnel)
.WithExplicitStart();
}
}
android.OnBeforeResourceStarted((_, e, ct) =>
tunnelStarter.StartAsync(mobileTunnels, e.Services, ct));
}
Die Hilfsklasse koordiniert den Start der mobilen Tunnels. Sie verwendet bereits laufende Tunnels weiter, führt die benötigten Startbefehle aus und wartet auf deren Bereitschaft.
Ein fehlgeschlagener Tunnelstart führt zu einem Fehler beim Start der mobilen Ressource, statt die Bereitstellung unbegrenzt warten zu lassen.
Der vollständige AppHost registriert unter macOS außerdem einen iOS-Simulator mit derselben API-Referenz und einem OTLP-Tunnel.
Android-Emulator starten
Erstellt und startet zunächst ein Android Virtual Device über den Android Device Manager.
Bei einem einzelnen laufenden Emulator können wir anschließend im Dashboard taskboard-android starten. Die Ressource baut die App, installiert sie und startet sie auf dem Emulator.
Wenn mehrere Emulatoren laufen, kann das Beispiel über TaskBoard:AndroidEmulatorId die gewünschte Instanz auswählen:
dotnet run --project src\TaskBoard.AppHost -- --TaskBoard:AndroidEmulatorId=emulator-5554
Verwendet hier die Seriennummer aus adb devices, nicht den AVD-Namen. Die verwendete Hosting-Integration reicht den Wert an adb -s weiter.
Die Option TaskBoard:EnableMobileTargets=true bereitet die Tunnels bereits beim AppHost-Start vor. Sie ist nicht erforderlich, damit die Android-Ressource im Development-Dashboard sichtbar ist.
Wichtiger Hinweis zum Tunnelzugriff
Die Demo-API besitzt keine Authentifizierung. Außerdem erlaubt der API-Tunnel über WithAnonymousAccess() anonyme Zugriffe.
Sobald wir eine mobile Ressource starten oder die Tunnels vorab aktivieren, ist die Aufgaben-API über diesen Tunnel erreichbar. Wer die URL kennt, kann Aufgaben lesen und verändern.
Verwendet deshalb ausschließlich wegwerfbare Beispieldaten ohne sensible Inhalte und beendet den AppHost nach den Tests wieder.
Die Anmeldung über devtunnel user login authentifiziert den Tunnelhost. Sie schützt nicht automatisch die Aufrufer unserer Demo-API.
Typische Probleme
Auch bei diesem Beispiel gibt es einige Punkte, die wir bei der Einrichtung beachten sollten.
Die MAUI App startet nicht automatisch
Das ist zunächst beabsichtigt. Der AppHost startet die API; die native App starten wir anschließend über die entsprechende Ressource im Dashboard.
Der Client verwendet nicht den erwarteten Endpunkt
Prüft, ob Aspire die Konfiguration unter services:taskapi bereitstellt und ob die native Ressource WithReference(api) verwendet.
Bei einem unabhängigen Start wird dagegen TaskBoard:ApiBaseUrl verwendet. Auf einem mobilen Gerät muss diese Adresse vom Gerät aus erreichbar sein. localhost bezeichnet dort nicht einfach unseren Entwicklungsrechner.
Die API ist erreichbar, aber die Client-Telemetrie fehlt
Prüft die nativen Service Defaults, die Initialisierung der OpenTelemetry-Provider und die Collector-Konfiguration. Für mobile Ressourcen wird zusätzlich der OTLP-Tunnel benötigt.
Der Android-Start schlägt fehl
Kontrolliert Android SDK, JDK, den laufenden Emulator sowie Installation und Anmeldung der Dev Tunnels CLI. Die mobile Bereitstellung benötigt außerdem eine Internetverbindung.
Bei mehreren Emulatoren muss die konfigurierte Gerätekennung einer passenden adb-Seriennummer entsprechen.
Ein fehlgeschlagener GET-Aufruf dauert länger als erwartet
Die Gesamtdauer kann mehrere Versuche und die Wartezeiten dazwischen enthalten. Vergleicht deshalb die einzelne Anfrage nicht nur mit dem Timeout eines Versuchs, sondern auch mit der gesamten Resilience-Konfiguration.
Nach einem Paketupdate funktioniert die Integration nicht mehr
Die native Hosting-Integration ist im verwendeten Stand eine Preview. Aktualisiert Aspire SDK, Hosting-Integration und weitere Pakete daher nicht unabhängig voneinander, ohne ihre Kompatibilität zu prüfen.
Wann lohnt sich Aspire?
Wenn wir Client und API gemeinsam entwickeln, bietet Aspire einen wiederholbaren Einstiegspunkt und eine gemeinsame Oberfläche für die Fehlersuche.
Gerade bei mehreren Entwicklern oder bei schwer nachvollziehbaren HTTP-Problemen kann das hilfreich sein.
Die zusätzliche Konfiguration hat aber auch ihren Preis: Wir benötigen weitere Projekte und Pakete, verwenden eine Preview-Integration und sind bei mobilen Tunnels von Benutzerkonto und Netzwerkverbindung abhängig.
Eine kleine App, die lediglich eine bereits bereitgestellte API aufruft, profitiert möglicherweise weniger von der lokalen Ressourcenkoordination.
Für eine bestehende Anwendung würde ich daher schrittweise vorgehen:
- AppHost und die beiden Defaults-Projekte ergänzen
- Client-Konfiguration anbinden
- zunächst ein Desktop-Ziel überprüfen
- bestehenden REST-Vertrag und MVVM-Verhalten beibehalten
- erst anschließend mobile Tunnels hinzufügen
- den Ablauf mit gezielt ausgelösten Verzögerungen und Fehlern untersuchen
Die Veröffentlichung der API, das Signieren nativer Pakete und die Auswahl der Produktionsendpunkte bleiben separate Aufgaben. Auch Datenbankschema-Verwaltung und Authentifizierung der Demo-API müssen vor einem produktiven Einsatz gesondert geplant werden.
Fazit
Mit Aspire können wir eine .NET MAUI App und ihre ASP.NET Core API in einen gemeinsamen Entwicklungsablauf einbinden.
Der AppHost koordiniert die Ressourcen, Service Discovery stellt die Endpunkte bereit und das Dashboard hilft uns, Anfragen über Client und Backend hinweg nachzuvollziehen.
Und genau das ist für mich der eigentliche Vorteil dieses Ansatzes.
Wir ersetzen weder unsere native App noch unsere API. Stattdessen schaffen wir eine gemeinsame Grundlage für den lokalen Start und die Fehlersuche. Ob sich der zusätzliche Aufwand lohnt, hängt davon ab, wie eng wir beide Seiten zusammen entwickeln.
Die vollständige Implementierung findet ihr in meinem TaskBoard-Repository . Der hier verwendete Repository-Stand hält die zugrunde liegenden Dateien und Paketversionen nachvollziehbar fest.