.Net Core/Konsole Anwendung/Konfiguration/XML

Question

Meine erste kleine Venture in die .Net Core-Bibliotheken mit dem neuen ConfigurationBuilder und Optionen Muster.

gibt es jede Menge guter Beispiele hier: https://docs.asp.net/en/latest/fundamentals/configuration.html und eine gute Kopie des Beispiels here

Punkt 1. Es sagt, kann dies mit nicht MVC-Anwendungen verwendet werden, aber keine Beispiele dafür, wie es ohne MVC verwenden - vor allem wenn Sie eine benutzerdefinierte, stark typisierte Klasse verwenden. Ich möchte ein Beispiel sehen, das das Setup von DependencyInjection, Konfiguration und Protokollierung mit einer Konsolenanwendung zeigt.

Element 2. Es heißt, Sie können zurückschreiben, aber keine Beispiele oder Dokumentation, wie Sie Änderungen in den Dateispeicher übernehmen können. Ich würde gerne ein Beispiel sehen, wie Änderungen mit einer stark typisierten Klasse wieder in die Konfiguration übernommen werden. In JSON oder XML?

Punkt 3. alle Beispiele erfordern eine Hand ursprüngliche Datei bombardiert - möchten ein Beispiel sehen, wo die anfängliche json/xml-Datei von einer stark typisierte Klasse erstellt wird (ist praktisch, wenn es viele Parameter für die Anwendung).

Wenn ich genug Zeit damit verbringen kann (anstatt ein Beispiel bereits in der Dokumentation zu veröffentlichen), werde ich es tun! Wenn Sie von einem Beitrag/Dokumentation wissen, die mir helfen, würde ich es begrüßen.

Answer 1

Wie konfiguriere ich eine .NET Core 1.0.0-Konsolenanwendung für Dependency Injection, Logging und Konfiguration?

Eine Menge von dem, was geschrieben wurde, ist nach RC2 veraltet. (siehe issue). Fortunatelly gibt es einige aktualisierte Beiträge mit excelent Info:

Essential .NET - Dependency Injection with .NET Core

Essential .NET - Logging with .NET Core

Ich kam mit der folgenden Lösung auf. Ich wette, es gibt Dinge, die verbessert werden können, bitte hinterlasse Kommentare, damit ich diese Antwort verbessern kann.

In meinem static void Main, ich

• Setup-Dependency Injection
• Invoke ConfigureServices
• Instantiate meine Application Klasse DI mit
• Wechsel von 'Sync Main' zu 'async Application.Run () ' (Es macht für mich Sinn, so schnell wie möglich und nur einmal zu async zu wechseln.)

Auf meiner Application Klasse:

• ich injizieren so viel wie möglich von der Klasse Konstruktor.
• Fangen Sie eine beliebige Ausnahme für die Run() -Methode.

Hier ist der Code.

using System; 
using System.Threading.Tasks; 
using Microsoft.Extensions.Logging; 
using Microsoft.Extensions.DependencyInjection; 
using Microsoft.Extensions.Options; 
using Microsoft.Extensions.Configuration; 
using System.IO; 

public class Program 
{ 
    static void Main(string[] args) 
    { 
     IServiceCollection serviceCollection = new ServiceCollection(); 

     ConfigureServices(serviceCollection); 

     // Application application = new Application(serviceCollection); 
     IServiceProvider serviceProvider = serviceCollection.BuildServiceProvider(); 

     var app = serviceProvider.GetService<Application>(); 

     // For async 
     Task.Run(() => app.Run()).Wait(); // Exceptions thrown here will be lost! Catch them all at Run() 
     // Otherwise use sync as in: app.Run();    
    } 

    private static void ConfigureServices(IServiceCollection services) 
    { 
     ILoggerFactory loggerFactory = new LoggerFactory() 
      .AddConsole() 
      .AddDebug(); 

     services.AddSingleton(loggerFactory); // Add first my already configured instance 
     services.AddLogging(); // Allow ILogger<T> 

     IConfigurationRoot configuration = GetConfiguration(); 
     services.AddSingleton<IConfigurationRoot>(configuration); 

     // Support typed Options 
     services.AddOptions(); 
     services.Configure<MyOptions>(configuration.GetSection("MyOptions")); 

     services.AddTransient<Application>(); 
    } 

    private static IConfigurationRoot GetConfiguration() 
    { 
     return new ConfigurationBuilder() 
      .SetBasePath(Directory.GetCurrentDirectory()) 
      .AddJsonFile($"appsettings.json", optional: true) 
      .Build(); 
    } 
} 

public class MyOptions 
{ 
    public string Name { get; set; } 
} 

public class Application 
{ 
    ILogger _logger; 
    MyOptions _settings; 

    public Application(ILogger<Application> logger, IOptions<MyOptions> settings) 
    { 
     _logger = logger; 
     _settings = settings.Value; 
    } 

    public async Task Run() 
    { 
     try 
     { 
      _logger.LogInformation($"This is a console application for {_settings.Name}"); 
     } 
     catch (Exception ex) 
     { 
      _logger.LogError(ex.ToString()); 
     } 
    } 
} 
} 

Die AppSettings.json Datei:

{ 
    "MyOptions": { 
    "Name" : "John" 
    } 
} 

Und die project.json Datei:

"dependencies": { 
    "Microsoft.Extensions.Configuration": "1.0.0", 
    "Microsoft.Extensions.Configuration.FileExtensions": "1.0.0", 
    "Microsoft.Extensions.Configuration.Json": "1.0.0", 
    "Microsoft.Extensions.DependencyInjection": "1.0.0", 
    "Microsoft.Extensions.Logging": "1.0.0", 
    "Microsoft.Extensions.Logging.Console": "1.0.0", 
    "Microsoft.Extensions.Logging.Debug": "1.0.0", 
    "Microsoft.Extensions.Options": "1.0.0", 
    "Microsoft.Extensions.PlatformAbstractions": "1.0.0", 
    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0", 

Auf Ihrer Frage # 2: Ich habe das Dokument gelesen und es sei denn, ich bin etwas fehlt Es heißt nicht, dass Sie die Konfiguration schreiben können. Ich bin mir nicht sicher, ob Sie das tun können, wenn Sie die JSON-Dateien nicht manuell mit Newtonsoft.JSON bearbeiten.

Wenn ein Name/Wert-Paar in die Konfiguration geschrieben wird, wird es nicht beibehalten. Diese bedeutet, dass der geschriebene Wert verloren geht, wenn die Quellen erneut gelesen werden .

Für Ihre Frage # 3 habe ich eine Standard-AppSettings.json-Datei enthalten. Ihre Konfiguration sollte einen Abschnitt haben, in dem die Einstellungen anhand der öffentlichen Eigenschaften Ihrer Einstellungsklasse übereinstimmen.