Entwicklungs-Roadmap

Dieses Update wird vollständige Unterstützung für die Projektgenerierung auf Basis von .NET 10 bieten, sobald die neue Version offiziell von Microsoft veröffentlicht wird.

Derzeit generiert Lino Projekte auf Basis von .NET 9 und nutzt dabei alle verfügbaren Plattformfunktionen, einschließlich Leistungsverbesserungen, fortgeschrittene Features von C# 13 und moderne Integration mit ASP.NET Core.

Das Ziel dieser zukünftigen Version ist es, sofortige Unterstützung für .NET 10 mit aktualisierten Templates, passenden Target Framework-Konfigurationen und einem für neue Sprach- und Laufzeitfunktionen vorbereiteten Scaffolding bereitzustellen.

Automatisierte Testgenerierung mit Unterstützung für zwei Hauptstufen:

Unit-Tests:
Erstellung von Tests für einzelne Klassen und Methoden mit Fokus auf Geschäftslogik.

Integrationstests:
Erstellung von Tests zur Überprüfung der Integration zwischen Komponenten, indem Interaktionen mit Datenbanken und externen Diensten simuliert werden.

Implementierung der automatischen Generierung von .http-Dateien zur Vereinfachung von Tests und Dokumentation von REST-Endpunkten in Entwicklungsumgebungen.

Berechtigungsbasiertes Zugriffskontrollsystem (PBAC) unter Verwendung von Policies in ASP.NET Core.
Die Berechtigungen werden automatisch durch Source Generators erstellt und als Policies in .NET registriert.
Jeder Dienst, der diese Berechtigungen nutzt, löst Ereignisse aus, die die Berechtigungsdatenbank des Systems automatisch aktualisieren.

Hauptmerkmale:
_ Automatische Generierung von Berechtigungen über Source Generators
_ Automatische Registrierung von Policies in ASP.NET Core
_ Dynamische Aktualisierung der Berechtigungsdatenbank über Ereignisse/Nachrichten
_ Unterstützung für hybrides RBAC, das die Einfachheit von Rollen mit der Granularität von Berechtigungen kombiniert

Vorteile:
_ Maximale Leistung und Skalierbarkeit
_ Automatisierte Verwaltung und vereinfachte Wartung
_ Flexibilität für unterschiedliche Sicherheitszenarien

Implementierung der nativen Unterstützung für den Typ IFormFile bei Endpunkten, die mit Minimal APIs erstellt wurden. Diese Funktion ermöglicht die automatische Generierung von Routen mit Datei-Uploads, darunter:

_ Definition von Endpunkten mit Unterstützung für Uploads über multipart/form-data;
_ Automatische Validierung von MIME-Typen und maximal zulässiger Dateigröße;
_ Unterstützung für lokale Speicherung und Integration mit Cloud-Diensten wie Azure Blob Storage und AWS S3;

Ideal für Anwendungen, die einen sicheren und performanten Datei-Upload benötigen – z. B. für Bilder, Dokumente und Medien.

Ab dieser Version führt die Lino CLI ein intelligentes automatisches Zusammenführen der generierten Dateien durch. Früher ersetzten die von Lino erstellten Dateien direkt die vorhandenen, wodurch manuelle Änderungen des Entwicklers überschrieben werden konnten.

Jetzt kann Lino dank der neuen 3-Wege-Merge-Strategie (original generierte Datei, vom Benutzer bearbeitete Version und neu generierte Datei) Anpassungen erhalten und gleichzeitig strukturelle Updates der Vorlage anwenden.

Vorteile dieses Ansatzes:
_ Verhindert versehentliches Überschreiben von manuellem Code.
_ Erleichtert die kontinuierliche Weiterentwicklung von templatebasierten Projekten.
_ Reduziert manuelle Konflikte bei Updates.
_ Verbessert die Integration zwischen lokalen Anpassungen und der Weiterentwicklung des Frameworks.

Mit Lino CLI generierte Projekte können nun Minimal APIs automatisch registrieren, indem sie die Tolitech.Presentation.API.Generators-Bibliothek verwenden, die auf Source Generators basiert.

Dieser Ansatz ersetzt die Notwendigkeit:
_ Jede Route manuell über MapGet, MapPost usw. zu registrieren
_ Reflection zu verwenden, um Routen zu scannen und zuzuordnen — was performanceintensiv ist.

