
Eine API liefert sporadisch Fehler, eine Datenbankabfrage wächst, und im Log steht nur „Speichern fehlgeschlagen“. Solche Aufgaben gehören zur Entwicklung dazu. Die Infrastruktur dafür jedes Mal neu zu schreiben, bringt die eigentliche Anwendung aber selten weiter.
Die Werkzeuge im Überblick: Serilog für strukturiertes Logging; xUnit für automatisierte Tests; FluentValidation für Eingabeprüfungen; EF Core für objektorientierten Datenzugriff mit LINQ und Migrationen; Dapper für eigene SQL-Abfragen mit Objekt-Mapping; Refit für typisierte REST-Clients; Microsoft.Extensions.Http.Resilience für Timeouts, Retries und Circuit Breaker; YARP für die Weiterleitung von HTTP-Anfragen als Reverse Proxy; SignalR für Echtzeitnachrichten zwischen Server und Clients.
Als roter Faden dient eine beispielhafte Geräteverwaltung: Geräte speichern, Wartungen prüfen, eine externe API abfragen und Änderungen an verbundene Clients melden. Die Beispiele veranschaulichen einzelne Ideen; sie sind keine vollständige Anwendung.
Inhaltsverzeichnis
- Serilog – strukturiertes Logging
- xUnit – automatisierte Tests
- FluentValidation – Eingaben prüfen
- EF Core – Datenzugriff mit ORM
- Dapper – SQL und Objekt-Mapping
- Refit – typisierte REST-Clients
- Microsoft.Extensions.Http.Resilience – robuste HTTP-Aufrufe
- YARP – Reverse Proxy
- SignalR – Echtzeitkommunikation
- Welche Werkzeuge gehören wirklich ins Projekt?

