wake-up-neo.com

Wie kann ich in einer beliebigen Klasse in ASP.NET Core auf die Konfiguration zugreifen?

Ich habe Konfigurationsdokumentation auf ASP.NET-Kern durchgelaufen. Die Dokumentation besagt, dass Sie von überall in der Anwendung auf die Konfiguration zugreifen können.

Unten ist Startup.cs erstellt von Vorlage

public class Startup
{
    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);

        if (env.IsEnvironment("Development"))
        {
            // This will Push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
            builder.AddApplicationInsightsSettings(developerMode: true);
        }

        builder.AddEnvironmentVariables();
        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container
    public void ConfigureServices(IServiceCollection services)
    {
        // Add framework services.
        services.AddApplicationInsightsTelemetry(Configuration);

        services.AddMvc();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        app.UseApplicationInsightsRequestTelemetry();

        app.UseApplicationInsightsExceptionTelemetry();

        app.UseMvc();
    }
}

In Startup.cs konfigurieren wir alle Einstellungen. Startup.cs hat auch eine Eigenschaft mit dem Namen Configuration.

Was kann ich nicht verstehen, wie Sie auf diese Konfiguration im Controller oder an einer anderen Stelle in der Anwendung zugreifen? MS empfiehlt die Verwendung von options pattern , aber ich habe nur 4-5 Schlüssel-Wert-Paare, daher möchte ich options options nicht verwenden. Ich wollte nur Zugriff auf die Konfiguration in der Anwendung haben. Wie spritze ich es in eine Klasse?

66
LP13

Aktualisieren

Durch die Verwendung von ASP.NET Core 2.0 wird automatisch die IConfiguration-Instanz Ihrer Anwendung im Abhängigkeitsinjektionscontainer hinzugefügt. Dies funktioniert auch in Verbindung mit ConfigureAppConfiguration für die WebHostBuilder.

Zum Beispiel:

public static void Main(string[] args)
{
    var Host = WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration(builder =>
        {
            builder.AddIniFile("foo.ini");
        })
        .UseStartup<Startup>()
        .Build();

    Host.Run();
}

Es ist genauso einfach wie das Hinzufügen der IConfiguration-Instanz als Einzelobjekt in ConfigureServices zur Servicesammlung:

public void ConfigureServices(IServiceCollection services)
{
   services.AddSingleton<IConfiguration>(Configuration);

   // ...
}

Dabei ist Configuration die Instanz in Ihrer Startup-Klasse.

Auf diese Weise können Sie IConfiguration in jeden Controller oder Dienst einfügen:

public class HomeController
{
   public HomeController(IConfiguration configuration)
   {
      // Use IConfiguration instance
   }
}
99
Henk Mollema

Ich weiß, das ist alt, aber angesichts der IOptions-Muster ist es relativ einfach zu implementieren:

  1. Klasse mit öffentlichen get/set -Eigenschaften, die den Einstellungen in der Konfiguration entsprechen

    public class ApplicationSettings
    {
        public string UrlBasePath { get; set; }
    }
    
  2. registrieren Sie Ihre Einstellungen 

    public void ConfigureServices(IServiceCollection services)
    {
     ...
     services.Configure<ApplicationSettings>(Configuration.GetSection("ApplicationSettings"));
    ...
    }
    
  3. über IOptions injizieren

    public class HomeController
    {
       public HomeController(IOptions<ApplicationSettings> appSettings)
       { ...
        appSettings.Value.UrlBasePath
        ...
        // or better practice create a readonly private reference
        }
     }
    

Ich bin nicht sicher, warum Sie das nicht einfach tun würden.

19
ScottC

Der richtige Weg, es zu tun:

In .NET Core können Sie die IConfiguration als Parameter in Ihren Klassenkonstruktor einfügen, und sie wird verfügbar sein.

public class MyClass 
{
    private IConfiguration configuration;
    public MyClass(IConfiguration configuration)
    {
        ConnectionString = new configuration.GetValue<string>("ConnectionString");
    }

Wenn Sie nun eine Instanz Ihrer Klasse erstellen möchten, da Ihre Klasse die IConfiguration injiziert, können Sie nicht einfach new MyClass() ausführen, da Sie den Parameter IConfiguration an den Konstruktor übergeben müssen deine Klasse auch in die Einspritzkette einzuspritzen, was zwei einfache Schritte bedeutet:

1) Fügen Sie Ihre Klasse (n) hinzu - wo Sie die IConfiguration verwenden möchten, zu der IServiceCollection bei der Methode ConfigureServices() in Startup.cs

services.AddTransient<MyClass>();

