Configuration de l’application

Conseil / Astuce

Ce contenu est un extrait du livre électronique, Blazor pour les développeurs ASP NET Web Forms pour Azure, disponible sur .NET Docs ou en tant que PDF téléchargeable gratuitement qui peut être lu hors connexion.

Télécharger le PDF

La principale façon de charger la configuration d’application dans Web Forms est d’utiliser des entrées dans le fichier web.config , soit sur le serveur, soit sur un fichier de configuration associé référencé par web.config. Vous pouvez utiliser l’objet statique ConfigurationManager pour interagir avec les paramètres de l’application, les chaînes de connexion du référentiel de données et d’autres fournisseurs de configuration étendus qui sont ajoutés à l’application. Il est courant de voir les interactions avec la configuration d’application comme indiqué dans le code suivant :

var configurationValue = ConfigurationManager.AppSettings["ConfigurationSettingName"];
var connectionString = ConfigurationManager.ConnectionStrings["MyDatabaseConnectionName"].ConnectionString;

Avec ASP.NET Core et côté Blazorserveur, le fichier web.config PEUT être présent si votre application est hébergée sur un serveur Windows IIS. Toutefois, il n’existe aucune ConfigurationManager interaction avec cette configuration et vous pouvez recevoir une configuration d’application plus structurée à partir d’autres sources. Examinons comment la configuration est collectée et comment vous pouvez toujours accéder aux informations de configuration à partir d’un fichier web.config .

Sources de configuration

ASP.NET Core reconnaît qu’il existe de nombreuses sources de configuration que vous pouvez utiliser pour votre application. L’infrastructure tente de vous offrir le meilleur de ces fonctionnalités par défaut. La configuration est lue et agrégée à partir de ces différentes sources par ASP.NET Core. Les valeurs chargées ultérieurement pour la même clé de configuration sont prioritaires sur les valeurs antérieures.

ASP.NET Core a été conçu pour prendre en charge le cloud et faciliter la configuration des applications pour les opérateurs et les développeurs. ASP.NET Core prend en compte l’environnement et sait s’il est en cours d’exécution dans votre Production ou Development environnement. L’indicateur d’environnement est défini dans la variable d’environnement ASPNETCORE_ENVIRONMENT système. Si aucune valeur n’est configurée, l’application s’exécute par défaut dans l’environnement Production .

Votre application peut déclencher et ajouter une configuration à partir de plusieurs sources en fonction du nom de l’environnement. Par défaut, la configuration est chargée à partir des ressources suivantes dans l’ordre indiqué :

1. fichierappsettings.json , le cas échéant
2. Fichier appsettings.{ENVIRONMENT_NAME}.json, s’il existe
3. Fichier de secrets utilisateur sur le disque, s’il est présent
4. Variables d'environnement
5. Arguments de ligne de commande

Format du fichier appsettings.json et accès à celui-ci

Le fichier appsettings.json peut être hiérarchique avec des valeurs structurées comme le json suivant :

{
  "section0": {
    "key0": "value",
    "key1": "value"
  },
  "section1": {
    "key0": "value",
    "key1": "value"
  }
}

Lorsqu’il est présenté avec le modèle JSON précédent, le système de configuration aplatit les valeurs enfants et référence leurs chemins hiérarchiques complets. Un caractère deux-points (:) sépare chaque propriété de la hiérarchie. Par exemple, la clé de configuration section1:key0 accède à la valeur section1 de l'objet littéral key0.

Secrets utilisateur

Les secrets utilisateur sont les suivants :

• Valeurs de configuration stockées dans un fichier JSON sur la station de travail du développeur, en dehors du dossier de développement d’application.
• Chargé uniquement lors de l’exécution dans l’environnement Development.
• Associé à une application spécifique.
• Géré avec la commande user-secrets de l’interface .NET CLI.

Configurez votre application pour le stockage des secrets en exécutant la user-secrets commande :

dotnet user-secrets init

La commande précédente ajoute un UserSecretsId élément au fichier projet. L’élément contient un GUID, utilisé pour associer des secrets à l’application. Vous pouvez ensuite définir un secret avec la set commande. Par exemple:

dotnet user-secrets set "Parent:ApiKey" "12345"

La commande précédente rend la clé de configuration disponible sur la Parent:ApiKey station de travail d’un développeur avec la valeur 12345.

Pour plus d’informations sur la création, le stockage et la gestion des secrets utilisateur, consultez le document Stockage sécurisé des secrets d’application pendant le développement dans ASP.NET Core.

Variables d'environnement

L’ensemble suivant de valeurs chargées dans la configuration de votre application est les variables d’environnement du système. Tous les paramètres de variable d’environnement de votre système sont désormais accessibles via l’API de configuration. Les valeurs hiérarchiques sont aplaties et séparées par un caractère deux-points lors de la lecture depuis votre application. Toutefois, certains systèmes d’exploitation n’autorisent pas les noms de variables d’environnement contenant le caractère deux-points. ASP.NET Core résout cette limitation en convertissant les valeurs qui ont des traits de soulignement doubles (__) en deux-points lorsqu’elles sont accessibles. La Parent:ApiKey valeur de la section secrets utilisateur ci-dessus peut être remplacée par la variable Parent__ApiKeyd’environnement.

