ASP.NET Core-Konfiguration für .NET Core-Konsolenanwendung

135

ASP.NET Core unterstützt ein neues Konfigurationssystem, wie hier dargestellt: https://docs.asp.net/en/latest/fundamentals/configuration.html

Wird dieses Modell auch in .NET Core-Konsolenanwendungen unterstützt?

Wenn nicht, was ist eine Alternative zum Vorgänger app.configund zum ConfigurationManagerModell?

kimsagro
quelle

Antworten:

76

Sie können dieses Code-Snippet verwenden. Es enthält Konfiguration und 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, und vergessen Sie nicht, in project.json hinzuzufügen

{
  "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"
    ]
  },
...
}
Aligin
quelle
12
Diese Antwort ist nicht ideal. Verwenden Sie Directory.GetCurrentDirectory()anstelle von AppContext.BaseDirectory. Der Hack sollte danach nicht mehr benötigt werden.
Matyas
1
Oder setzen Sie die Eigenschaft "In Ausgabeverzeichnis kopieren" in Visual Studio für die JSON-Dateien auf "Wenn neuer kopieren".
BuddhiP
Damit das Basisverzeichnis in Web, Console und Winforms funktioniert, können Sie diesen Ansatz verwenden. Stackoverflow.com/a/33675039/1818723
Pawel Cioch
Gary Woodfine beschrieb dies ausführlich in einem sehr guten Stil in diesem Beitrag: garywoodfine.com/configuration-api-net-core-console-application
Javad Norouzi
@javad Nur teilweise; Ich bin hier gelandet, weil ich den DI-Teil wollte, den er versprochen hat, aber ich habe ihn nicht gefunden. Er hat auch nicht gezeigt, wie mehrere Konfigurationsdateien verwendet werden, wie in diesem Beispiel.
Auspex
230

Für eine .NET Core 2.0-Konsolen-App habe ich Folgendes getan:

  1. Erstellen Sie eine neue Datei mit dem Namen appsettings.json im Stammverzeichnis des Projekts (der Dateiname kann beliebig sein).
  2. Fügen Sie dieser Datei meine spezifischen Einstellungen als json hinzu. Beispielsweise:
{
  "myKey1" :  "my test value 1", 
  "myKey2" :  "my test value 2", 
  "foo" :  "bar" 
}
  1. Konfigurieren Sie das Kopieren der Datei in das Ausgabeverzeichnis, wenn das Projekt erstellt wird (in VS -> Projektmappen- Explorer -> Rechtsklick auf Datei -> Wählen Sie 'Eigenschaften' -> Erweitert -> In Ausgabeverzeichnis kopieren -> Wählen Sie 'Immer kopieren').

  2. Installieren Sie das folgende Nuget-Paket in meinem Projekt:

    • Microsoft.Extensions.Configuration.Json
  3. Fügen Sie Program.cs (oder wo immer Main()es sich befindet) Folgendes hinzu :

    static void Main(string[] args)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json");
    
        var configuration = builder.Build();
    
        // rest of code...
    }
  4. Lesen Sie dann die Werte auf eine der folgenden Arten:

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

Weitere Informationen: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

Strahl
quelle
1
Wie ich bemerkt habe, verwendet Microsoft in den Beispielen nicht IConfigurationRoot, sondern IConfiguration.
Aligin
3
IConfigurationRootist weiterhin in .NET Core 2.0 verfügbar . Es erbt von, IConfigurationaber es wird als abgeleiteter Fall davon angesehen, der nicht häufig verwendet wird . Unabhängig davon wurde das Codebeispiel aktualisiert, um es nicht einzuschließen und Verwirrung zu vermeiden.
Ray
10
2 Anmerkungen: In Punkt 4 benötigen Sie nur Microsoft.Extensions.Configuration.Json ... Die anderen 2 sind standardmäßig enthalten. Zweitens: Wenn Sie einen Abschnitt in ein Objekt laden möchten, ist es hilfreich zu wissen: var options = new FooOptions (); ConfigurationBinder.Bind (configuration.GetSection ("foo"), Optionen); Sie benötigen Microsoft.Extensions.Options.ConfigurationExtensions
Yepeekai
1
öffentliche Klasse FooOptions {public string myKey1 {get; set;} public string myKey2 {get; set;}}
Yepeekai
2
Tools> NuGet Package Manager> Package Manager-Konsole .. .. Installationspaket Microsoft.Extensions.Configuration .. Installationspaket Microsoft.Extensions.Configuration.FileExtensions ..
Installationspaket
19

Wenn Sie Microsoft.Extensions.Hosting(Konsole 2.1.0+) zum Hosten Ihrer Konsolen-App und der asp.net-Kern-App verwenden, werden alle Ihre Konfigurationen mit HostBuilder's ConfigureAppConfigurationund ConfigureHostConfigurationMethoden versehen. Hier ist die Demo zum Hinzufügen der appsettings.jsonVariablen und um:

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

