C# Set Flag Enum verstehen: Flaggen zuweisen

Tim Corey

10m 39s

Das Konfigurationsmanagement ist ein wesentlicher Aspekt bei der Erstellung skalierbarer und wartbarer Anwendungen in C#. Eine der effektivsten Methoden zur Handhabung von Konfigurationseinstellungen ist die Verwendung des Options Pattern. In seinem Video The Options Pattern in C# in 10 Minutes or Less bietet Tim Corey eine prägnante und dennoch aufschlussreiche Erklärung dieses Musters und seiner effizienten Umsetzung. In diesem Artikel werden wir das Options Pattern anhand von Tims Erklärungen und Demonstrationen aus seinem Video untersuchen.

Einführung

Tim beginnt mit einer Einführung in das Options-Pattern als leistungsfähige und dennoch einfache Möglichkeit, Informationen aus Konfigurationsdateien abzurufen und sie in die Dependency Injection (DI) einzubinden. Er hebt mehrere Vorteile dieses Musters hervor, wie z. B.:

• Die Fähigkeit, Laufzeitwertänderungen zu verwalten.
• Integrierte Unterstützung für die Datenvalidierung.
• Kompatibilität mit verschiedenen C#-Projekttypen, einschließlich Blazor-Anwendungen.

Tim betont, dass er zwar in der Regel ausführliche technische Schulungen anbietet, dieses Video jedoch als Schnellstartanleitung für die Implementierung des Optionsmusters gedacht ist.

Projekt Einrichten

Tim beginnt mit dem Öffnen von Visual Studio mit einer Blazor Web App (nur serverseitiges Rendering). Er hat bereits ein paar Änderungen vorgenommen, um die Demonstration zu beschleunigen. Der Schlüsselaufbau beinhaltet:

• Erstellen einer appsettings.json-Datei mit einem CloudInfo-Abschnitt, der drei Schlüssel-Wert-Paare enthält.
• Verwenden eines Plain Old CLR Object (POCO) Modells namens CloudInfoOptions, das diese Konfigurationswerte zuordnet.

Die Konfigurationsdatei

Die appsettings.json-Datei enthält den folgenden Abschnitt:

{
  "CloudInfo": {
    "Storage": "Azure Storage",
    "Website": "Azure Static Web Apps",
    "API": "Azure Web App"
  }
}

{
  "CloudInfo": {
    "Storage": "Azure Storage",
    "Website": "Azure Static Web Apps",
    "API": "Azure Web App"
  }
}

Tim stellt klar, dass, während er appsettings.json verwendet, die Konfigurationswerte auch von folgenden Quellen stammen könnten:

• appsettings.Development.json
• secrets.json
• Umgebungsvariablen

Binden der Konfiguration an Optionen

Nun erklärt Tim, wie man die Konfigurationswerte bindet an die CloudInfoOptions-Klasse und diese in DI injiziert.

Registrieren von Optionen in Program.cs

In Program.cs fügt Tim die folgende Zeile innerhalb von builder.Services hinzu:

builder.Services.Configure<CloudInfoOptions>(builder.Configuration.GetSection("CloudInfo"));

builder.Services.Configure<CloudInfoOptions>(builder.Configuration.GetSection("CloudInfo"));

builder.Services.Configure(Of CloudInfoOptions)(builder.Configuration.GetSection("CloudInfo"))

builder.Services.Configure(Of CloudInfoOptions)(builder.Configuration.GetSection("CloudInfo"))

Dies bindet den CloudInfo-Abschnitt von appsettings.json an die CloudInfoOptions-Klasse. Tim merkt an, dass dieser Schritt sicherstellt, dass die Werte in Dependency Injection verfügbar sind.

Einfügen von Optionen in eine Razor-Komponente

Tim geht zur Home Page-Komponente (Index.razor) und modifiziert diese, um die Konfigurationswerte dynamisch anzuzeigen.

Er injiziert die IOptions-Schnittstelle in die Komponente:

@inject IOptions<CloudInfoOptions> CloudInfoOptions