Durch den Einsatz von Source Generators erfolgt das Routing zur Compile-Zeit, was optimierten, sauberen und nachvollziehbaren Code erzeugt.

Hauptvorteile:
_ Beseitigt die Wiederholung und Umständlichkeit manueller Routendeklaration
_ Verzicht auf Reflection reduziert CPU- und Speicherverbrauch
_ Verbesserte Codeorganisation und klare Trennung der Verantwortlichkeiten
_ Sichere, automatische Routenerstellung mit Compile-Time-Validierung
_ Erleichtert Wartung und Skalierbarkeit des Projekts

Wir verwenden jetzt die Bibliothek Tolitech.DependencyInjection.Generators, die den auf Reflection basierenden Ansatz von Tolitech.DependencyInjection.Extensions ersetzt.

Diese neue Bibliothek nutzt die Source Generators von .NET, um Abhängigkeitsregistrierungen automatisch zur Kompilierzeit zu generieren.

Das bietet mehrere Vorteile:
_ Entfernung von Reflection zur Laufzeit, wodurch die Anwendungsleistung verbessert wird.
_ Vorhersehbare und nachvollziehbare Codegenerierung.
_ Sicherere Kompilierung mit frühzeitiger Fehlererkennung.
_ Native Integration in die .NET-Build-Pipeline.

Wir verwenden jetzt den Central Package Manager (CPM), einen modernen Ansatz zur Verwaltung von NuGet-Paketen in Lösungen mit mehreren Projekten. Damit werden alle Paketversionen zentral in der Datei Directory.Packages.props definiert, was Inkonsistenzen beseitigt und sichere, koordinierte Updates erleichtert. Dies reduziert Fehler durch Versionskonflikte zwischen Projekten, verbessert die Nachverfolgbarkeit und vereinfacht großflächige Aktualisierungen von Abhängigkeiten.

Lino erstellt jetzt Lösungen im neuen Format .slnx, einer modernen Weiterentwicklung des traditionellen .sln.
Das auf XML basierende .slnx wurde übernommen, da es für Menschen und Tools besser lesbar ist und die Komplexität bei der Integration mit externen Systemen und CI/CD-Pipelines reduziert.

Darüber hinaus verbessert seine sauberere Struktur die Versionskontrolle erheblich – Änderungen sind vorhersehbarer und leichter zu überprüfen.
Diese Änderung entspricht der zukünftigen Ausrichtung des .NET-Ökosystems und fördert eine bessere Interoperabilität, Erweiterbarkeit und Automatisierung in der Projektentwicklung.

Das Community-Abonnement bietet nun Unterstützung für die Erstellung von Projekten basierend auf .NET 9 und Aspire 9.2.1, sodass Benutzer die Funktionen der Plattform kostenlos und technisch erkunden können.

Diese Version umfasst:
_ Erstellung von Services und Entitäten mit automatisiertem Scaffolding;
_ Auswahl der Datenbank und vollständige Initialkonfiguration;
_ Funktionale Generierung bis zur Phase von EF Core Migrations.

Obwohl fortgeschrittene Funktionen wie Mikrodienste und modulare Monolithen auf kostenpflichtige Pläne beschränkt sind, bietet diese Version eine solide Grundlage zur Bewertung der generierten Architektur, der Codequalität und der Integration mit dem modernen .NET-Ökosystem.

Die CLI bietet jetzt den Befehl lino database migrations add an, um die Erstellung von Migrationen für beliebige Dienste oder Module des Projekts zu erleichtern.

Diese Funktion automatisiert die Generierung von Migrationsskripten, die an die Build-Version gebunden sind, und ermöglicht eine konsistente Dokumentation der Änderungen.

Hauptvorteile:
_ Schnelle Erstellung von Migrationen pro Dienst oder Modul mit einfachen und direkten Befehlen.
_ Automatische Generierung von .sql-Skripten, die mit der Projektversionierung kompatibel sind.
_ Erleichtert die Versionskontrolle der Datenbank auch in verteilten Architekturen.
_ Standardisiert und dokumentiert strukturelle Datenbankänderungen sicher und prüfbar.
_ Natürliche Integration in den Build- und Deployment-Prozess der Anwendung.

Die neue Versionierungsfunktion ermöglicht es, vorhandene Versionen aufzulisten und einen Versions-Bump für mit dem Tool generierte Dienste und Webanwendungen durchzuführen, gemäß der SemVer-Konvention (Semantische Versionierung). Dies sorgt für mehr Nachvollziehbarkeit, Standardisierung und Kontrolle im Release-Zyklus.

