InfluencesMag.org
Home

.net Core Get Configuration Value Console App

4 min read Jun 03, 2024
.net Core Get Configuration Value Console App

Obtenir des valeurs de configuration dans une application console .NET Core

Les applications console .NET Core peuvent être configurées en utilisant des fichiers de configuration, des variables d'environnement et des arguments de ligne de commande. Cela permet de personnaliser le comportement de l'application sans modifier le code source.

Configuration à partir d'un fichier JSON

La méthode la plus courante pour configurer une application console .NET Core est d'utiliser un fichier JSON. Par défaut, ce fichier est nommé appsettings.json et se trouve dans le répertoire racine du projet.

Voici un exemple de fichier appsettings.json :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "MySettings": {
    "ConnectionString": "Data Source=mydatabase.db;Initial Catalog=mydatabase;Integrated Security=True",
    "ApiUrl": "https://api.example.com"
  }
}

Pour accéder à ces valeurs dans le code, utilisez la classe IConfiguration :

using Microsoft.Extensions.Configuration;

class Program
{
  static void Main(string[] args)
  {
    // Charger la configuration
    var configuration = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
        .Build();

    // Accéder aux valeurs de configuration
    var connectionString = configuration.GetConnectionString("ConnectionString");
    var apiUrl = configuration.GetValue("MySettings:ApiUrl");

    Console.WriteLine($"ConnectionString: {connectionString}");
    Console.WriteLine($"ApiUrl: {apiUrl}");
  }
}

Configuration à partir de variables d'environnement

Les variables d'environnement sont des variables système qui sont disponibles pour toutes les applications. Elles peuvent être utilisées pour configurer des paramètres sensibles ou pour modifier le comportement de l'application en fonction de l'environnement d'exécution.

Pour charger des valeurs de configuration à partir de variables d'environnement, utilisez AddEnvironmentVariables() dans le builder de configuration :

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddEnvironmentVariables()
    .Build();

Par exemple, si vous définissez la variable d'environnement API_URL avec la valeur https://api.example.com, vous pouvez l'accéder dans le code avec :

var apiUrl = configuration.GetValue("API_URL");

Configuration à partir d'arguments de ligne de commande

Les arguments de ligne de commande sont des paramètres qui sont passés à l'application lors de son exécution. Ils peuvent être utilisés pour configurer des options spécifiques à une exécution.

Pour charger des valeurs de configuration à partir d'arguments de ligne de commande, utilisez AddCommandLine() dans le builder de configuration :

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddCommandLine(args)
    .Build();

Par exemple, si vous exécutez l'application avec dotnet run --connection-string "Data Source=mydatabase.db;..." vous pouvez accéder à la valeur connection-string avec :

var connectionString = configuration.GetValue("connection-string");

En résumé, la configuration d'une application console .NET Core est un processus simple et flexible qui utilise des fichiers JSON, des variables d'environnement et des arguments de ligne de commande pour permettre de personnaliser l'application.

Related Post

Featured Posts