Arguments de ligne de commande

La configuration peut également être fournie en tant qu’arguments de ligne de commande lorsque votre application est démarrée. Utilisez la notation de double tiret (--) ou de barre oblique (/) pour indiquer le nom de la valeur de configuration à définir et la valeur à configurer. La syntaxe ressemble aux commandes suivantes :

dotnet run CommandLineKey1=value1 --CommandLineKey2=value2 /CommandLineKey3=value3
dotnet run --CommandLineKey1 value1 /CommandLineKey2 value2
dotnet run Parent:ApiKey=67890

Retour de web.config

Si vous avez déployé votre application sur Windows sur IIS, le fichier web.config configure toujours IIS pour gérer votre application. Par défaut, IIS ajoute une référence au module ASP.NET Core (ANCM). ANCM est un module IIS natif qui héberge votre application à la place du serveur web Kestrel. Cette section web.config ressemble au balisage XML suivant :

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <location path="." inheritInChildApplications="false">
    <system.webServer>
      <handlers>
        <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified" />
      </handlers>
      <aspNetCore processPath=".\MyApp.exe"
                  stdoutLogEnabled="false"
                  stdoutLogFile=".\logs\stdout"
                  hostingModel="inprocess" />
    </system.webServer>
  </location>
</configuration>

La configuration spécifique à l’application peut être définie en imbrication d’un environmentVariables élément dans l’élément aspNetCore . Les valeurs définies dans cette section sont présentées à l’application ASP.NET Core en tant que variables d’environnement. Les variables d’environnement se chargent correctement pendant ce segment de démarrage de l’application.

<aspNetCore processPath="dotnet"
      arguments=".\MyApp.dll"
      stdoutLogEnabled="false"
      stdoutLogFile=".\logs\stdout"
      hostingModel="inprocess">
  <environmentVariables>
    <environmentVariable name="ASPNETCORE_ENVIRONMENT" value="Development" />
    <environmentVariable name="Parent:ApiKey" value="67890" />
  </environmentVariables>
</aspNetCore>

Lire la configuration dans l’application

ASP.NET Core fournit une configuration d’application via l’interface IConfiguration . Cette interface de configuration doit être demandée par vos Blazor composants, Blazor pages et toute autre classe gérée par core ASP.NET qui a besoin d’accéder à la configuration. L’infrastructure ASP.NET Core remplit automatiquement cette interface avec la configuration résolue configurée précédemment. Sur une page ou dans le balisage Razor d'un composant Blazor, vous pouvez injecter l'objet IConfiguration avec une directive @inject au début du fichier .razor comme suit :

@inject IConfiguration Configuration

Cette instruction précédente rend l’objet IConfiguration disponible en tant que Configuration variable tout au long du reste du modèle Razor.

Les paramètres de configuration individuels peuvent être lus en spécifiant la hiérarchie des paramètres de configuration recherchée en tant que paramètre d’indexeur :

var mySetting = Configuration["section1:key0"];

Vous pouvez extraire des sections de configuration entières en utilisant la méthode GetSection pour récupérer une collection de clés à un emplacement spécifique, avec une syntaxe similaire à GetSection("section1") pour récupérer la configuration de la section1 de l'exemple précédent.

Configuration fortement typée

Avec Web Forms, il était possible de créer un type de configuration fortement typé hérité du ConfigurationSection type et des types associés. Un type ConfigurationSection vous permettait de configurer certaines règles de gestion et le traitement de ces valeurs de configuration.

Dans ASP.NET Core, vous pouvez spécifier une hiérarchie de classes qui recevra les valeurs de configuration. Ces classes :

• Il n'est pas nécessaire d'hériter d'une classe parente.
• Doit inclure des public propriétés qui correspondent aux propriétés et références de type de la structure de configuration que vous souhaitez capturer.

Pour l’exemple deappsettings.json précédent, vous pouvez définir les classes suivantes pour capturer les valeurs :

public class MyConfig
{
    public MyConfigSection section0 { get; set;}

    public MyConfigSection section1 { get; set;}
}

public class MyConfigSection
{
    public string key0 { get; set; }

    public string key1 { get; set; }
}

Cette hiérarchie de classes peut être remplie en ajoutant la ligne suivante à la Startup.ConfigureServices méthode (ou emplacement approprié dans Program.cs à l’aide de la builder.Services propriété au lieu de services:

services.Configure<MyConfig>(Configuration);

Dans le reste de l'application, vous pouvez ajouter un paramètre d'entrée aux classes ou intégrer une directive @inject dans les modèles Razor de type IOptions<MyConfig> pour recevoir les paramètres de configuration à typage fort. La IOptions<MyConfig>.Value propriété génère la MyConfig valeur renseignée à partir des paramètres de configuration.

@inject IOptions<MyConfig> options
@code {
    var MyConfiguration = options.Value;
    var theSetting = MyConfiguration.section1.key0;
}

Vous trouverez plus d’informations sur la fonctionnalité des options dans le modèle d'options dans ASP.NET Core.

PrécédentSuivant