Comprendre l'Enum Set Flag du C# : Attribution de drapeaux

Tim Corey

10m 39s

La gestion de la configuration est un aspect essentiel de la création d'applications évolutives et faciles à maintenir en C#. L'une des façons les plus efficaces de gérer les paramètres de configuration est d'utiliser le Options Pattern. Dans sa vidéo, The Options Pattern in C# in 10 Minutes or Less, Tim Corey fournit une explication concise mais perspicace de ce modèle et de la manière de le mettre en œuvre efficacement. Dans cet article, nous allons explorer le modèle des options à travers les explications et les démonstrations de Tim dans sa vidéo.

Introduction

Tim commence par présenter le Options Pattern comme un moyen puissant mais simple de récupérer des informations dans les fichiers de configuration et de les injecter dans l'injection de dépendances (DI). Il souligne plusieurs avantages de ce modèle, tels que :

• La capacité à gérer les changements de valeur au moment de l'exécution.
• Prise en charge intégrée de la validation des données.
• Compatibilité avec divers types de projets C#, y compris les applications Blazor.

Tim insiste sur le fait que, bien qu'il fournisse habituellement une formation technique approfondie, cette vidéo est conçue comme un guide de démarrage rapide pour la mise en œuvre du modèle d'options.

Configuration du projet

Tim commence par ouvrir Visual Studio avec une application Web Blazor (rendu côté serveur uniquement). Il a déjà apporté quelques modifications pour accélérer la démonstration. La configuration clé implique :

• Création d'un fichier appsettings.json avec une section CloudInfo contenant trois paires clé-valeur.
• Utilisation d'un modèle POCO (Plain Old CLR Object) appelé CloudInfoOptions, qui correspond à ces valeurs de configuration.

Le fichier de configuration

Le fichier appsettings.json contient la section suivante :

{
  "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 précise que bien qu'il utilise appsettings.json, les valeurs de configuration pourraient aussi provenir de :

• appsettings.Development.json
• secrets.json
• Variables d'environnement

Lier la configuration aux options

Maintenant, Tim explique comment lier les valeurs de configuration à la classe CloudInfoOptions et les injecter dans DI.

Enregistrement des options dans Program.cs

Dans Program.cs, Tim ajoute la ligne suivante à l'intérieur de builder.Services :

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"))

Ceci lie la section CloudInfo de appsettings.json à la classe CloudInfoOptions. Tim note que cette étape permet de s'assurer que les valeurs sont disponibles dans l'injection de dépendances.

Injecter des options dans un composant Razor

Tim passe au composant Page d'accueil (Index.razor) et le modifie pour afficher dynamiquement les valeurs de configuration.

Il injecte l'interface IOptions dans le composant :

@inject IOptions<CloudInfoOptions> CloudInfoOptions

@inject IOptions<CloudInfoOptions> CloudInfoOptions

Pour récupérer les valeurs réelles, il les assigne à l'intérieur de OnInitialized :

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 explique que IOptions<t> fournit une instance Singleton des valeurs de configuration, ce qui signifie qu'elle reste constante pendant tout le cycle de vie de l'application. Lorsque l'application s'exécute, les valeurs de configuration apparaissent correctement sur la page.

Explorer différentes interfaces d'options

Tim présente ensuite trois façons différentes d'utiliser le modèle d'options :

1. Options Singleton

Par défaut, IOptions<t> fournit une instance Singleton. Tim démontre que si le fichier de configuration est mis à jour alors que l'application est en cours d'exécution, les modifications ne se reflètent que si l'application est redémarrée.

2. Options à portée - Utilisation de IOptionsSnapshot<t>

Pour permettre les mises à jour à la demande, Tim modifie l'injection en :

@inject IOptionsSnapshot<CloudInfoOptions> CloudInfoOptions

@inject IOptionsSnapshot<CloudInfoOptions> CloudInfoOptions

Cela permet de s'assurer que chaque nouvelle requête HTTP reçoit de nouvelles valeurs de configuration. Tim teste cela en modifiant appsettings.json, actualisant la page, et montrant que les valeurs mises à jour apparaissent immédiatement.

Il explique que IOptionsSnapshot<t> est utile pour des scénarios où les changements doivent être reflétés sans redémarrer l'application mais ne nécessitent pas de surveillance en direct.

3. Surveillance des changements - Utilisation de IOptionsMonitor<t>

Enfin, Tim introduit IOptionsMonitor<t>, qui permet une détection des changements en temps réel. Il met à jour l'injection pour :

@inject IOptionsMonitor<CloudInfoOptions> CloudInfoOptions

@inject IOptionsMonitor<CloudInfoOptions> CloudInfoOptions

Contrairement à IOptionsSnapshot, qui met à jour par requête, IOptionsMonitor<t> peut déclencher des événements lorsque les valeurs de configuration changent. Ces outils sont particulièrement utiles lorsqu'il s'agit de réagir de manière dynamique à des changements de configuration.

Tim note que IOptionsMonitor<t> est soutenu par un singleton mais peut actualiser les valeurs dynamiquement lorsque le fichier de configuration sous-jacent change.

Conclusion

Tim conclut la vidéo en résumant les principales différences entre les trois approches :

Il souligne que si le modèle des options simplifie la gestion de la configuration, la compréhension de ces différentes variantes permet de choisir la bonne approche en fonction des exigences du projet.

En suivant l'approche de Tim, les développeurs peuvent gérer efficacement les paramètres de l'application, assurer une injection de dépendances sans heurts et gérer efficacement les changements de configuration au cours de l'exécution. Pour une meilleure compréhension, veuillez regarder l'intégralité de la vidéo et visitez son canal pour d'autres vidéos perspicaces sur C#.