asp.net-core
Configuration

Introduction

Syntaxe

• IConfiguration
• string this[string key] { get; set; }
• IEnumerable<IConfigurationSection> GetChildren();
• IConfigurationSection GetSection(string key);

Accès à la configuration en utilisant l'injection de dépendance

L'approche recommandée serait d'éviter de le faire et d'utiliser plutôt IOptions<TOptions> et IServiceCollection.Configure<TOptions> .

Cela dit, cela reste assez simple pour rendre IConfigurationRoot disponible à l’échelle des applications.

Dans le constructeur Startup.cs, vous devez avoir le code suivant pour générer la configuration,

 Configuration = builder.Build();

Ici, la Configuration est une instance de IConfigurationRoot , et ajoute cette instance en tant que Singleton à la collection de services dans la méthode ConfigureServices, Startup.cs,

 public void ConfigureServices(IServiceCollection services)
 {
    services.AddSingleton<IConfigurationRoot>(provider => Configuration);

Par exemple, vous pouvez maintenant accéder à la configuration dans un contrôleur / service

  public MyController(IConfigurationRoot config){
      var setting1= config.GetValue<string>("Setting1")
  }

Commencer

Dans cet exemple, nous allons décrire ce qui se passe lorsque vous échafaudez un nouveau projet.

Tout d'abord, les dépendances suivantes seront ajoutées à votre projet (actuellement fichier project.json ):

"Microsoft.Extensions.Configuration.EnvironmentVariables": "1.0.0",
"Microsoft.Extensions.Configuration.Json": "1.0.0",

Il va également créer un constructeur dans votre fichier Startup.cs qui sera chargé de construire la configuration à l'aide d'Api ConfigurationBuilder fluent:

1. Il commence par créer un nouveau ConfigurationBuilder .
2. Il définit ensuite un chemin de base qui sera utilisé pour calculer le chemin absolu des autres fichiers
3. Il ajoute un appsettings.json facultatif au constructeur de configuration et surveille ses modifications
4. Il ajoute un fichier de configuration appsettings.environementName.json lié à l'environnement facultatif
5. Il ajoute ensuite des variables d'environnement.

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
        .AddEnvironmentVariables();

    Configuration = builder.Build();
}

Si un même paramètre est défini dans plusieurs sources, la dernière source ajoutée gagnera et sa valeur sera sélectionnée.

La configuration peut ensuite être consommée à l'aide de la propriété de l'indexeur. Les deux points : caractère servent un délimiteur de chemin.

Configuration["AzureLogger:ConnectionString"]

Cela recherchera une valeur de configuration ConnectionString dans une section AzureLogger .

Travailler avec des variables d'environnement

Vous pouvez .AddEnvironmentVariables() configuration à partir des variables d'environnement en appelant .AddEnvironmentVariables() sur ConfigurationBuilder .

Il chargera les variables d'environnement préfixées par APPSETTING_ Il utilisera alors deux points : comme séparateur de chemin de clé.

Cela signifie que: les paramètres d'environnement suivants:

APPSETTING_Security:Authentication:UserName = a_user_name
APPSETTING_Security:Authentication:Password = a_user_password

Sera l'équivalent de ce json:

{
    "Security" : {
       "Authentication" : {
           "UserName" : "a_user_name",
           "Password" : "a_user_password" 
        } 
    }
}

** Notez que Azure Service transmettra les paramètres en tant que variables d'environnement. Le préfixe sera défini pour vous de manière transparente. Donc, pour faire la même chose dans Azure, il suffit de définir deux paramètres d'application dans la lame AppSettings:

Security:Authentication:UserName         a_user_name
Security:Authentication:Password         a_user_password

Modèle d'option et configuration

Lorsque vous traitez de grands ensembles de valeurs de configuration, il peut être difficile de les charger en un seul.

Modèle d'option qui vient avec asp.net offre un moyen pratique pour mapper une section à une dotnet poco : Par exemple, on peut hydrater StorageOptions directement à partir d' une section de configuration b ajoutant Microsoft.Extensions.Options.ConfigurationExtensions package et en appelant le Configure<TOptions>(IConfiguration config) méthode d'extension.

services.Configure<StorageOptions>(Configuration.GetSection("Storage"));

Source de configuration en mémoire

Vous pouvez également créer une configuration à partir d'un objet en mémoire tel qu'un Dictionary<string,string>

.AddInMemoryCollection(new Dictionary<string, string>
{
    ["akey"] = "a value"
})

Cela peut s'avérer utile dans les scénarios de test d'intégration / d'unité.