web-dev-qa-db-fra.com

Configuration ASP.NET Core pour application console .NET Core

ASP.NET Core prend en charge un nouveau système de configuration, comme indiqué ci-après: https://docs.asp.net/en/latest/fundamentals/configuration.html

Ce modèle est-il également pris en charge dans les applications de la console .NET Core?

Si non, qu'est-ce qui est alterné au modèle précédent app.config et ConfigurationManager?

c#.net-core
81
kimsagro

Vous pouvez utiliser cet extrait de code. Il comprend la configuration et DI.

public class Program
{
    public static ILoggerFactory LoggerFactory;
    public static IConfigurationRoot Configuration;

    public static void Main(string[] args)
    {
        Console.OutputEncoding = Encoding.UTF8;

        string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

        if (String.IsNullOrWhiteSpace(environment))
            throw new ArgumentNullException("Environment not found in ASPNETCORE_ENVIRONMENT");

        Console.WriteLine("Environment: {0}", environment);

        var services = new ServiceCollection();

        // Set up configuration sources.
        var builder = new ConfigurationBuilder()
            .SetBasePath(Path.Combine(AppContext.BaseDirectory))
            .AddJsonFile("appsettings.json", optional: true);
        if (environment == "Development")
        {

            builder
                .AddJsonFile(
                    Path.Combine(AppContext.BaseDirectory, string.Format("..{0}..{0}..{0}", Path.DirectorySeparatorChar), $"appsettings.{environment}.json"),
                    optional: true
                );
        }
        else
        {
            builder
                .AddJsonFile($"appsettings.{environment}.json", optional: false);
        }

        Configuration = builder.Build();

        LoggerFactory = new LoggerFactory()
            .AddConsole(Configuration.GetSection("Logging"))
            .AddDebug();

        services
            .AddEntityFrameworkNpgsql()
            .AddDbContext<FmDataContext>(o => o.UseNpgsql(connectionString), ServiceLifetime.Transient);

        services.AddTransient<IPackageFileService, PackageFileServiceImpl>();

        var serviceProvider = services.BuildServiceProvider();

        var packageFileService = serviceProvider.GetRequiredService<IPackageFileService>();

        ............
    }
}

Oh, et n'oubliez pas d'ajouter le fichier project.json

{
  "version": "1.0.0-*",
  "buildOptions": {
    "emitEntryPoint": true,
    "copyToOutput": {
      "includeFiles": [
        "appsettings.json",
        "appsettings.Integration.json",
        "appsettings.Production.json",
        "appsettings.Staging.json"
      ]
    }
  },

  "publishOptions": {
    "copyToOutput": [
      "appsettings.json",
      "appsettings.Integration.json",
      "appsettings.Production.json",
      "appsettings.Staging.json"
    ]
  },
...
}
55
aligin

Pour une application de console .NET Core 2.0, j'ai procédé comme suit:

  1. Créez un nouveau fichier nommé appsettings.json à la racine du projet (le nom du fichier peut être n'importe quoi) 
  2. Ajoutez mes paramètres spécifiques à ce fichier en tant que json. Par exemple:
{
  "myKey1" :  "my test value 1", 
  "myKey2" :  "my test value 2", 
  "foo" :  "bar" 
}

  1. Configurez pour copier le fichier dans le répertoire de sortie à chaque construction du projet (dans VS -> Explorateur de solutions -> fichier du clic droit -> sélectionnez "Propriétés" -> Avancé -> Copier dans le répertoire de sortie -> sélectionnez "Copier toujours ')

  2. Installez le package de nuget suivant dans mon projet:

    • Microsoft.Extensions.Configuration.Json

  3. Ajoutez ce qui suit à Program.cs (ou à l’endroit où se trouve Main()):

    static void Main(string[] args)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json");

    var configuration = builder.Build();

    // rest of code...
}

  4. Ensuite, lisez les valeurs en utilisant l’une des méthodes suivantes: 

    string myKey1 = configuration["myKey1"];
Console.WriteLine(myKey1);

string foo = configuration.GetSection("foo").Value;
Console.WriteLine(foo);

Plus d'infos: https://docs.Microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

127
Ray Vega

Je me trompais. Vous pouvez utiliser la nouvelle ConfigurationBuilder à partir d'une application de console netcore.

Voir https://docs.asp.net/fr/latest/fundamentals/configuration.html pour un exemple.

Cependant, seul le noyau aspnet a une injection de dépendance prête à l'emploi. Vous ne pouvez donc pas avoir de paramètres de configuration fortement typés ni les injecter automatiquement avec IOptions.

9
kimsagro

Si vous utilisez Microsoft.Extensions.Hosting (version 2.1.0+) pour héberger votre application console et votre application principale asp.net, toutes vos configurations sont injectées avec les méthodes HostBuilder's ConfigureAppConfiguration et ConfigureHostConfiguration. Voici la démonstration sur la façon d'ajouter les variables appsettings.json et d'environnement:

    var hostBuilder = new HostBuilder()
        .ConfigureHostConfiguration(config =>
        {
            config.AddEnvironmentVariables();

            if (args != null)
            {
                // enviroment from command line
                // e.g.: dotnet run --environment "Staging"
                config.AddCommandLine(args);
            }
        })
        .ConfigureAppConfiguration((context, builder) =>
        {
            var env = context.HostingEnvironment;
            builder.SetBasePath(AppContext.BaseDirectory)
            .AddJsonFile("appsettings.json", optional: false)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            // Override config by env, using like Logging:Level or Logging__Level
            .AddEnvironmentVariables();

        })
        ... // add others, logging, services
        //;

Afin de compiler le code ci-dessus, vous devez ajouter ces packages:

<PackageReference Include="Microsoft.Extensions.Configuration" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.1.0" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="2.1.0" />
9
Feiyu Zhou

Cela ressemble à ceci, pour une application de console centrale dotnet 2.x:

        using Microsoft.Extensions.Configuration;
        using Microsoft.Extensions.DependencyInjection;
        using Microsoft.Extensions.Logging;

        [...]
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddEnvironmentVariables()
            .Build();
        var serviceProvider = new ServiceCollection()
            .AddLogging(options => options.AddConfiguration(configuration).AddConsole())
            .AddSingleton<IConfiguration>(configuration)
            .AddSingleton<SomeService>()
            .BuildServiceProvider();
        [...]
        await serviceProvider.GetService<SomeService>().Start();

Vous pouvez injecter ILoggerFactory, IConfiguration dans SomeService.

0
lnaie
var directoryInfo = Directory.GetParent(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName).FullName;
            var builder = new ConfigurationBuilder()
                .SetBasePath(directoryInfo)
                .AddJsonFile("appsettings.json",  true, true)
                .Build();
0
Hakobyan Vanik