2) Definieren Sie eine Instanz - sagen wir in der Controller und fügen Sie sie mit dem Konstruktor ein:

public class MyController : ControllerBase
{
    private MyClass _myClass;
    public MyController(MyClass myClass)
    {
        _myClass = myClass;
    }

Jetzt solltest du in der Lage sein, deinen _myClass.configuration frei zu genießen ...

Andere Option:

Wenn Sie immer noch nach einer Möglichkeit suchen, sie verfügbar zu machen, ohne die Klassen in den Controller einzufügen, können Sie sie in einem static class speichern, den Sie im Startup.cs konfigurieren.

public static class MyAppData
{
    public static IConfiguration Configuration;
}

Und dein Startup Konstruktor sollte so aussehen:

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
    MyAppData.Configuration = configuration;
}

Verwenden Sie dann MyAppData.Configuration an einer beliebigen Stelle in Ihrem Programm.

Konfrontieren Sie mich nicht, warum die erste Option der richtige Weg ist. Ich sehe nur, dass erfahrene Entwickler auf ihrem Weg immer Mülldaten vermeiden, und es ist wohlbekannt, dass es nicht die beste Methode ist, alle Daten im Speicher verfügbar zu haben Die Zeit ist weder gut für die Leistung noch für die Entwicklung, und vielleicht ist es auch sicherer, nur das bei sich zu haben, was Sie brauchen.

5
Mayer Spitzer

Ich schaute in das Muster der Optionen und sah folgendes:

public class Startup
{
    public Startup(IConfiguration config)
    {
        // Configuration from appsettings.json has already been loaded by
        // CreateDefaultBuilder on WebHost in Program.cs. Use DI to load
        // the configuration into the Configuration property.
        Configuration = config;
    }
...
}

Beim Hinzufügen von Iconfiguration im Konstruktor meiner Klasse konnte ich über DI auf die Konfigurationsoptionen zugreifen.

Beispiel:

public class MyClass{

    private Iconfiguration _config;

    public MyClass(Iconfiguration config){
        _config = config;
    }

    ... // access _config["myAppSetting"] anywhere in this class
}
2
pursang

Ich mache es im Moment so:

// Requires NuGet package Microsoft.Extensions.Configuration.Json

using Microsoft.Extensions.Configuration;
using System.IO;

namespace ImagesToMssql.AppsettingsJson
{
    public static class AppSettingsJson
    {           
        public static IConfigurationRoot GetAppSettings()
        {
            string applicationExeDirectory = ApplicationExeDirectory();

            var builder = new ConfigurationBuilder()
            .SetBasePath(applicationExeDirectory)
            .AddJsonFile("appsettings.json");

            return builder.Build();
        }

        private static string ApplicationExeDirectory()
        {
            var location = System.Reflection.Assembly.GetExecutingAssembly().Location;
            var appRoot = Path.GetDirectoryName(location);

            return appRoot;
        }
    }
}

Und dann benutze ich das, wo ich die Daten aus der Datei appsettings.json holen muss:

var appSettingsJson = AppSettingsJson.GetAppSettings();
// appSettingsJson["keyName"]
2
JedatKinports

Es gibt auch eine Option, configuration in startup.cs statisch zu machen, sodass Sie von überall aus problemlos darauf zugreifen können. Statische Variablen sind praktisch. 

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}

internal static IConfiguration Configuration { get; private set; }

Dadurch ist die Konfiguration mit Startup.Configuration.GetSection... überall zugänglich. Was kann schief gehen?

1
konzo

In 8-2017 kam Microsoft mit System.Configuration für .NET CORE v4.4 heraus. Derzeit v4.5 und v4.6 Vorschau.

Für diejenigen von uns, die an der Umstellung von .Net Framework auf CORE arbeiten, ist dies von wesentlicher Bedeutung. Es ermöglicht die Speicherung und Verwendung der aktuellen app.config -Dateien, auf die von jeder Assembly aus zugegriffen werden kann. Es ist wahrscheinlich sogar eine Alternative zu appsettings.json, da Microsoft die Notwendigkeit dafür erkannt hat. Es funktioniert genauso wie zuvor in FW. Es gibt einen Unterschied:

In den Webanwendungen [z. ASP.NET CORE WEB API] müssen Sie app.config und not web.config für Ihr appSettings oder configurationSection verwenden. Möglicherweise müssen Sie web.config verwenden, jedoch nur, wenn Sie Ihre Site über IIS bereitstellen. Sie platzieren IIS-spezifische Einstellungen in web.config

Ich habe es mit netstandard20 DLL und Asp.net Core Web Api getestet und es funktioniert alles .

0
T.S.