Mit dem Befehl version kann die Versionsnummer eines jeden Dienstes oder einer Anwendung einfach festgelegt und aktualisiert werden, was Audits erleichtert und Best Practices in den Entwicklungsprozess integriert.

Der Befehl build wurde ebenfalls verbessert, um Docker-Images mit dem definierten Versionstag zu erstellen, was das Packaging vereinfacht und die Anwendungen für die Veröffentlichung vorbereitet.

Diese Verbesserungen erhöhen die Konsistenz und Vorhersehbarkeit im Release-Management und bieten mehr Transparenz für Entwicklungs- und Betriebsteams.

Anpassen, welche Eigenschaften bei der Generierung von Artefakten des Typs Command (Post, Put, Patch) und Query (Get) berücksichtigt werden.

Diese Funktion bietet:
_ Interaktive CLI-Oberfläche zur Auswahl von Eigenschaften während des Entity-Scaffoldings;
_ Automatische Generierung von Objekten mit nur den ausgewählten Feldern für Input/Output;
_ Vollständige Unterstützung zur Anpassung von Payloads in REST-APIs, wodurch Flexibilität und Kontrolle über übertragene Daten erhöht werden;
_ Integration mit Validierung und generierten Datenverträgen unter Einhaltung von Pflicht- und Konsistenzregeln.

Diese Verbesserung zielt darauf ab, eine feinere Modellierung von Artefakten zu ermöglichen, damit Entwickler genau steuern können, was über die von der CLI generierte Architektur exponiert, gespeichert oder abgefragt wird.

In Lino CLI wurde ein automatischer Mechanismus zur Versionierung und Sicherung von Dateien implementiert, um Sicherheit und Nachverfolgbarkeit bei der Erstellung und Überschreibung von Dateien zu gewährleisten.

Alle generierten Dateien werden im Ordner /.lino/files/.../received/ gespeichert, was eine zeitliche Organisation und einfache Auffindbarkeit sicherstellt.

Ersetzte Dateien bleiben im Ordner /.lino/files/.../replaced/ gespeichert, wodurch eine Wiederherstellung früherer Versionen bei Bedarf möglich ist. Diese Backup-Struktur bietet mehr Kontrolle und Sicherheit und ermöglicht eine vollständige Überprüfung der generierten Dateien, insbesondere in kollaborativen und automatisierten Entwicklungsumgebungen.

Vollständige Implementierung von Authentifizierung und Autorisierung für Frontend- und Backend-Projekte basierend auf JWT (JSON Web Tokens) und granularem Berechtigungsmanagement durch benutzerdefinierte Authorization Policies in ASP.NET Core.

Highlights:
_ Sicheres Login mit Ausgabe und Validierung von JWTs.
_ Autorisierung basierend auf benutzerdefinierten Richtlinien (Claims und Rollen).
_ Automatische Integration zwischen generierten APIs und Frontends (Blazor).
_ Schutz von Routen und Komponenten basierend auf Benutzerberechtigungen.

Vorteile:
_ Robuste Sicherheit für moderne Anwendungen.
_ Standardisierung des Zugriffsmodells nach Profil und Domäne.
_ Sicheres und integriertes Nutzungserlebnis zwischen den Anwendungsschichten.
_ Einfach erweiterbar und an Unternehmensszenarien anpassbar.

Es ist jetzt möglich, ein oder mehrere Frontends zu generierten Projekten hinzuzufügen, mit anfänglicher Unterstützung für Blazor Web Apps — einschließlich der Server- und WebAssembly-Modelle.

Diese Frontends werden automatisch mit den von dem Tool generierten APIs integriert, wodurch die Erstellung kompletter CRUD-Seiten mit direkten Aufrufen der Backend-Endpunkte und Persistenz in der Datenbank ermöglicht wird.

Highlights:
_ UI-Generierung basierend auf Domänenentitäten.
_ Native Kommunikation mit den generierten APIs.
_ End-to-End-Funktionalität: Frontend, Backend und Datenbank arbeiten zusammen.
_ Möglichkeit mehrerer Frontends im selben Projekt (z.B. Admin, Portal, Öffentlich).

