ASP.Net Core Live-Update-Konfiguration auf stark typisierte

Question

Ich habe versucht, ASP.Net Core und ich und ich herumalbern mit der neuen Konfiguration Implementierung. Ich habe meine Konfiguration wie folgt aus:

public Startup(IHostingEnvironment env) 
{ 
    var builder = new ConfigurationBuilder() 
     .SetBasePath(env.ContentRootPath) 
     .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) 
     .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true) 
     .AddEnvironmentVariables() 
     .AddUserSecrets(); 

    ConfigurationManager.SetConfiguration(builder.Build()); 
} 

ich meine eigene Klasse Configuration haben, die im Grunde die IConfigurationRoot hält und ich habe einige Hilfsmethoden in ihm.

public static class ConfigurationManager 
{ 
    private static IConfigurationRoot _configuration { get; set; } 

    public static IConfigurationRoot GetConfiguration() 
    { 
     return _configuration; 
    } 

    public static void SetConfiguration(IConfigurationRoot configuration) 
    { 
     _configuration = configuration; 
    } 

    public static string GetString(string appSettingKey) 
    { 
     return _configuration.GetValue<string>(appSettingKey); 
    } 

    public static IConfigurationSection GetSection(string sectionKey) 
    { 
     return _configuration.GetSection(sectionKey); 
    } 
} 

Ich kann meine ‚Foo‘ wie diese Einstellung zuzugreifen:

var foo = ConfigurationManager.GetString("Foo"); 

Wenn ich meine Anwendung ausführen über den Code gibt mir den Wert von ‚Foo‘, die „Bar“ ist. Wenn ich den Wert von "Foo" in meiner applicationsettings.json von "Bar" auf "BarBar" ändere, während meine Anwendung noch läuft und auf den obigen Code stoße, würde ich den neuen Wert von "Foo" erhalten.

Ich habe eine Configuration-Klasse erstellt, so dass ich meine Einstellungen als stark typisiert haben kann.

public class Configuration 
{ 
    public string Foo { get; set; } 
} 

binde ich es zu meiner Konfiguration wie folgt aus:

services.Configure<Configuration>(ConfigurationManager.GetConfiguration()); 

ich die Einstellung durch Dependency Injection in meinem Controller wie dieses 'Foo' acces kann:

public MyController(IOptions<Configuration> config) 
{ 
    var foo = config.Value.Foo; 
} 

Wenn ich rufe der Controller der Wert von "Foo" ist "Bar". Wenn ich den Wert von "Foo" in "BarBar" ändere und den Controller erneut anrufe, ist der Wert von "Foo" immer noch "Bar" in meiner stark typisierten Konfiguration.

Gibt es eine Möglichkeit, die stark typisierte Klasse zu ändern, wenn ich meine applicationsettings.json im laufenden Betrieb ändere, wenn ich die stark typisierte Klasse nicht verwende?

Answer 1

Wenn Sie 1.1 ASP.NET-Core verwenden, können Sie die Updates von stark typisierten Konfiguration mit

IOptionsSnapshot bekommen

wo T Sie stark typisierte Konfigurationsklasse ist.

Sie finden Arbeitsbeispiel here und mehr über sie here im IOptionsSnapshot Abschnitt