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

ASP.NET Core-Unterstützung, eine neue Konfiguration für das system, wie hier gezeigt:
https://docs.asp.net/en/latest/fundamentals/configuration.html

Ist dieses Modell auch unterstützt .NET-Core-console-Anwendungen?

Wenn nicht, was ist die Alternative zu den bisherigen app.config und ConfigurationManager Modell?

InformationsquelleAutor der Frage kimsagro | 2016-06-30

.net-core c#

Können Sie dieses code-snippet. Es enthält die 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, fügen Sie in das Projekt.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"
    ]
  },
...
}

InformationsquelleAutor der Antwort aligin

66

Für eine .NET-Core-2.0-Konsole app, ich habe die folgenden:
1. Erstellen Sie eine neue Datei mit dem Namen appsettings.json an der Wurzel des Projekts (der name der Datei kann alles sein)
2. Meine spezifischen Einstellungen, um die Datei als json. Zum Beispiel:
```
{
  "myKey1" :  "my test value 1", 
  "myKey2" :  "my test value 2", 
  "foo" :  "bar" 
}
```
1. Konfigurieren Sie die Datei kopieren um die Ausgabe-Verzeichnis, wenn das Projekt gebaut wird (in VS -> Lösung-Explorer -> Rechtsklick auf Datei -> wählen Sie "Eigenschaften" - > Erweitert -> Copy to Output Directory (- > wählen Sie 'Kopieren')
2. Installieren Sie die folgenden nuget-Pakete in meinem Projekt:
  - Microsoft.Extensions.Konfiguration
  - Microsoft.Extensions.- Konfiguration.FileExtensions
  - Microsoft.Extensions.- Konfiguration.Json
3. Fügen Sie die folgenden Programm.cs (oder wo auch immer Main() liegt):
```
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 mit einer der folgenden Möglichkeiten:
```
string myKey1 = configuration["myKey1"];
Console.WriteLine(myKey1);

string foo = configuration.GetSection("foo").Value;
Console.WriteLine(foo);
```
Mehr info: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration?tabs=basicconfiguration#simple-configuration

InformationsquelleAutor der Antwort Ray Vega
9

Ich war Irre. Sie können die neue ConfigurationBuilder aus einer netcore-Konsole-Anwendung.

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

Jedoch nur aspnet-core dependency injection out of the box, so dass Sie don ' T haben die Fähigkeit, stark typisierte Konfiguration-Einstellungen automatisch injizieren Sie mit IOptions.

InformationsquelleAutor der Antwort kimsagro

Wenn Sie Microsoft.Extensions.Hosting (version 2.1.0+) für das Hosting Ihrer app und Konsole asp.net Kern-app, die alle Ihre Konfigurationen sind, injiziert mit HostBuilder's ConfigureAppConfiguration und ConfigureHostConfiguration Methoden. Hier ist die demo über, wie Sie die 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
        //;

Auszuwerten, um obigen code, Sie hinzufügen müssen, um diese Pakete:

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

InformationsquelleAutor der Antwort Feiyu Zhou

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.