Vorteile:
_ Schnelle Entwicklung von Benutzeroberflächen.
_ Weniger Nacharbeit und manuelle Integration.
_ Einheitlicher Standard für Navigation, Stil und Datenzugriff.
_ Höhere Produktivität durch automatische Generierung von CRUD-Seiten.

Wir haben das Muster Transactional Outbox implementiert, um die Zuverlässigkeit beim Versenden von Integrationsereignissen zu gewährleisten. Anstatt das Ereignis direkt während der Anwendungstransaktion zu veröffentlichen, wird es nun in einer speziellen Tabelle innerhalb derselben Datenbanktransaktion registriert.

Anschließend liest ein background job diese Outbox und führt die tatsächliche Auslösung des Ereignisses durch.

Vorteile dieses Ansatzes:
_ Gewährleistet Konsistenz zwischen Datenbankänderungen und Ereignisveröffentlichung.
_ Verhindert Nachrichtenverlust bei Zwischenfehlern.
_ Ermöglicht Kontrolle von Wiederholungen und Auditierung veröffentlichter Ereignisse.
_ Entspricht bewährten Praktiken ereignisgesteuerter Architektur und Microservices.

Es wurde die Möglichkeit hinzugefügt, Background Jobs in generierten Services — ob einfach oder modular — mithilfe der Bibliothek Hangfire zu integrieren.

Damit verfügen Projekte nun standardmäßig über Terminierung und Ausführung von Hintergrundaufgaben, einschließlich:
_ Wiederkehrende (cron), geplante oder sofortige Ausführung.
_ Überwachung über ein integriertes Dashboard.
_ Sichere Persistenz und Wiederverarbeitung von Jobs.

Dieser Mechanismus kann auch zusammen mit dem Transactional Outbox Pattern verwendet werden, um eine zuverlässige Auslösung von Integrationsereignissen selbst bei Teilfehlern oder in verteilten Szenarien zu gewährleisten.

Hauptvorteile:
_ Automatisierung wiederkehrender und langwieriger Aufgaben ohne Blockierung des Hauptflusses.
_ Hohe Resilienz und Beständigkeit von Hintergrundaufgaben.
_ Sofortige Integration mit dem Outbox-Pattern für zuverlässige Ereignisse.
_ Einfache Konfiguration und Anpassung von Jobs pro Service.
_ Integriertes Dashboard zur Überwachung und Steuerung von Ausführungen.

Die Möglichkeit wurde hinzugefügt, Unterstützung für asynchrone Nachrichtenübermittlung mit RabbitMQ zu konfigurieren, unter Nutzung der Abstraktion und fortgeschrittenen Funktionen von MassTransit.

Dadurch können generierte Services entkoppelt und resilient kommunizieren, indem sie verteilte Events und Commands verwenden.

Highlights der Integration:
_ Automatisierte Transportkonfiguration mit RabbitMQ.
_ Veröffentlichung und Empfang von Events via MassTransit mit nativer Dependency Injection.
_ Kompatibel mit dem Transactional Outbox Pattern für höhere Zuverlässigkeit.

Vorteile:
_ Hohe Skalierbarkeit durch eventbasierte Kommunikation.
_ Entkopplung von Produzenten und Konsumenten.
_ Höhere Fehlertoleranz und automatische Wiederverarbeitung.
_ Einfache Wartung und Erweiterung asynchroner Geschäftsabläufe.

Ein robustes Unit of Work-System wurde implementiert mit voller Transaktionskontrolle, Verwaltung von Domain-Events, Veröffentlichung von Integrations-Events (Outbox Pattern), automatischem Rollback und Unterstützung des Result-Patterns für Commit/Rollback basierend auf Erfolg oder Misserfolg der Operation.

Highlights:
_ Explizite Erstellung von Transaktionen mit Isolationslevel-Kontrolle.
_ Veröffentlichung von Domain Events, synchron zur Datenpersistenz.
_ Entkoppelte Veröffentlichung von Integration Events via Outbox Pattern.
_ Automatisches Rollback und Ausnahmebehandlung mit Unterstützung von Constraint-Validierungen.
_ Commit bedingt durch das Result der Operation.
_ Strukturierte Protokollierung von Events, Transaktionen und Fehlern.

Vorteile:
_ Transaktionale Konsistenz zwischen Datenbankoperationen und generierten Events.
_ Flexibilität bei der Nutzung von Standard-SaveChanges oder vollständiger Steuerung des Ablaufs.
_ Einfachheit bei Unit-Tests und Fehlernachverfolgung.
_ Klare Trennung zwischen Domäne und Infrastruktur mit MediatR-Unterstützung.

