Accéder aux paramètres pendant la configuration dans ASP.NET Core / .NET 8

Pourquoi un accès anticipé à la configuration compte

Tim Corey commence par souligner l'importance des paramètres de l'application dans ASP.NET Core. Selon Tim, appsettings.json est un " excellent endroit pour stocker la configuration " car il permet aux développeurs de changer des valeurs sans recompiler ou redéployer des applications.

Dans le développement web, il est courant de se fier à la configuration pour les services, comme définir des URLs pour les API ou ajuster des paramètres spécifiques à l'environnement. Normalement, dans une application web .NET Core, les développeurs accèdent à la configuration via l'injection de dépendances :

@inject IConfiguration config

Cependant, Tim souligne que parfois vous avez besoin d'accéder à ces valeurs de configuration pendant la configuration, par exemple, lors de la configuration des clients HTTP ou d'autres services dans program.cs. Le faire garantit que vos applications restent souples et adaptables lorsqu'elles passent entre différents environnements comme développement, préproduction ou production.

Configurer une application Blazor minimale

Pour démontrer, Tim crée une application Blazor simple, désactivant l'interactivité pour se concentrer entièrement sur program.cs. Il souligne que l'architecture d'ASP.NET Core permet de séparer la configuration du code, ce qui facilite la gestion des applications web et des projets cloud natifs.

Cette approche s'aligne également avec la nature multiplateforme de .NET, car la même logique de configuration fonctionne sous Windows, Linux et macOS sans modification.

Configurer un client HTTP à l'aide des paramètres de l'application

Tim nous guide à travers un scénario où un client HTTP est enregistré dans program.cs :

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

Bien que cela fonctionne, Tim explique que coder en dur l'URL n'est pas idéal. Si le point de terminaison de l'API change, les développeurs doivent mettre à jour le code et créer une demande de validation pour le déploiement. Au lieu de cela, il recommande de stocker la valeur dans appsettings.json :

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

Cela garantit que le framework extrait la configuration de manière dynamique, évitant la recompilation et réduisant les erreurs lors du déploiement. Cela s'aligne également avec les meilleures pratiques pour des applications web sécurisées et maintenables.

Accéder à la configuration dans Program.cs

Tim démontre comment extraire les valeurs de configuration avant l'injection de dépendances :

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

Points clés soulignés par Tim :

• builder.Configuration est disponible avant builder.Build().

• Les valeurs peuvent provenir d'appsettings.json, de variables d'environnement, de secrets utilisateur, ou même d'Azure Key Vault.

• Cela vous permet de configurer des services, d'enregistrer des logs ou d'autres composants de framework web de manière dynamique.

Tim place un point d'arrêt pour vérifier que l'URL de l'API locale est correctement récupérée. Il note que cette méthode fonctionne sur toutes les plateformes prises en charge, ce qui la rend idéale pour le développement multiplateforme.

Gestion des configurations manquantes

Tim aborde les scénarios où une clé de configuration pourrait être manquante ou nulle. Il montre que vous pouvez fournir une valeur par défaut en utilisant GetValue:

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

Cela garantit que vos applications sont prêtes à être exécutées même si la configuration n'est pas définie, améliorant ainsi la gestion des erreurs et la productivité des développeurs. Cela réduit également la probabilité de problèmes d'exécution dans les déploiements sur le cloud ou sur différentes plateformes.

Avantages d'un accès anticipé aux configurations

Tim présente plusieurs avantages à tirer parti des configurations lors de l'installation :

1. Configuration dynamique : des services comme HttpClient peuvent utiliser des points de terminaison spécifiques à l'environnement.

2. Évitage de la recompilation : le changement d'URLs ou d'autres paramètres ne nécessite plus de modifications de code.

3. Enregistrement flexible et services : configurez les enregistreurs ou d'autres services de framework web en utilisant des valeurs de configuration.

4. Prise en charge de multiples sources : la configuration peut provenir de appsettings.json, de variables d'environnement, de secrets d'utilisateur ou de coffres de clés dans le cloud.

Il insiste sur le fait que cette approche garde les applications légères et faciles à maintenir tout en profitant pleinement du framework ASP.NET Core et de la plateforme .NET.

Exécution et test de l'application (6:03–7:36)

Tim démontre le nettoyage du code et l'exécution de l'application. Il montre que l'URL de l'API locale est soit extraite de la configuration soit qu'elle tombe par défaut :

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

Cette configuration flexible permet aux développeurs de continuer à créer des applications web sans se soucier des URLs codées en dur ou des pull requests répétées pour de petits changements. Elle garantit également que les déploiements multiplateformes sur Linux, Windows ou macOS se déroulent sans heurts.

Conclusion

Tim Corey conclut en soulignant la simplicité et l'efficacité d'accéder aux configurations lors de l'installation dans ASP.NET Core / .NET 8. En utilisant :

builder.Configuration.GetValue()

les développeurs peuvent :

• Configurer les services de manière dynamique

• Éviter de coder en dur des valeurs dans le framework

• Supporter de multiples environnements et plateformes

• Améliorer la productivité des développeurs et la gestion des erreurs

Cette technique est essentielle pour créer des applications web sécurisées, maintenables et prêtes pour le cloud. La démonstration pratique de Tim met en avant comment une application ASP.NET Core légère et multiplateforme peut être robuste, flexible et prête pour le développement web moderne.

La vidéo de Tim Corey est à ne pas manquer pour les développeurs souhaitant maîtriser la gestion des configurations dans ASP.NET Core. En suivant ses étapes, vous pouvez vous assurer que vos applications sont flexibles, maintenables et prêtes pour le déploiement multiplateforme, les environnements de cloud, et l'architecture web moderne.