Configuration ASP.NET Core pour l'application console .NET Core

ASP.NET Core prend en charge un nouveau système de configuration comme indiqué ici: 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?

Sinon, qu'est-ce qui est alternatif au précédent app.configet au ConfigurationManagermodèle?

Vous pouvez utiliser cet extrait de code. Il comprend la configuration et la 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 dans le 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"
    ]
  },
...
}

Pour une application console .NET Core 2.0, j'ai effectué les opérations suivantes:

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" 
}

3. Configurer pour copier le fichier dans le répertoire de sortie chaque fois que le projet est construit (dans VS -> Explorateur de solutions -> cliquez avec le bouton droit sur le fichier -> sélectionnez 'Propriétés' -> Avancé -> Copier dans le répertoire de sortie -> sélectionnez 'Copier toujours')

4. Installez le package nuget suivant dans mon projet:

   • Microsoft.Extensions.Configuration.Json

5. Ajoutez ce qui suit à Program.cs (ou à Main()son emplacement):

   static void Main(string[] args)
   {
       var builder = new ConfigurationBuilder()
           .SetBasePath(Directory.GetCurrentDirectory())
           .AddJsonFile("appsettings.json");
   
       var configuration = builder.Build();
   
       // rest of code...
   }

6. Ensuite, lisez les valeurs de l'une des manières suivantes:

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

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

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 HostBuilderdes méthodes ConfigureAppConfigurationet ConfigureHostConfiguration. Voici la démonstration sur la façon d'ajouter les appsettings.jsonvariables d'environnement et:

    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" />

Je me trompais. Vous pouvez utiliser le nouveau à ConfigurationBuilderpartir d'une application console netcore.

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

Cependant, seul aspnet core a une injection de dépendances prête à l'emploi, vous n'avez donc pas la possibilité d'avoir des paramètres de configuration fortement typés et de les injecter automatiquement à l'aide de IOptions.

C'est quelque chose comme ça, pour une application de console de base 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 le fichier SomeService.

Sur .Net Core 3.1, nous devons simplement faire ceci:

static void Main(string[] args)
{
  var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
}

L'utilisation de SeriLog ressemblera à:

using Microsoft.Extensions.Configuration;
using Serilog;
using System;


namespace yournamespace
{
    class Program
    {

        static void Main(string[] args)
        {
            var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
            Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(configuration).CreateLogger();

            try
            {
                Log.Information("Starting Program.");
            }
            catch (Exception ex)
            {
                Log.Fatal(ex, "Program terminated unexpectedly.");
                return;
            }
            finally
            {
                Log.CloseAndFlush();
            }
        }
    }
}

Et la section Serilog appsetings.json pour générer un fichier quotidiennement ressemblera à ceci:

  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "Using": [ "Serilog.Sinks.Console", "Serilog.Sinks.File" ],
    "WriteTo": [
      {
        "Name": "File",
        "Args": {
          "path": "C:\\Logs\\Program.json",
          "rollingInterval": "Day",
          "formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
        }
      }
    ]
  }

Vous pouvez utiliser la bibliothèque LiteWare.Configuration pour cela. Il est très similaire à .NET Framework original ConfigurationManageret fonctionne pour .NET Core / Standard. Au niveau du code, vous vous retrouverez avec quelque chose comme:

string cacheDirectory = ConfigurationManager.AppSettings.GetValue<string>("CacheDirectory");
ulong cacheFileSize = ConfigurationManager.AppSettings.GetValue<ulong>("CacheFileSize");

Avis de non-responsabilité: Je suis l'auteur de LiteWare.Configuration.

Je m'empile juste ... semblable au message de Feiyu Zhou. Ici, j'ajoute le nom de la machine.

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
          .ConfigureAppConfiguration((context, builder) =>
          {
            var env = context.HostingEnvironment;
            var hostname = Environment.MachineName;
            builder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
              .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
              .AddJsonFile($"appsettings.{hostname}.json", optional: true, reloadOnChange: true);
            builder.AddEnvironmentVariables();
            if (args != null)
            {
              builder.AddCommandLine(args);
            }
          })
        .UseStartup<Startup>();
  }

Installez ces packages:

• Microsoft.Extensions.Configuration
• Microsoft.Extensions.Configuration.Binder
• Microsoft.Extensions.Configuration.EnvironmentVariables
• Microsoft.Extensions.Configuration.FileExtensions
• Microsoft.Extensions.Configuration.Json

Code:

static void Main(string[] args)
    {
        var environmentName = Environment.GetEnvironmentVariable("ENVIRONMENT");
        Console.WriteLine("ENVIRONMENT: " + environmentName);

        var builder = new ConfigurationBuilder()
           .SetBasePath(Directory.GetCurrentDirectory())
           .AddJsonFile("appsettings.json", false)
           .AddJsonFile($"appsettings.{environmentName}.json", true)
           .AddEnvironmentVariables();

        IConfigurationRoot configuration = builder.Build();
        var mySettingsConfig = configuration.Get<MySettingsConfig>();

        Console.WriteLine("URL: " + mySettingsConfig.Url);
        Console.WriteLine("NAME: " + mySettingsConfig.Name);

        Console.ReadKey();
    }

Classe MySettingsConfig:

public class MySettingsConfig
{
    public string Url { get; set; }
    public string Name { get; set; }
}

Vos paramètres d'application peuvent être aussi simples que ceci:

En outre, définissez les fichiers de paramètres d'applications sur Contenu / Copie s'ils sont plus récents: