Zugriff auf Einstellungen während des Setups in ASP.NET Core / .NET 8

Warum früher Zugriff auf Konfiguration wichtig ist

Tim Corey hebt die Bedeutung von App-Einstellungen in ASP.NET Core hervor. Laut Tim ist appsettings.json ein "großartiger Ort, um Konfigurationen zu speichern", da Entwickler Werte ändern können, ohne Anwendungen neu zu kompilieren oder neu zu deployen.

In der Webentwicklung ist es üblich, sich auf Konfigurationen für Dienste zu stützen, wie das Festlegen von URLs für APIs oder das Anpassen umgebungsspezifischer Parameter. Normalerweise greifen Entwickler in einer .NET Core-Web-App über Dependency Injection auf die Konfiguration zu:

@inject IConfiguration config

Tim weist jedoch darauf hin, dass Sie manchmal während der Einrichtung auf diese Konfigurationswerte zugreifen müssen, zum Beispiel beim Konfigurieren von HTTP-Clients oder anderen Diensten in program.cs. Dadurch bleibt Ihre Anwendung flexibel und anpassbar, wenn sie über verschiedene Umgebungen wie Entwicklung, Inszenierung oder Produktion hinweg migriert.

Erstellen einer minimalen Blazor-App

Um dies zu demonstrieren, erstellt Tim eine einfache Blazor-Anwendung, wobei die Interaktivität deaktiviert wird, um sich ganz auf program.cs zu konzentrieren. Er betont, dass die Architektur von ASP.NET Core Ihnen ermöglicht, die Konfiguration vom Code zu trennen, was die Verwaltung von Web-Apps und cloud-nativen Projekten erleichtert.

Dieser Ansatz steht auch im Einklang mit der plattformübergreifenden Natur der .NET-Plattform, da die gleiche Konfigurationslogik auf Windows, Linux und macOS ohne Änderungen funktioniert.

Konfiguration eines HTTP-Clients mit App-Einstellungen

Tim führt uns durch ein Szenario, in dem ein HTTP-Client in program.cs registriert wird:

builder.Services.AddHttpClient("LocalAPI", client =>
{
    client.BaseAddress = new Uri("https://localhost:7654");
});

Obwohl dies funktioniert, erklärt Tim, dass das Hardcodieren der URL nicht ideal ist. Wenn sich der API-Endpunkt ändert, müssen Entwickler den Code aktualisieren und einen Pull-Request zur Bereitstellung erstellen. Er empfiehlt stattdessen, den Wert in appsettings.json zu speichern:

{
  "LocalAPI": "https://localapi.fromconfig"
}

Dies stellt sicher, dass das Framework die Konfiguration dynamisch abruft, was eine Neukompilierung vermeidet und Fehler bei der Bereitstellung reduziert. Es steht auch im Einklang mit den bewährten Methoden für sichere und wartbare Web-Apps.

Konfiguration in Program.cs abrufen

Tim demonstriert, wie man Konfigurationswerte vor der Dependency Injection abruft:

var localApiBaseAddress = builder.Configuration.GetValue<string>("LocalAPI");

Wichtige Punkte, die Tim hervorhebt:

• builder.Configuration ist vor builder.Build() verfügbar.

• Werte können aus appsettings.json, Umgebungsvariablen, Benutzgeheimnissen oder sogar dem Azure Key Vault stammen.

• Dies ermöglicht Ihnen, Dienste, Logging oder andere Web-Framework-Komponenten dynamisch zu konfigurieren.

Tim setzt einen Haltepunkt, um zu überprüfen, dass die LocalAPI-URL korrekt abgerufen wird. Er stellt fest, dass diese Methode auf allen unterstützten Plattformen funktioniert, was sie ideal für plattformübergreifende Entwicklung macht.

Umgang mit fehlender Konfiguration

Tim geht auf Szenarien ein, bei denen ein Konfigurationsschlüssel fehlen oder null sein könnte. Er zeigt, dass Sie einen Standardwert mit GetValue bereitstellen können:

var localApiBaseAddress = builder.Configuration.GetValue<string>("LocalAPI", "https://localhost:7654");

Dies stellt sicher, dass Ihre Anwendungen bereit sind, auch wenn die Konfiguration nicht gesetzt ist, was die Fehlerbehandlung und Entwicklerproduktivität verbessert. Es verringert auch die Wahrscheinlichkeit von Laufzeitproblemen in Cloud-Bereitstellungen oder auf unterschiedlichen Plattformen.

Vorteile des frühen Konfigurationszugriffs

Tim skizziert mehrere Vorteile, die das Abrufen der Konfiguration während der Einrichtung bietet:

1. Dynamische Einrichtung: Dienste wie HttpClient können umgebungsspezifische Endpunkte verwenden.

2. Keine Neukompilierung: Änderungen an URLs oder anderen Einstellungen erfordern keine Codeänderungen mehr.

3. Flexibles Logging und Dienste: Konfigurieren Sie Logger oder andere Web-Framework-Dienste mithilfe von Konfigurationswerten.

4. Unterstützt mehrere Quellen: Konfiguration kann aus appsettings.json, Umgebungsvariablen, Benutzgeheimnissen oder Cloud-Schlüssel-Tresoren stammen.

Er betont, dass dieser Ansatz Anwendungen leicht und wartbar hält und gleichzeitig die Vorteile des ASP.NET Core-Frameworks und der .NET-Plattform voll ausschöpft.

Ausführen und Testen der Anwendung (6:03–7:36)

Tim demonstriert die Bereinigung des Codes und das Ausführen der App. Er zeigt, dass die LocalAPI-URL entweder aus der Konfiguration abgerufen oder auf den Standardwert zurückgegriffen wird:

var localApiBaseAddress = builder.Configuration.GetValue<string>("LocalAPI", "https://localhost:7654");

Dieses flexible Setup ermöglicht es Entwicklern, weiterhin Web-Apps zu erstellen, ohne sich um hartcodierte URLs oder wiederholte Pull-Requests für geringfügige Änderungen sorgen zu müssen. Es stellt auch sicher, dass plattformübergreifende Bereitstellungen auf Linux, Windows oder macOS nahtlos sind.

Abschluss

Tim Corey schließt ab, indem er die Einfachheit und Effizienz des Konfigurationszugriffs während der Einrichtung in ASP.NET Core / .NET 8 betont. Durch die Nutzung von:

builder.Configuration.GetValue()

können Entwickler:

• Dienste dynamisch konfigurieren

• Vermeiden, Werte im Framework hart zu codieren

• Unterstützung für mehrere Umgebungen und Plattformen erhalten

• Entwicklereffizienz und Fehlerbehandlung verbessern

Diese Technik ist unerlässlich, um sichere, wartbare und cloudfähige Webanwendungen zu erstellen. Tims praktische Demonstration zeigt, wie selbst eine leichte, plattformübergreifende ASP.NET Core-Anwendung robust, flexibel und bereit für die moderne Webentwicklung sein kann.

Das Video von Tim Corey ist ein Muss für Entwickler, die das Konfigurationsmanagement in ASP.NET Core beherrschen wollen. Durch das Befolgen seiner Schritte können Sie sicherstellen, dass Ihre Apps flexibel, wartbar und bereit für plattformübergreifende Bereitstellung, Cloud-Umgebungen und moderne Webarchitektur sind.