web-dev-qa-db-de.com

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

ASP.NET Core unterstützt ein neues Konfigurationssystem, wie hier zu sehen ist: https://docs.asp.net/de/latest/fundamentals/configuration.html

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

Wenn nicht, was ist eine Alternative zum vorherigen Modell app.config und ConfigurationManager?

81
kimsagro

Sie können dieses Code-Snippet verwenden. Es beinhaltet 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 einzufü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"
    ]
  },
...
}
55
aligin

Für eine .NET Core 2.0-Konsolenanwendung habe ich Folgendes ausgeführt:

  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 speziellen Einstellungen als Json hinzu. Zum Beispiel:
{
  "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 (klicken Sie in VS -> Projektmappen-Explorer -> Datei mit der rechten Maustaste -> 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 Folgendes zu Program.cs hinzu (oder wo sich Main() befindet):

    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

127
Ray Vega

Ich lag falsch. Sie können die neue ConfigurationBuilder von einer Netcore-Konsolenanwendung aus verwenden.

Siehe https://docs.asp.net/de/latest/fundamentals/configuration.html für ein Beispiel.

Nur der Aspnet-Core verfügt jedoch über eine Abhängigkeitseingabe, so dass Sie keine stark typisierten Konfigurationseinstellungen haben und diese automatisch mit IOptions einfügen können.

9
kimsagro

Wenn Sie Microsoft.Extensions.Hosting (Version 2.1.0+) zum Hosten Ihrer Konsolen-App und der asp.net core-App verwenden, werden alle Ihre Konfigurationen mit den HostBuilder-Methoden ConfigureAppConfiguration und ConfigureHostConfiguration injiziert. Hier ist die Demo zum Hinzufügen der appsettings.json- und Umgebungsvariablen:

    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" />
9
Feiyu Zhou

Für eine Dotnet 2.x-Kernkonsolenanwendung ist das 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();

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

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