Fehler finden und Regeln absichern
Serilog: Logs, mit denen sich etwas anfangen lässt
Ein langer Text im Log ist noch keine gute Diagnose. Serilog erfasst Ereignisse mit strukturierten Eigenschaften. Eine Geräte-ID bleibt damit ein eigenes Feld, nach dem ein geeignetes Logsystem filtern kann.
Log.Information(
"Wartung für Gerät {DeviceId} gespeichert, Dauer {ElapsedMs} ms",
deviceId,
elapsedMilliseconds);
Das Beispiel nutzt einen bereits konfigurierten Serilog-Logger. Die Werte werden separat übergeben; String-Interpolation würde diese Struktur an dieser Stelle auflösen. Über sogenannte Sinks lassen sich Ereignisse beispielsweise an die Konsole, in Dateien oder an einen zentralen Logdienst ausgeben.
Der Gewinn entsteht bei der Fehlersuche: Welche Geräte sind betroffen? Welche Vorgänge dauern auffällig lange? Trotzdem gehören sinnvolle Log-Level, Aufbewahrung und der bewusste Umgang mit personenbezogenen Daten zur Konfiguration. Tokens und Passwörter haben im Log nichts verloren.
Im Projekt einbinden: In ASP.NET Core lässt sich Serilog als Provider hinter dem gewohnten ILogger<T> betreiben. Fachliche Services müssen dann nicht überall die statische Log-Klasse verwenden. Sie erhalten ihren Logger per Dependency Injection. Die Entscheidung über Ausgabeziele und Mindestlevel bleibt zentral im Anwendungsstart beziehungsweise in der Konfiguration.
Die ASP.NET-Core-Integration bietet außerdem UseSerilogRequestLogging(). Die Middleware fasst einen HTTP-Request mit Methode, Pfad, Statuscode und Laufzeit in einem Abschlussereignis zusammen. Ihre Position in der Pipeline bestimmt, welche nachfolgenden Komponenten sie erfasst. So lässt sich beispielsweise erkennen, ob eine langsame Geräteansicht regelmäßig mit einem bestimmten Endpunkt zusammenhängt.
Zusammengehörige Vorgänge erkennen: Eine einzelne Geräte-ID reicht nicht immer. Derselbe Benutzer kann mehrere Aktionen gleichzeitig auslösen. Eine Request- oder Korrelations-ID verbindet die dazugehörigen Ereignisse. Kontextinformationen lassen sich über einen passend konfigurierten Log-Kontext ergänzen, statt sie bei jedem Aufruf erneut einzutippen. In mehreren Diensten sollte diese Zuordnung durchgängig geplant werden; bloß überall ein Feld namens RequestId anzulegen, verbindet noch keine Aufrufe.
Auch die Auswahl der Eigenschaften ist eine fachliche Entscheidung. Für eine fehlgeschlagene Wartung sind Geräte-ID, Vorgangs-ID und Fehlerursache hilfreicher als ein komplett serialisiertes Benutzerobjekt. Eine sinnvolle Ausgangsbasis wäre: erfolgreiche Routinevorgänge auf Information, auffällige Situationen auf Warning, tatsächlich gescheiterte Aktionen auf Error. Während einer Diagnose lässt sich gezielt mehr protokollieren. Dauerhaft jedes Detail auf Debug zu speichern, macht Suche und Betrieb dagegen unnötig teuer. Der Produktivitätsgewinn liegt in beantwortbaren Fragen, nicht in möglichst vielen Logzeilen.
xUnit: Verhalten bei Änderungen überprüfen
xUnit ist ein Testframework für .NET. Einzelne Testfälle und datengetriebene Tests helfen, erwartetes Verhalten festzuhalten. In der Geräteverwaltung könnte das zum Beispiel die Berechnung des nächsten Wartungstermins sein: Monatswechsel, Schaltjahr und ein fehlendes Startdatum.
Solche Tests sparen nicht automatisch beim ersten Schreiben Zeit. Ihr Nutzen zeigt sich, wenn sich die Berechnung später ändert und vorhandene Fälle weiterhin stimmen müssen. Reine Unit-Tests ersetzen allerdings keinen Integrationstest gegen die tatsächlich verwendete Datenbank oder API.
Wer bereits mit NUnit arbeitet, muss dafür nicht wechseln. Wichtiger als der Name des Frameworks sind nachvollziehbare Testfälle, kurze Laufzeiten und die Ausführung in der CI-Pipeline.
Einzeltest oder Datenreihe: Mit [Fact] wird ein einzelner Test beschrieben, mit [Theory] derselbe Testablauf für mehrere Eingaben. Für Wartungsintervalle lässt sich damit eine kleine Tabelle fachlicher Erwartungen ausdrücken. Der Testname sollte das erwartete Verhalten nennen. „Test1“ hilft beim Fehlschlag wenig; „NextDate_UsesLastDay_WhenTargetMonthIsShorter“ benennt dagegen bereits die zu prüfende Regel.
[Theory]
[InlineData(2024, 1, 31, 1, 2024, 2, 29)]
[InlineData(2025, 1, 31, 1, 2025, 2, 28)]
public void NextDate_UsesLastDay_WhenTargetMonthIsShorter(
int year, int month, int day, int interval,
int expectedYear, int expectedMonth, int expectedDay)
{
var start = new DateOnly(year, month, day);
var expected = new DateOnly(expectedYear, expectedMonth, expectedDay);
var actual = MaintenanceSchedule.NextDate(start, interval);
Assert.Equal(expected, actual);
}
Der Ausschnitt benötigt xUnit und die beispielhafte Fachklasse MaintenanceSchedule. Deren Implementierung ist hier bewusst nicht enthalten. Die Testdaten formulieren eine angenommene Geschäftsregel: Fehlt der Tag im Zielmonat, wird dessen letzter Tag verwendet. Ob ein Termin danach wieder auf den ursprünglichen Monatstag zurückspringt, ist eine weitere fachliche Frage und braucht einen eigenen Test.
Isolation ist wichtiger als Bequemlichkeit: xUnit erzeugt für einzelne Tests neue Testklasseninstanzen. Aufwendige Testvorbereitung kann über Fixtures geteilt werden. Eine gemeinsam gestartete Testdatenbank spart beispielsweise Zeit; gemeinsam veränderbare Datensätze können jedoch Abhängigkeiten zwischen Tests erzeugen. Deshalb braucht jeder Test einen definierten Ausgangszustand, etwa eigene Datensätze oder ein kontrolliertes Zurücksetzen.
Besonders tückisch sind Tests, die nur in einer bestimmten Reihenfolge funktionieren oder von der aktuellen Uhrzeit abhängen. Übergib die benötigte Zeit beziehungsweise abstrahiere die Uhr, und mache externe Antworten kontrollierbar. So erklärt ein Fehlschlag möglichst präzise, welche Regel verletzt wurde. Ein Test, der intern bloß dieselbe Berechnung wie der Produktivcode wiederholt, liefert dagegen wenig zusätzliche Sicherheit.
FluentValidation: Eingaben an einer klaren Stelle prüfen
Wenn Pflichtfelder, Wertebereiche und voneinander abhängige Eingaben zusammenkommen, werden verteilte if-Abfragen schnell unübersichtlich. FluentValidation bündelt solche Regeln in Validatoren. Ein Gerätename darf beispielsweise nicht leer sein; ein Wartungsintervall muss größer als null sein.
Die Regeln lassen sich unabhängig vom Controller testen. Bei asynchronen Prüfungen sollte der Validator über ValidateAsync aufgerufen werden. Die ältere automatische Einbindung über FluentValidation.AspNetCore wird nicht mehr unterstützt; deren MVC-Validierungspipeline kann asynchrone Regeln nicht ausführen.
Eine Eingabeprüfung ersetzt außerdem keine Datenbank-Constraints oder Berechtigungsprüfung. Zwei gleichzeitige Anfragen können beide eine Vorabprüfung bestehen – Eindeutigkeit muss deshalb auch die Datenbank absichern.
Regeln als lesbare Klasse: Ein Validator leitet sich typischerweise von AbstractValidator<T> ab. Die Regeln beziehen sich auf Eigenschaften eines Eingabemodells. Dadurch bleibt beispielsweise ein Request zum Anlegen eines Geräts frei von Validierungslogik, die nur für diesen konkreten Anwendungsfall gilt.
public sealed class CreateDeviceValidator
: AbstractValidator<CreateDeviceRequest>
{
public CreateDeviceValidator()
{
RuleFor(x => x.Name)
.NotEmpty()
.MaximumLength(120);
RuleFor(x => x.MaintenanceIntervalMonths)
.GreaterThan(0)
.When(x => x.HasRecurringMaintenance);
}
}
Vorausgesetzt wird ein Eingabemodell mit den gezeigten Eigenschaften sowie using FluentValidation;. Das Intervall wird nur geprüft, wenn eine wiederkehrende Wartung aktiviert ist. Solche Bedingungen sind nützlich, müssen aber sorgfältig platziert werden: Innerhalb einer Regelkette kann eine Bedingung mehrere vorhergehende Validatoren betreffen.
Über den Cascade-Modus lässt sich außerdem steuern, ob nach einem Fehler weitere Prüfungen ausgeführt werden. Bei einer Regelkette kann ein früher Abbruch sinnvoll sein, wenn nachfolgende Prüfungen einen gültigen Ausgangswert voraussetzen. Für ein Formular ist es dagegen oft angenehmer, Fehler mehrerer unabhängiger Felder gesammelt zurückzugeben, damit der Benutzer nicht nach jeder Korrektur den nächsten Fehler entdecken muss.
Die Grenze zur Fachlogik: „Name fehlt“ ist eine Eingabeprüfung. „Dieser Benutzer darf das Gerät dieser Organisation (des Mandanten) bearbeiten“ ist eine Berechtigungsentscheidung. „Eine abgeschlossene Wartung darf nicht erneut abgeschlossen werden“ betrifft den fachlichen Zustand. Diese Verantwortlichkeiten sollten erkennbar bleiben. Ein Validator kann Datenbankabfragen nutzen, sollte aber nicht nebenbei Änderungen speichern. Für die API lohnt sich eine einheitliche Fehlerantwort mit Feldbezug; die Oberfläche kann diese dann direkt an den betroffenen Eingaben anzeigen. Und die Prüfung muss serverseitig stattfinden, auch wenn der Client dieselben Regeln bereits für eine angenehmere Bedienung ausführt.