@inject IOptions<CloudInfoOptions> CloudInfoOptions

Um die tatsächlichen Werte abzurufen, ordnet er sie innerhalb von OnInitialized zu:

protected override void OnInitialized()
{
    CloudInfo = CloudInfoOptions.Value;
}

protected override void OnInitialized()
{
    CloudInfo = CloudInfoOptions.Value;
}

Protected Overrides Sub OnInitialized()
    CloudInfo = CloudInfoOptions.Value
End Sub

Protected Overrides Sub OnInitialized()
    CloudInfo = CloudInfoOptions.Value
End Sub

Tim erklärt, dass IOptions<t> eine Singleton-Instanz der Konfigurationswerte bereitstellt, was bedeutet, dass sie während des gesamten Lebenszyklus der Anwendung konstant bleibt. Wenn die Anwendung ausgeführt wird, werden die Konfigurationswerte korrekt auf der Seite angezeigt.

Unterschiedliche Optionen erforschen Schnittstellen

Anschließend stellt Tim drei verschiedene Möglichkeiten vor, das Options-Pattern zu verwenden:

1. Singleton-Optionen

Standardmäßig bietet IOptions<t> eine Singleton-Instanz. Tim demonstriert, dass, wenn die Konfigurationsdatei aktualisiert wird, während die Anwendung läuft, die Änderungen nicht übernommen werden, bis die Anwendung neu gestartet wird.

2. Scoped Options - Using IOptionsSnapshot<t>

Um Aktualisierungen pro Anfrage zu ermöglichen, ändert Tim die Injektion in:

@inject IOptionsSnapshot<CloudInfoOptions> CloudInfoOptions

@inject IOptionsSnapshot<CloudInfoOptions> CloudInfoOptions

Dadurch wird sichergestellt, dass jede neue HTTP-Anfrage neue Konfigurationswerte erhält. Tim testet dies, indem er appsettings.json modifiziert, die Seite aktualisiert und zeigt, dass die aktualisierten Werte jetzt sofort erscheinen.

Er erklärt, dass IOptionsSnapshot<t> nützlich ist für Szenarien, in denen Änderungen widergespiegelt werden müssen, ohne die App neu zu starten, aber keine Live-Überwachung erforderlich ist.

3. Monitoring Changes - Using IOptionsMonitor<t>

Schließlich führt Tim IOptionsMonitor<t> ein, das Echtzeit-Änderungserkennung ermöglicht. Er aktualisiert die Injektion auf:

@inject IOptionsMonitor<CloudInfoOptions> CloudInfoOptions

@inject IOptionsMonitor<CloudInfoOptions> CloudInfoOptions

Im Gegensatz zu IOptionsSnapshot, das pro Anfrage aktualisiert wird, kann IOptionsMonitor<t> Ereignisse auslösen, wenn sich Konfigurationswerte ändern. Dies ist besonders nützlich, wenn Sie dynamisch auf Konfigurationsänderungen reagieren müssen.

Tim bemerkt, dass IOptionsMonitor<t> von einem Singletonunterstützt wird, aber Werte dynamisch aktualisieren kann, wenn sich die zugrunde liegende Konfigurationsdatei ändert.

Abschluss

Tim fasst zum Abschluss des Videos die wichtigsten Unterschiede zwischen den drei Ansätzen zusammen:

Er betont, dass das Options-Pattern zwar das Konfigurationsmanagement vereinfacht, das Verständnis dieser verschiedenen Varianten jedoch bei der Auswahl des richtigen Ansatzes auf der Grundlage der Projektanforderungen hilft.

Durch die Befolgung von Tims Ansatz können Entwickler Effiziente Anwendungseinstellungen verwalten, eine reibungslose Injektion von Abhängigkeiten sicherstellen und Änderungen der Laufzeitkonfiguration effektiv handhaben. Zum besseren Verständnis sehen Sie sich bitte das komplette Video an und besuchen Sie seinen Kanal für weitere aufschlussreiche Videos zu C#.