ASP.NET configuration de Base .NET de Base l'application de la console

Question

ASP.NET de soutien de Base d'un nouveau système de configuration comme on le voit ici: https://docs.asp.net/en/latest/fundamentals/configuration.html

Est-ce modèle a également pris en charge .NET de Base les applications de console?

Si non quelle est l'alternative à la précédente app.config et ConfigurationManager modèle?

Answer 1

Pour un .NET Core 2.0 application console, je n'ai suivantes:

1. Créez un nouveau fichier nommé appsettings.json à la racine du projet (le nom de fichier peut être n'importe quoi)
2. Ajouter mon paramètres spécifiques à ce fichier 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 (VS -> Explorateur de solutions -> cliquez-droit sur le fichier -> sélectionnez "Propriétés" - > Avancé -> Copier vers le Répertoire de Sortie -> sélectionnez "Copier")

4. Installer les package nuget dans mon projet:

   • Microsoft.Extensions.La Configuration.Json

5. Ajoutez ce qui suit au Programme.cs (ou partout où Main() se trouve):

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

6. Ensuite, lire les valeurs à l'aide 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'infos: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

Answer 2

Vous pouvez utiliser ce bout de code. Il inclut la Configuration et de 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 projet.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"
    ]
  },
...
}

Answer 3

Si vous utilisez Microsoft.Extensions.Hosting (version 2.1.0+) pour héberger votre application console et asp.net core app, toutes vos configurations sont injectés avec HostBuilders' ConfigureAppConfiguration et ConfigureHostConfiguration méthodes. Voici la démo sur la façon d'ajouter l' appsettings.json et les variables 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 paquets:

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

Answer 4

Je me suis trompé. Vous pouvez utiliser le nouveau ConfigurationBuilder d'un netcore application console.

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

Toutefois, seul le réseau de base a l'injection de dépendance de la boîte de sorte que vous n'avez pas la possibilité d'avoir fortement typé paramètres de configuration automatiquement et de les injecter à l'aide de IOptions.