Es ist jetzt möglich, für jeden generierten Dienst individuell die zu verwendende Datenbank festzulegen — mit nativer Unterstützung für SQL Server und PostgreSQL.

Dieser Ansatz ermöglicht es, dass jeder Dienst seine eigene exklusive Datenbank hat, was vollständige Isolation gewährleistet und die Umsetzung von echten Microservice-Architekturen erleichtert.

Bei modularen Diensten verwendet die Anwendung weiterhin eine einzelne Datenbank pro Dienst, wobei jeder Modul durch ein Schema getrennt wird, was Organisation und Kohärenz bewahrt.

Hauptvorteile:
_ Datenisolation zwischen Diensten erhöht Sicherheit und Verantwortlichkeitsklarheit.
_ Stufenweise Einführung von Microservices mit unabhängigen Datenbanken möglich.
_ Trennung per Schema bei modularen Diensten erleichtert Wartung und Domänenverständnis.
_ Volle Flexibilität bei der Wahl des passenden DBMS pro Dienst.
_ Einfache Tests, isolierte Deployments und horizontale Skalierbarkeit.

Das Lino CLI ermöglicht dem Entwickler jetzt, während der Projekterstellung zwischen der Erstellung von einfachen Diensten (traditionell) oder modularen Diensten zu wählen, mit voller Freiheit, beide nach Bedarf innerhalb der Lösung zu kombinieren.

Dieser Ansatz bietet direkte Unterstützung für unterschiedliche Architekturansätze:
Einfache Dienste: ideal zur Zusammensetzung von Microservice-basierten Lösungen oder zum Aufbau traditioneller monolithischer Anwendungen auf direkte und isolierte Weise.
Modulare Dienste: strukturieren die Anwendungsdomäne in Bounded Contexts und erleichtern die Einführung eines Modular-Monolithen mit klarer Verantwortlichkeitsverteilung und besserer Komponenten-Zusammenhalt.

Sie können beliebig viele Dienste hinzufügen — einfach, modular oder beides — je nach Anwendungsszenario.

Vorteile dieses Ansatzes:
_ Größere Flexibilität bei der Architekturmodellierung.
_ Einfache schrittweise Skalierung von einem Monolithen zu Microservices.
_ Klare Trennung der Verantwortlichkeiten nach Domäne oder Kontext.
_ Bessere Codeorganisation und Ausrichtung an modernen Architekturpraktiken.
_ Weniger Kopplung und höhere Wartbarkeit.

Entwickeln Sie mit Microservices oder entscheiden Sie sich für einen modularen Monolithen — Sie wählen den idealen Weg für Ihre Anwendung.

Native Unterstützung für hybrides Caching wurde mit der Bibliothek Microsoft.Extensions.Caching.Hybrid hinzugefügt.

Die Implementierung kombiniert In-Memory-Caching (MemoryCache) mit verteiltem Caching (DistributedCache) und bietet so das Beste aus beiden Welten.

Dieser Ansatz ermöglicht extrem schnelle Antworten auf häufige Anfragen und sorgt gleichzeitig für Synchronisierung und Skalierbarkeit in verteilten Umgebungen.

Vorteile der hybriden Strategie:
_ Hohe Leistung durch sofortigen Lesezugriff auf lokalen Speicher.
_ Persistenz und Datenaustausch zwischen Instanzen über verteilten Cache.
_ Reduzierung von Datenbank- und API-Aufrufen.
_ Bessere horizontale Skalierbarkeit bei Anwendungen mit mehreren Replikas.
_ Intelligente Synchronisierung zwischen beiden Cache-Ebenen.

Ideal für Szenarien, die Leistung und Konsistenz erfordern, ohne auf architektonische Flexibilität zu verzichten.

Lino CLI generiert jetzt Projekte mit integrierter Mehrsprachigkeitsunterstützung, einschließlich automatischer Übersetzung für die folgenden Kulturen:
en, pt-BR, es, fr, it, de, ja, ko, zh-Hans und ru.

Die Ressourcen-Dateien (resx) werden automatisch basierend auf der Hauptsprache generiert und die Inhalte automatisch übersetzt, bereit zur sofortigen Verwendung in globalen Anwendungen.

Vorteile der Mehrsprachigkeitsunterstützung:
_ Erleichtert die Erstellung von Anwendungen für verschiedene Regionen und Kulturen.
_ Verkürzt die für die Internationalisierung benötigte Zeit.
_ Native Integration mit dem .NET-Lokalisierungssystem.
_ Verbessert die Endbenutzererfahrung in mehrsprachigen Anwendungen.
_ Ermöglicht schnelles Skalieren von Lösungen für den globalen Markt.

Die vom Lino CLI generierten Codes verwenden jetzt LoggerMessage, um Logs effizienter und leistungsfähiger zu erfassen.

Im Gegensatz zu herkömmlichen Erweiterungsmethoden von ILogger, die Boxing von Werttypen erzeugen und die Speicherallokation zur Laufzeit beeinflussen, erstellt das LoggerMessage-Muster stark typisierte und statische Actions für jede Lognachricht.

Vorteile dieses Ansatzes:
_ Deutliche Reduzierung der Speicherallokationen.
_ Vermeidet Boxing von Werttypen wie int, Guid, DateTime usw.
_ Bessere Leistung bei Szenarien mit hohem Log-Aufkommen.
_ Standardisierung und Zentralisierung von Lognachrichten.
_ Mehr Klarheit bei Audit, Diagnose und Überwachung.

Diese Verbesserung ist besonders relevant in APIs und Backend-Services, bei denen Leistung und Nachverfolgbarkeit entscheidend sind.

Die Lino CLI bietet jetzt eine optionale Unterstützung für Strongly Typed Ids, wodurch Entitätskennungen mit spezifischen, stark typisierten Typen statt generischer Typen wie Guid oder int dargestellt werden können.

Diese Funktion hilft, häufige Fehler wie das versehentliche Zuweisen eines Identifikators zwischen verschiedenen Entitäten zu vermeiden und macht den Code zugleich ausdrucksstärker und domänenorientierter.

Vorteile der Verwendung von Strongly Typed Ids:
_ Höhere Typsicherheit zur Kompilierzeit.
_ Verhindert versehentliche Zuweisungen zwischen verschiedenen Entitäten.
_ Verbessert Lesbarkeit und Ausdruck der Absicht im Code.
_ Erleichtert das Nachverfolgen und Debuggen von Identifikatoren im Domänenkontext.
_ Integration mit EF Core, JSON-Serialisierung und Validierung.

Die Funktion ist optional und kann bei der Projekterstellung aktiviert werden.

Generierte Projekte können jetzt mit Unterstützung für statische Codeanalyse konfiguriert werden, unter Verwendung der wichtigsten Analyzer des .NET-Ökosystems. Diese Tools sind direkt in den Build integriert und helfen, Formatierungs-, Stil-, Architekturprobleme und mögliche logische Fehler bereits in der Entwicklungsphase zu erkennen.

Vorteile:
_ Fördert Konsistenz und Standardisierung im Code von Anfang an.
_ Erkennt frühzeitig Bugs und schlechte Praktiken.
_ Erleichtert Code-Reviews und technische Onboardings.
_ Verbessert Qualität und Wartbarkeit des Codebestands.
_ Verhindert häufige Fehler und verbessert die Einhaltung der .NET-Best-Practices.

Die Konfiguration kann pro Projekt angepasst werden, was eine größere Flexibilität beim gewünschten Strengegrad ermöglicht.

Erstellung der Bibliothek Tolitech.Results, die das Result Pattern in .NET vollständig und flüssig implementiert.

Diese Bibliothek kapselt das Ergebnis von Operationen — egal ob erfolgreich oder fehlerhaft — in strukturierte Objekte, die HTTP-Status, Nachrichten, Fehler, Titel, Details und optionale Daten enthalten (mit Unterstützung für Result<T>).

Vorteile der Verwendung des Result Pattern:
_ Standardisierung der Rückgabe von Operationen in der gesamten Anwendung.
_ Reduzierung von Ausnahmen als Flusskontrolle.
_ Erleichterung der Komposition und Verkettung von Operationen.
_ Bessere Unterstützung der Kommunikation zwischen Schichten und Diensten.
_ Fließende Integration mit HTTP-APIs, Validierungen und Fehlermeldungen.
_ Verbesserte Debugging- und strukturierte Protokollierungserfahrung.

Darüber hinaus erweitern Erweiterungen wie Tolitech.Results.Http und Tolitech.Results.Guards die Integration mit REST-APIs und defensiven Validierungen.