Um den obigen Code zu kompilieren, müssen Sie folgende Pakete hinzufügen:

<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" />
Feiyu Zhou
quelle
Wie wird die Umgebung bestimmt? Wenn ich ein Profil in launchSettings erstelle, wird es tatsächlich festgelegt, ASPNETCORE_ENVIRONMENTaber dann context.HostingEnvironment.EnvironmentNamenicht richtig festgelegt
Sinaesthetic
Sie sollten die Umgebung als Schlüssel verwenden. Überprüfen Sie diesen Code: github.com/aspnet/Hosting/blob/dev/src/…
Feiyu Zhou
@FeiyuZhou, das ist ein toter Link
Auspex
Ist nicht alle diese Lösung nach new HostBuilder()redundant? Macht das nicht HostBuilderalles intern?
Auspex
@Auspex Es hängt davon ab, wie Sie Ihre Konsolen-App definieren. Wenn Sie benutzerdefinierte Konfigurationen definieren müssen, sollten Sie dies so einstellen. Hier ist das Dokument für Dotnet Core 3.0: docs.microsoft.com/en-us/aspnet/core/fundamentals/host/…
Feiyu Zhou
10

Ich lag falsch. Sie können das Neue ConfigurationBuilderaus einer Netcore-Konsolenanwendung verwenden.

Ein Beispiel finden Sie unter https://docs.asp.net/en/latest/fundamentals/configuration.html .

Allerdings verfügt nur der Aspnet-Core über eine sofort einsatzbereite Abhängigkeitsinjektion, sodass Sie nicht in der Lage sind, stark typisierte Konfigurationseinstellungen zu verwenden und diese automatisch mit zu injizieren IOptions.

kimsagro
quelle
9
Diese Antwort ist gültig, sollte aber den erforderlichen Code enthalten, also keine Gegenstimme.
Matyas
4
Alles was Sie brauchen, ist Paket hinzuzufügen: Microsoft.Extensions.Optionsund anrufenservice.AddOptions();
Bruno Garcia
2
Die gesamte (sehr lange) verlinkte Seite scheint ASP.NET-bezogen zu sein, wobei in jedem Beispiel "WebHost" erwähnt wird. Ich kam zu dieser SO-Frage, nachdem ich die verlinkte Seite gefunden und gedacht hatte "OK, das ist ASP.NET, was ist mit Konsolen-Apps".
Mackenir
Das ist ein bisschen seltsam, @mackenir, denn in 3.0 wurde alles überarbeitet, so dass alles nur Host ist! Der einzige Verweis auf WebHost selbst besteht darin, Sie auf die 2.2-Dokumentation zu verweisen. Es hätte etwas klarer sein können, dass die ConfigureWebHostDefaults()Aufrufe in den Beispielen optional sind und nur für Web-Apps.
Auspex
4

Für eine Dotnet 2.x-Kernkonsolenanwendung ist dies ungefähr so:

        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();

Das könnten Sie ILoggerFactory, IConfiguration in die injizieren SomeService.

lnaie
quelle
2

In .Net Core 3.1 müssen wir nur Folgendes tun:

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

Die Verwendung von SeriLog sieht folgendermaßen aus:

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();
            }
        }
    }
}

Der Abschnitt Serilog appsetings.json zum täglichen Generieren einer Datei sieht folgendermaßen aus:

  "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"
        }
      }
    ]
  }
Ernest
quelle
Nachdem Sie all diese Syntax aus dem gesamten Web ausprobiert haben, hat Ihre Syntax für mich funktioniert, und sie ist so einfach.
GaneshT
Ich bin froh, dass es dir geholfen hat.
Ernest
1

Sie können dafür die LiteWare.Configuration- Bibliothek verwenden. Es ist dem Original von .NET Framework sehr ähnlich ConfigurationManagerund funktioniert für .NET Core / Standard. In Bezug auf den Code erhalten Sie am Ende Folgendes:

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

Haftungsausschluss: Ich bin der Autor von LiteWare.Configuration.

Hisham Maudarbocus
quelle
0

Einfach aufstapeln ... ähnlich wie bei Feiyu Zhous Post. Hier füge ich den Maschinennamen hinzu.

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>();
  }
bvj
quelle
0

Installieren Sie diese Pakete:

  • 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();
    }

MySettingsConfig Klasse:

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

Ihre Apps können so einfach sein: Geben Sie hier die Bildbeschreibung ein

Stellen Sie außerdem die Appsettings-Dateien auf Content / Copy ein, falls neu: Inhalt

alansiqueira27
quelle