Daten speichern: EF Core und Dapper passend einsetzen
EF Core: Objektmodell, LINQ und Migrationen
Entity Framework Core übernimmt viel Arbeit rund um relationale Daten: Entitäten abfragen, Beziehungen abbilden und Änderungen speichern. LINQ macht viele Abfragen direkt in C# lesbar. Migrationen halten Änderungen am Datenbankschema als versionierbaren Code fest.
Für eine Geräteverwaltung mit Räumen, Wartungen und Verantwortlichen ist das ein naheliegender Ansatz. Statt für jeden Schreibvorgang SQL und Objektzuordnung von Hand zu pflegen, arbeitet die Anwendung mit ihrem Datenmodell.
Das bedeutet nicht, dass die Datenbank unsichtbar werden darf. Abfragemenge, Indizes und erzeugtes SQL bleiben relevant. Für reine Listen lohnt es sich, nur die benötigten Felder zu projizieren und Tracking bewusst einzusetzen oder wegzulassen. Auch generierte Migrationen gehören vor dem produktiven Einsatz geprüft.
Was beim Speichern passiert: Der DbContext verwaltet bei getrackten Entitäten ihren Zustand. Wird ein geladenes Gerät umbenannt und anschließend SaveChangesAsync aufgerufen, ermittelt EF Core die zu speichernden Änderungen. Das reduziert wiederholten Zuordnungscode. Es macht den Context aber auch zu einer Arbeitseinheit mit Lebensdauer, die zum jeweiligen Vorgang passen muss.
Laut Dokumentation zur DbContext-Lebensdauer ist ein Context nicht threadsicher. Mehrere Datenbankoperationen dürfen daher nicht einfach per Task.WhenAll auf derselben Instanz gestartet werden. Für unabhängige parallele Vorgänge braucht es getrennte Instanzen. Gerade bei langlebigen Oberflächen ist „ein Context für die ganze Anwendung“ deshalb eine problematische Abkürzung.
var devices = await db.Devices
.AsNoTracking()
.Where(x => x.RoomId == roomId)
.OrderBy(x => x.Name)
.ThenBy(x => x.Id)
.Select(x => new DeviceSummary { Id = x.Id, Name = x.Name })
.Take(50)
.ToListAsync(cancellationToken);
Das Beispiel setzt das passende Modell und einen DTO-Typ voraus. Es lädt eine begrenzte, stabil sortierte Liste statt vollständiger Objektgraphen. Bei dieser reinen DTO-Projektion werden ohnehin keine Entitäten getrackt; AsNoTracking macht hier zusätzlich die Leseabsicht sichtbar. Für weitere Seiten muss eine passende Pagination ergänzt werden.
Die häufigsten Kosten entstehen in der Abfrage: Wer für jedes Gerät nachträglich dessen Wartungen einzeln lädt, erzeugt schnell viele Datenbankaufrufe. Die Hinweise zu effizienten Abfragen erklären dieses N+1-Problem und den bewussten Umgang mit Projektionen und Beziehungen. Umgekehrt kann ein großes Include-Geflecht unnötig viele Daten liefern. Deshalb zuerst überlegen, welche Informationen die Ansicht wirklich braucht, dann SQL und Ausführungsplan prüfen. EF Core spart vor allem Routine beim Datenzugriff; die Entscheidung über ein sinnvolles Datenmodell und effiziente Zugriffspfade bleibt Entwicklungsarbeit.
Dapper: SQL selbst bestimmen, Mapping abgeben
Dapper ist ein schlanker Object Mapper: Du schreibst SQL, Dapper überträgt die Ergebnisse in .NET-Objekte. Das passt beispielsweise zu einer gezielten Auswertung über fällige Wartungen, deren SQL bereits feststeht.
var devices = await connection.QueryAsync<DeviceSummary>(
"SELECT Id, Name FROM Devices WHERE RoomId = @RoomId",
new { RoomId = roomId });
Der Ausschnitt setzt eine passende Datenbankverbindung und den Ergebnistyp DeviceSummary voraus. Der Filterwert wird als Parameter übergeben, nicht in den SQL-Text eingesetzt. Dapper bringt im Kern weder das Change Tracking noch die Schema-Migrationen von EF Core mit.
EF Core und Dapper müssen keine Grundsatzentscheidung sein. EF Core für das reguläre Datenmodell und Dapper für ausgewählte Abfragen können zusammenpassen. Zwei Zugriffswege erhöhen aber auch den Pflegeaufwand. Ob ein Wechsel tatsächlich schneller ist, sollte eine Messung mit realistischen Daten zeigen.
Die Abstraktion ist bewusst schmal: Bei Dapper bleiben Tabellen, Spalten und SQL-Dialekt sichtbar. Das ist hilfreich, wenn eine vorhandene Datenbank bereits komplexe Abfragen vorgibt. Es bedeutet aber auch: Umbenannte Spalten oder geänderte Ergebnistypen werden nicht durch ein gemeinsames LINQ-Modell abgefangen. Aussagekräftige Aliase und Integrationstests gegen den eingesetzten Datenbanktyp helfen, solche Brüche früh zu erkennen.
Für längere Vorgänge lohnt sich ein Blick auf CommandDefinition. Darüber lassen sich neben SQL und Parametern beispielsweise eine Transaktion, ein Command-Timeout und ein CancellationToken übergeben. Verlässt der Benutzer eine Ansicht, kann die Anwendung den Abbruch weiterreichen, statt die Datenbankarbeit unabhängig vom ursprünglichen Bedarf weiterlaufen zu lassen. Ob und wie schnell der Abbruch greift, hängt auch vom verwendeten Provider ab.
Mehrere Änderungen gehören zusammen: Soll eine Wartung gespeichert und zugleich der nächste Termin aktualisiert werden, braucht dieser Vorgang gegebenenfalls eine Transaktion. Die Anwendung öffnet sie auf der Verbindung und übergibt sie an die beteiligten Dapper-Aufrufe. Bei Erfolg wird bestätigt, bei einem Fehler zurückgerollt. Wenn EF Core und Dapper gemeinsam an derselben Arbeitseinheit beteiligt sind, müssen Verbindung und Transaktion ausdrücklich aufeinander abgestimmt werden.
Auch die Ergebnismenge bleibt wichtig. Die üblichen QueryAsync-Aufrufe puffern Ergebnisse; „schlanker Mapper“ bedeutet daher nicht automatisch geringen Speicherverbrauch bei riesigen Exporten. Für eine Bildschirmansicht sind begrenzte Abfragen meist sinnvoller. Bei großen Datenmengen muss zwischen Streaming, Verbindungsdauer und Verarbeitung abgewogen werden. SQL-Parameter schützen außerdem nur Werte: Dynamische Spaltennamen für eine Sortierung benötigen eine kontrollierte Zuordnung erlaubter Felder. Einfach Benutzereingaben in ORDER BY einzusetzen, wäre trotz ansonsten parametrisierter Abfrage falsch.

Externe APIs: weniger Routinecode, bewusster Umgang mit Ausfällen
Refit: einen HTTP-Client als Interface beschreiben
Bei REST-Clients wiederholen sich viele Aufgaben: URL zusammensetzen, Parameter übertragen, JSON lesen. Refit beschreibt den Aufruf über ein C#-Interface und erzeugt die Implementierung.
public interface IDeviceApi
{
[Get("/devices/{id}")]
Task<DeviceDto> GetDeviceAsync(
Guid id,
CancellationToken cancellationToken = default);
}
Hierfür werden Refit und ein passender DTO-Typ benötigt; Basisadresse und Registrierung kommen separat hinzu. Mit Refit.HttpClientFactory lässt sich der Client in Dependency Injection und IHttpClientFactory einbinden.
Das macht die Beschreibung der API-Aufrufe übersichtlich. Authentifizierung, Fehlerbehandlung und API-Änderungen verschwinden dadurch aber nicht. Ein C#-Interface verhindert beispielsweise nicht, dass der Server plötzlich ein anderes JSON-Format zurückliefert.
Den Client zentral konfigurieren: Das Interface beschreibt die Endpunkte, die Registrierung legt Basisadresse und HTTP-Pipeline fest. Damit bleiben Transportdetails außerhalb der Fachklasse, die beispielsweise Gerätedaten abfragt. Die HttpClientFactory-Anbindung lässt sich etwa so registrieren:
builder.Services
.AddRefitClient<IDeviceApi>()
.ConfigureHttpClient(client =>
client.BaseAddress = new Uri("https://api.example.com"));
Der Ausschnitt gehört in den Anwendungsstart und benötigt Refit.HttpClientFactory. Die Adresse ist ein Platzhalter. In einer realen Anwendung kommt sie sinnvollerweise aus der Konfiguration. Authentifizierung und wiederkehrende Header können über die HTTP-Pipeline ergänzt werden. Dabei ist vor allem die Lebensdauer von Tokens zu beachten: Ein beim Start einmal gelesener Token ist keine vollständige Lösung für ablaufende Anmeldungen.
Fehlerbehandlung gehört zur API-Schnittstelle: Der Rückgabetyp beeinflusst, wie die aufrufende Anwendung mit einer Antwort arbeitet. Ein einfacher Task<DeviceDto> passt, wenn erfolgreiche Antworten direkt verarbeitet und Fehler als Exceptions behandelt werden sollen. Mit Response-Wrappern wie ApiResponse<T> lassen sich Status, Header und Fehlerinformationen gezielt auswerten. Ein HTTP-Erfolg allein garantiert dabei noch keine erfolgreich deserialisierte Antwort.
Ein nicht gefundenes Gerät, eine fehlende Berechtigung und ein nicht erreichbarer Server verdienen unterschiedliche Reaktionen. Bei 404 kann die Oberfläche erklären, dass der Datensatz nicht mehr existiert. Bei einem Verbindungsfehler sollte sie die eingegebenen Daten erhalten und einen erneuten Versuch ermöglichen. Die Entscheidung, wie die Anwendung auf diese Fehler reagiert, nimmt Refit nicht ab.
Für Tests sollte außerdem nicht nur das Interface gemockt werden. Das prüft zwar den aufrufenden Service, aber weder den tatsächlichen Pfad noch die JSON-Zuordnung. Ein zusätzlicher Test mit kontrollierter HTTP-Antwort kann Änderungen an Feldnamen, Statuscodes und leeren Antwortkörpern sichtbar machen. Refit reduziert den Transportcode; ein überprüfbarer API-Vertrag bleibt trotzdem nötig.
Microsoft.Extensions.Http.Resilience: auf Störungen vorbereitet sein
Ein externer Dienst antwortet manchmal langsam oder vorübergehend gar nicht. Microsoft.Extensions.Http.Resilience ergänzt HttpClient um Resilience-Strategien und baut dabei auf Polly auf. Dazu gehören unter anderem Timeouts, Wiederholungen und ein Circuit Breaker.
Ein Timeout begrenzt die Wartezeit. Ein Retry versucht einen geeigneten Aufruf erneut. Ein Circuit Breaker unterbricht weitere Versuche vorübergehend, wenn eine Abhängigkeit wiederholt ausfällt. Diese Mechanismen lassen sich auch mit einem über die HttpClientFactory registrierten Refit-Client kombinieren.
Ein Retry ist nicht für jeden Aufruf harmlos. Wenn der Server einen Auftrag schon gespeichert hat und nur die Antwort verloren geht, kann eine Wiederholung einen zweiten Auftrag anlegen. Der Standard-Handler wiederholt standardmäßig auch HTTP-Methoden, bei denen das problematisch sein kann. Mit DisableForUnsafeHttpMethods() lassen sich diese Wiederholungen deaktivieren; alternativ braucht der Dienst ein geeignetes Idempotenzkonzept.
Die Einstellungen müssen deshalb zum Vorgang passen. Ein robuster Client wartet weder unbegrenzt noch erzeugt er durch unbedachte Wiederholungen zusätzliche Last.
Eine maximale Gesamtwartezeit festlegen: Drei Versuche mit jeweils langer Laufzeit können einen Benutzer erheblich länger warten lassen als erwartet. Deshalb sollten Anzahl der Versuche, Wartepausen und maximale Gesamtdauer zusammen geplant werden. Für ein interaktives Formular gelten andere Grenzen als für einen Hintergrundimport, der einen vorübergehenden Ausfall überbrücken darf. Die Oberfläche muss außerdem einen Abbruch bis zum eigentlichen Aufruf weiterreichen können.
Die Retry-Strategie von Polly erlaubt unter anderem zunehmende Warteabstände und Jitter. Der zufällige Anteil verhindert, dass viele Clients nach einer Störung alle im gleichen Takt erneut anfragen. Das hilft allerdings nur bei passend ausgewählten Fehlern. Ein fachlich ungültiger Request wird durch Wiederholung nicht gültig, und ein abgelaufener Zugang benötigt eine andere Behandlung als ein kurzzeitig überlasteter Dienst.
Ein Circuit Breaker liefert keine Ersatzdaten: Er beobachtet Ergebnisse und blockiert bei überschrittener Fehlerschwelle zeitweise weitere Aufrufe. Nach einer Pause wird geprüft, ob die Abhängigkeit wieder verfügbar ist. Die Polly-Dokumentation grenzt das klar von Retries ab: Ein Breaker übernimmt weder deren Wiederholungen noch automatisch einen Fallback. Die Anwendung muss entscheiden, ob sie einen zwischengespeicherten Stand anzeigt, den Vorgang verschiebt oder einen verständlichen Fehler meldet.
Bei der beispielhaften Geräteverwaltung könnte ein externer Herstellerdienst ausfallen, während lokale Gerätedaten weiterhin bearbeitbar bleiben. Diese Trennung muss die Anwendung vorsehen. Ein technisch erfolgreicher Fallback auf eine leere Liste wäre hier möglicherweise irreführend, weil er „keine Daten vorhanden“ statt „Quelle vorübergehend nicht erreichbar“ signalisiert.
Schließlich sollten Wiederholungen nicht unbemerkt auf mehreren Ebenen stattfinden. Wenn Client, eigener Service und Hintergrundjob jeweils erneut versuchen, vervielfacht sich die Last. Deshalb Zuständigkeit und maximale Gesamtdauer aller Versuche festlegen und Versuche, Abbrüche sowie geöffnete Breaker beobachten. Microsoft.Extensions.Resilience ist der allgemeinere Baustein; die HTTP-Erweiterung richtet diese Mechanismen gezielt auf ausgehende HTTP-Aufrufe aus.

Anfragen weiterleiten und Änderungen live anzeigen
YARP: Reverse Proxy mit eigener .NET-Logik
YARP steht für „Yet Another Reverse Proxy“ und ist eine Reverse-Proxy-Bibliothek auf ASP.NET Core. Damit lassen sich eingehende Anfragen an konfigurierte Ziele weiterleiten und in die eigene Middleware-Pipeline einbinden.
Interessant wird das, wenn die Weiterleitung eigene Anwendungslogik benötigt – etwa bei der schrittweisen Ablösung einer alten API. Für gewöhnliches Routing am Rand einer bestehenden Infrastruktur ist eine zusätzliche selbst entwickelte Proxy-Anwendung dagegen nicht automatisch die einfachste Lösung.
YARP ist ein Baustein für solche Szenarien, kein fertig eingerichtetes API-Management. Welche Regeln für Zugriff, Betrieb und Überwachung gelten, muss weiterhin festgelegt werden.
Route, Cluster und Destination: Die YARP-Konfiguration trennt diese Begriffe. Eine Route beschreibt, welche eingehenden Anfragen passen, beispielsweise anhand eines Pfads. Sie verweist auf einen Cluster. Dieser enthält eine oder mehrere Destinations, also konkrete Zieladressen. Dadurch lässt sich die öffentliche Adresse einer API von ihren internen Instanzen entkoppeln.
Für die schrittweise Migration einer Geräteverwaltung könnte /api/devices bereits an den neuen Dienst gehen, während /api/reports noch vom Altsystem beantwortet wird. Clients müssen dafür nicht zwingend auf zwei Basisadressen umgestellt werden. Das erleichtert eine schrittweise Ablösung, verlangt aber saubere Regeln: Überlappende Pfade und deren Priorität dürfen nicht erst im Produktivbetrieb auffallen.
Weiterleitung gezielt verändern: Über Transforms lassen sich beispielsweise Pfade oder Header anpassen. So kann ein öffentliches Präfix vor der Weiterleitung entfernt werden. Solche Anpassungen sollten überschaubar bleiben. Wenn der Proxy zunehmend fachliche Daten umschreibt, wird er selbst zu einer Anwendung mit eigenem Test- und Wartungsbedarf.
Besonders wichtig ist die Vertrauensgrenze. Ein vom Client selbst gesetzter Header darf nicht ungeprüft als Identitätsnachweis beim Zielsystem ankommen. Es muss klar sein, wo authentifiziert wird, welche Informationen weitergegeben werden und welche Berechtigungen das Zielsystem selbst überprüft. Ein erreichbarer Proxy-Endpunkt bedeutet noch nicht, dass der dahinterliegende Vorgang für jeden erlaubt ist.
Auch der Betrieb gehört zur Entscheidung: Der Proxy liegt im Anfrageweg und kann damit selbst zum Engpass oder Ausfallpunkt werden. Laufzeiten, Fehlerquoten und die Erreichbarkeit der Zielserver sollten überwacht werden können. Für einen einfachen Dienst hinter einer bereits vorhandenen Traefik- oder Nginx-Konfiguration entsteht durch YARP nicht automatisch ein Vorteil. Es lohnt sich besonders dann, wenn die Weiterleitungslogik tatsächlich Teil der eigenen .NET-Anwendung sein soll.
SignalR: Aktualisierungen vom Server zum Client
Wird eine Wartung abgeschlossen, sollen andere geöffnete Ansichten den neuen Status sehen. Mit ASP.NET Core SignalR kann der Server Nachrichten an verbundene Clients senden, statt auf deren nächste regelmäßige Abfrage zu warten.
Hubs und die gezielte Ansprache von Clients oder Gruppen vereinfachen dabei die Verwaltung der Kommunikation. Das passt zu Live-Dashboards, Fortschrittsanzeigen und gemeinsam genutzten Anwendungen. Bei mehreren Serverinstanzen muss die Verteilung der Nachrichten mitgeplant werden.
SignalR ist dabei keine vollständige Offline-Synchronisation. Nach einer Unterbrechung muss die Anwendung ihren aktuellen Zustand gegebenenfalls erneut laden. Auch die Entscheidung, welcher Benutzer welche Meldung erhalten darf, bleibt Teil der Anwendung.
Vom gespeicherten Vorgang zur Meldung: Die eigentliche Änderung sollte zunächst zuverlässig gespeichert werden. Danach kann ein Anwendungsservice über IHubContext<THub> eine Nachricht senden. Dafür muss die Fachlogik nicht in die Hub-Klasse wandern. Der Hub stellt die Kommunikationsschnittstelle bereit; Speicherung und Geschäftsregeln bleiben in ihren zuständigen Services.
In der Geräteverwaltung wäre eine Meldung wie „Gerät X wurde geändert“ oft ausreichend. Der Client lädt anschließend den aktuellen Datensatz nach. Das hält Nachrichten klein und bündelt die Berechtigungsprüfung für den Lesezugriff in der API. Alternativ können passende Änderungen direkt übertragen werden. Dann müssen Nachrichtenschema, Versionskonflikte und die Reihenfolge der Verarbeitung sorgfältiger berücksichtigt werden.
Gruppen sind keine Berechtigungen: Mit SignalR-Gruppen können beispielsweise alle Client-Verbindungen einer Organisation gemeinsam angesprochen werden. Der Server muss aber vor dem Beitritt prüfen, ob der Benutzer dieser Organisation angehört und auf deren Daten zugreifen darf. Eine vom Client übergebene Organisations-ID allein ist dafür kein Berechtigungsnachweis. Wird dem Benutzer die Berechtigung entzogen, muss der Server auch den weiteren Empfang dieser Gruppennachrichten unterbinden.
Nach einem Verbindungsabbruch sollte die Oberfläche den Zustand sichtbar machen. Bei den üblichen Neuverbindungen sind Gruppenbeitritte erneut zu organisieren. Automatische Wiederverbindung und das Wiederherstellen des fachlichen Zustands sind unterschiedliche Aufgaben: Eine wieder offene Verbindung sagt noch nichts darüber aus, welche Änderungen während der Unterbrechung passiert sind.
Außerdem sind Datenbankspeicherung und anschließendes Senden nicht automatisch atomar. Stürzt der Prozess genau dazwischen ab, kann die Änderung gespeichert sein, ohne dass die Meldung ankommt. Für eine reine Aktualisierung der Anzeige reicht oft ein erneutes Laden beim Öffnen oder Verbinden. Müssen Ereignisse zuverlässig weiterverarbeitet werden, braucht es ein dauerhaftes Zustellkonzept, beispielsweise eine Outbox mit separater Verarbeitung. SignalR verbessert die unmittelbare Rückmeldung, übernimmt aber nicht die Rolle einer verlässlichen Ereignisablage.
Welche Werkzeuge gehören wirklich ins Projekt?
Für eine kleine Anwendung wäre es unnötig, alle neun Bausteine vorsorglich einzubauen. Sinnvoller ist es, beim konkreten Aufwand anzusetzen: unbrauchbare Logs verbessern, wiederholte Client-Implementierungen bündeln oder wichtige Regeln durch Tests absichern.
Jede zusätzliche Abhängigkeit bedeutet auch Updates, Kompatibilitätsfragen und Wartung. Ein Paket lohnt sich dann, wenn es mehr verständlichen, gut betreuten Code mitbringt, als die Anwendung andernfalls selbst pflegen müsste.
So entsteht Produktivität nicht durch eine möglichst lange NuGet-Liste, sondern durch weniger wiederkehrende Arbeit. Welche dieser Aufgaben kostet dich in deinen Projekten gerade am meisten Zeit?
Technische Quellen: die jeweils verlinkten Projekt- und Herstellerdokumentationen. Stand: 13. November 2026. Die Illustrationen wurden mit KI erstellt.












