Lesen von AppSettings-Werten aus einer JSON-Datei in ASP.NET Core

246

Ich habe meine AppSettings-Daten in der Datei appsettings / Config .json folgendermaßen eingerichtet:

{
  "AppSettings": {
        "token": "1234"
    }
}

Ich habe online gesucht, wie AppSettings-Werte aus der JSON-Datei gelesen werden können, konnte aber nichts Nützliches finden.

Ich habe es versucht:

var configuration = new Configuration();
var appSettings = configuration.Get("AppSettings"); // null
var token = configuration.Get("token"); // null

Ich weiß, dass Sie mit ASP.NET 4.0 Folgendes tun können:

System.Configuration.ConfigurationManager.AppSettings["token"];

Aber wie mache ich das in ASP.NET Core?

Oluwafemi
quelle
Dies kann sogar durch die Verwendung der Abhängigkeitsinjektion von IConfiguration (in .net Core 2.0) vereinfacht werden. Was hier erklärt wird Kodierung-issues.com/2018/10/…
Ranadheer Reddy
@RanadheerReddy, die Abhängigkeitsinjektion funktioniert für Controller. Aber was ist, wenn jemand einen Wert in Middleware lesen muss?
Alexander Ryan Baggett

Antworten:

319

Dies hat ein paar Drehungen und Wendungen gehabt. Ich habe diese Antwort so geändert, dass sie mit ASP.NET Core 2.0 (Stand: 26/02/2018) auf dem neuesten Stand ist.

Dies ist meistens der offiziellen Dokumentation entnommen :

Um mit Einstellungen in Ihrer ASP.NET-Anwendung zu arbeiten, wird empfohlen, nur a Configurationin der StartupKlasse Ihrer Anwendung zu instanziieren . Verwenden Sie dann das Optionsmuster, um auf einzelne Einstellungen zuzugreifen. Nehmen wir an, wir haben eine appsettings.jsonDatei, die so aussieht:

{
  "MyConfig": {
   "ApplicationName": "MyApp",
   "Version": "1.0.0"
   }

}

Und wir haben ein POCO-Objekt, das die Konfiguration darstellt:

public class MyConfig
{
    public string ApplicationName { get; set; }
    public int Version { get; set; }
}

Jetzt bauen wir die Konfiguration in Startup.cs:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

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

        Configuration = builder.Build();
    }
}

Beachten Sie, dass appsettings.jsondies standardmäßig in .NET Core 2.0 registriert wird . Bei Bedarf können wir auch eine appsettings.{Environment}.jsonKonfigurationsdatei pro Umgebung registrieren .

Wenn wir unsere Konfiguration in unsere Controller einfügen möchten, müssen wir sie bei der Laufzeit registrieren. Wir tun dies über Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    // Add functionality to inject IOptions<T>
    services.AddOptions();

    // Add our Config object so it can be injected
    services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
}

Und wir injizieren es so:

public class HomeController : Controller
{
    private readonly IOptions<MyConfig> config;

    public HomeController(IOptions<MyConfig> config)
    {
        this.config = config;
    }

    // GET: /<controller>/
    public IActionResult Index() => View(config.Value);
}

Die ganze StartupKlasse:

public class Startup 
{
    public IConfigurationRoot Configuration { get; set; }

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

        Configuration = builder.Build();
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc();

        // Add functionality to inject IOptions<T>
        services.AddOptions();

        // Add our Config object so it can be injected
        services.Configure<MyConfig>(Configuration.GetSection("MyConfig"));
    }
}
Yuval Itzchakov
quelle
3
Version "1.0.0-beta4"funktioniert bei mir nicht "1.0.0-alpha4". Vielen Dank!
Oluwafemi
2
Ich muss eine Einstellung aus einer Utility-Klasse an eine andere Ebene übergeben, damit ich so etwas wie diese öffentliche statische Zeichenfolge GetConnectionString () {if (string.IsNullOrEmpty (connectionString)) {var builder = new ConfigurationBuilder () .AddJsonFile ("config.json" benötige "); Konfiguration = builder.Build (); connectionString = Configuration.Get ("Daten: DefaultConnection: ConnectionString"); }} return connectionString; }
dnxit
2
Ich bekommeArgument 2: cannot convert from 'Microsoft.Extensions.Configuration.IConfigurationSection' to 'System.Action<....Settings>'
Peter
5
Nach dem Hinzufügen des Nugets funktionierte Microsoft.Extensions.Options.ConfigurationExtensionses wie erwartet.
Peter
2
Schöne Erklärung der Konfigurationsprozesslogik, aber es fehlt ein wichtiger Punkt: SetBasePath () und AddJsonFile () sind Erweiterungsmethoden, die in separaten Assemblys tief im Framework verankert sind. Um loszulegen, müssen zusätzlich zu Microsoft.Extensions.Configuration Microsoft.Extensions.Configuration.FileExtensions und Microsoft.Extensions.Configuration.Json installiert werden.
Bozhidar Stoyneff
63

Zunächst einmal: Der Assemblyname und der Namespace von Microsoft.Framework.ConfigurationModel wurden in Microsoft.Framework.Configuration geändert. Sie sollten also verwenden: z

"Microsoft.Framework.Configuration.Json": "1.0.0-beta7"

als Abhängigkeit in project.json. Verwenden Sie Beta5 oder 6, wenn Sie 7 nicht installiert haben. Dann können Sie so etwas in tun Startup.cs.

public IConfiguration Configuration { get; set; }

public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
     var configurationBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
        .AddJsonFile("config.json")
        .AddEnvironmentVariables();
     Configuration = configurationBuilder.Build();
}

Wenn Sie dann eine Variable aus der Datei config.json abrufen möchten, können Sie sie sofort abrufen, indem Sie:

public void Configure(IApplicationBuilder app)
{
    // Add .Value to get the token string
    var token = Configuration.GetSection("AppSettings:token");
    app.Run(async (context) =>
    {
        await context.Response.WriteAsync("This is a token with key (" + token.Key + ") " + token.Value);
    });
}

oder Sie können eine Klasse namens AppSettings wie folgt erstellen:

public class AppSettings
{
    public string token { get; set; }
}

und konfigurieren Sie die Dienste wie folgt:

public void ConfigureServices(IServiceCollection services)
{       
    services.AddMvc();

    services.Configure<MvcOptions>(options =>
    {
        //mvc options
    });

    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
}

und dann über zB einen Controller wie diesen darauf zugreifen:

public class HomeController : Controller
{
    private string _token;

    public HomeController(IOptions<AppSettings> settings)
    {
        _token = settings.Options.token;
    }
}
Umarmung
quelle
können Sie bitte Konfiguration json für "AppSettings" als Referenz teilen
Ankit Mori
Ich benötige ganze appSettings.json-Konfigurationen in der Klasse. Dazu habe ich eine Klasse gemäß JSON entworfen und verwende sie, Configuration.Get<AppSettings>()um die gesamte Datei anstelle eines bestimmten Abschnitts zu deserialisieren.
Nilay
52

Für .NET Core 2.0 haben sich die Dinge ein wenig geändert. Der Startkonstruktor verwendet ein Konfigurationsobjekt als Parameter. Daher ist die Verwendung von ConfigurationBuildernicht erforderlich. Hier ist mein:

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

public IConfiguration Configuration { get; }

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.Configure<StorageOptions>(Configuration.GetSection("AzureStorageConfig"));
}

Mein POCO ist das oben StorageOptionserwähnte Objekt:

namespace FictionalWebApp.Models
{
    public class StorageOptions
    {
        public String StorageConnectionString { get; set; }
        public String AccountName { get; set; }
        public String AccountKey { get; set; }
        public String DefaultEndpointsProtocol { get; set; }
        public String EndpointSuffix { get; set; }

        public StorageOptions() { }
    }
}

Und die Konfiguration ist eigentlich ein Unterabschnitt meiner appsettings.jsonDatei mit dem Namen AzureStorageConfig:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },

  "AzureStorageConfig": {
    "AccountName": "fictionalwebapp",
    "AccountKey": "Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==",
    "DefaultEndpointsProtocol": "https",
    "EndpointSuffix": "core.windows.net",
    "StorageConnectionString": "DefaultEndpointsProtocol=https;AccountName=fictionalwebapp;AccountKey=Cng4Afwlk242-23=-_d2ksa69*2xM0jLUUxoAw==;EndpointSuffix=core.windows.net"
  }
}

Das einzige, was ich hinzufügen möchte, ist, dass ich, da sich der Konstruktor geändert hat, nicht getestet habe, ob etwas zusätzliches getan werden muss, damit er geladen wird appsettings.<environmentname>.json im Gegensatz zu appsettings.json.

MDMoore313
quelle
Nur ein Hinweis, dass Sie .AddJsonFile ("yourfile.json") noch an ConfigConfiguration werfen müssen. IE, müssen Sie ihm sagen, wo sich die Datei befindet. Hab das in der Antwort nicht gesehen.
Eric
Eric, ich werde das noch einmal testen. Ich kann mich nicht erinnern, diese Zeile hinzugefügt zu haben. Könnte es nur notwendig sein, wenn der Name der JSON-Datei nicht der Standardname ist?
MDMoore313
Per MSDN ist es für ASPNETCORE 2.0 nicht erforderlich, obwohl es auch für mich nicht zu funktionieren scheint. docs.microsoft.com/en-us/dotnet/api/…
Sa Thiru
1
Ich kann bestätigen, dass ich ein ConfigurationBuilder () -Objekt erstellen und AddJSONFile () aufrufen musste, um die Dateien appSettings.json in das Konfigurationswörterbuch zu laden. Dies ist ASP.NET Core 2.0. Ist dies ein Fehler, da er im Widerspruch zu den Aussagen von MSDN steht?
Sa Thiru
1
Können Sie ein Beispiel geben, wie Sie StorageOptions in Ihre Controller einfügen? Wenn ich den Ansatz von hug verwende, Abhängigkeitsinjektion mit zu verwenden public HomeController(IOptions<StorageOptions> settings), wird folgende Fehlermeldung angezeigt: Modellgebundene komplexe Typen dürfen keine abstrakten oder Werttypen sein und müssen einen parameterlosen Konstruktor haben.
Jpsy
30

Mit .NET Core 2.2 und auf einfachste Weise ...

public IActionResult Index([FromServices] IConfiguration config)
{
    var myValue = config.GetValue<string>("MyKey");
}

appsettings.jsonwird automatisch geladen und ist entweder über den Konstruktor oder die Aktionsinjektion verfügbar, und es gibt auch eine GetSectionMethode IConfiguration. Es besteht keine Notwendigkeit zu ändern Startup.csoder Program.cswenn alles, was Sie brauchen, ist appsettings.json.

tnJed
quelle
2
noch einfacher:var myValue = config["MyKey"]
Jokab
... und Sie können Folgendes tun: config ["Storage: ConnectionString"], um Elemente innerhalb des json abzurufen. Ich kann bestätigen, dass diese Technik auf .net Core 3 und auf Konstruktionsinjektion funktioniert.
Mário Meyrelles
29

Wenn Sie nur den Wert des Tokens erhalten möchten, verwenden Sie

Configuration["AppSettings:token"]

Kodebot
quelle
4
Damit dies funktioniert, muss zuvor eine IConfiguration-Instanz über ConfigurationBuilder initialisiert werden.
Ε Г И І І И
20

.NET Core 3.0

Vielleicht ist es nicht der beste Weg, einen Wert von appsettings.json zu erhalten , aber es ist einfach und funktioniert in meiner Anwendung !!

Datei appsettings.json

{
    "ConnectionStrings": {
        "DefaultConnection":****;"
    }

    "AppSettings": {
        "APP_Name": "MT_Service",
        "APP_Version":  "1.0.0"
    }
}

Regler:

Oben :

using Microsoft.Extensions.Configuration;

In Ihrem Code:

var AppName = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build().GetSection("AppSettings")["APP_Name"];
Alexander S.
quelle
Ziemlich einfach. Danke dafür, du hast mir geholfen!
Matt
AddJsonFile ist im ConfigurationBuilder
Essej
10

Das Folgende funktioniert für Konsolenanwendungen.

  1. Installieren Sie die folgenden NuGet-Pakete ( .csproj);

    <ItemGroup>
        <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0-preview2-35157" />
        <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.2.0-preview2-35157" />
        <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0-preview2-35157" />
    </ItemGroup>
  2. appsettings.jsonAuf Stammebene erstellen . Klicken Sie mit der rechten Maustaste darauf und "In Ausgabeverzeichnis kopieren" als " Bei neuerer Version kopieren ".

  3. Beispielkonfigurationsdatei:

    {
      "AppConfig": {
        "FilePath": "C:\\temp\\logs\\output.txt"
      }
    }
  4. Program.cs

    configurationSection.Keyund configurationSection.Valuewird Konfigurationseigenschaften haben.

    static void Main(string[] args)
    {
        try
        {
    
            IConfigurationBuilder builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
    
            IConfigurationRoot configuration = builder.Build();
            // configurationSection.Key => FilePath
            // configurationSection.Value => C:\\temp\\logs\\output.txt
            IConfigurationSection configurationSection = configuration.GetSection("AppConfig").GetSection("FilePath");
    
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }
Teoman Shipahi
quelle
8

Für .NET Core 2.0 können Sie einfach:

Deklarieren Sie Ihre Schlüssel / Wert-Paare in appsettings.json:

{
  "MyKey": "MyValue"
}

Fügen Sie den Konfigurationsdienst in startup.cs ein und rufen Sie den Wert mithilfe des Dienstes ab

using Microsoft.Extensions.Configuration;

public class Startup
{
    public void Configure(IConfiguration configuration,
                          ... other injected services
                          )
    {
        app.Run(async (context) =>
        {
            string myValue = configuration["MyKey"];
            await context.Response.WriteAsync(myValue);
        });
Chris Halcrow
quelle
8

Ich bezweifle, dass dies eine gute Praxis ist, aber sie funktioniert vor Ort. Ich werde dies aktualisieren, wenn es beim Veröffentlichen / Bereitstellen (auf einem IIS-Webdienst) fehlschlägt.

Schritt 1 - Fügen Sie diese Assembly oben in Ihrer Klasse hinzu (in meinem Fall Controller-Klasse):

using Microsoft.Extensions.Configuration;

Schritt 2 - Fügen Sie dies oder etwas Ähnliches hinzu:

var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json").Build();

Schritt 3 - Rufen Sie dazu den Wert Ihres Schlüssels auf (gibt eine Zeichenfolge zurück):

config["NameOfYourKey"]
Eric Milliot-Martinez
quelle
Ich denke, das sollte in Ordnung sein, vorausgesetzt, das appsettings.jsonist im richtigen Verzeichnis
Ju66ernaut
7

Nur um die Antwort von Yuval Itzchakov zu ergänzen.

Sie können die Konfiguration ohne Builder-Funktion laden, Sie können sie einfach einfügen.

public IConfiguration Configuration { get; set; }

public Startup(IConfiguration configuration)
{
   Configuration = configuration;
}
Tiago Barroso
quelle
6

Zusätzlich zu den vorhandenen Antworten möchte ich erwähnen, dass es manchmal nützlich sein kann, Erweiterungsmethoden für zu habenIConfiguration willen der Einfachheit halber.

Ich behalte die JWT-Konfiguration in appsettings.json bei, sodass meine Klasse für Erweiterungsmethoden wie folgt aussieht:

public static class ConfigurationExtensions
{
    public static string GetIssuerSigningKey(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:SecurityKey");
        return result;
    }

    public static string GetValidIssuer(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Issuer");
        return result;
    }

    public static string GetValidAudience(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Authentication:JwtBearer:Audience");
        return result;
    }

    public static string GetDefaultPolicy(this IConfiguration configuration)
    {
        string result = configuration.GetValue<string>("Policies:Default");
        return result;
    }

    public static SymmetricSecurityKey GetSymmetricSecurityKey(this IConfiguration configuration)
    {
        var issuerSigningKey = configuration.GetIssuerSigningKey();
        var data = Encoding.UTF8.GetBytes(issuerSigningKey);
        var result = new SymmetricSecurityKey(data);
        return result;
    }

    public static string[] GetCorsOrigins(this IConfiguration configuration)
    {
        string[] result =
            configuration.GetValue<string>("App:CorsOrigins")
            .Split(",", StringSplitOptions.RemoveEmptyEntries)
            .ToArray();

        return result;
    }
}

Es spart Ihnen viele Zeilen und Sie schreiben einfach sauberen und minimalen Code:

...
x.TokenValidationParameters = new TokenValidationParameters()
{
    ValidateIssuerSigningKey = true,
    ValidateLifetime = true,
    IssuerSigningKey = _configuration.GetSymmetricSecurityKey(),
    ValidAudience = _configuration.GetValidAudience(),
    ValidIssuer = _configuration.GetValidIssuer()
};

Es ist auch möglich, eine IConfigurationInstanz als Singleton zu registrieren und sie zu injizieren, wo immer Sie sie benötigen. Ich verwende den Autofac-Container folgendermaßen:

var appConfiguration = AppConfigurations.Get(WebContentDirectoryFinder.CalculateContentRootFolder());
builder.Register(c => appConfiguration).As<IConfigurationRoot>().SingleInstance();

Mit MS Dependency Injection können Sie dasselbe tun:

services.AddSingleton<IConfigurationRoot>(appConfiguration);
Alex Herman
quelle
6

Hier ist der vollständige Anwendungsfall für ASP.NET Core!

articles.json

{
  "shownArticlesCount": 3,
  "articles": [
    {
      "title": "My Title 1",
      "thumbnailLink": "example.com/img1.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
    {
      "title": "My Title 2",
      "thumbnailLink": "example.com/img2.png",
      "authorProfileLink": "example.com/@@alper",
      "authorName": "Alper Ebicoglu",
      "publishDate": "2018-04-17",
      "text": "...",
      "link": "..."
    },
  ]
}

ArticleContainer.cs

public class ArticleContainer
{
    public int ShownArticlesCount { get; set; }

    public List<Article> Articles { get; set; }
}

public class Article
{
    public string Title { get; set; }

    public string ThumbnailLink { get; set; }

    public string AuthorName { get; set; }

    public string AuthorProfileLink { get; set; }

    public DateTime PublishDate { get; set; }

    public string Text { get; set; }

    public string Link { get; set; } 
}

Startup.cs

public class Startup
{
    public IConfigurationRoot ArticleConfiguration { get; set; }

    public Startup(IHostingEnvironment env)
    {
        ArticleConfiguration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("articles.json")
            .Build();
    }

    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services.AddOptions();

        services.Configure<ArticleContainer>(ArticleConfiguration);
    }
}

Index.cshtml.cs

public class IndexModel : PageModel
{
    public ArticleContainer ArticleContainer { get;set; }

    private readonly IOptions<ArticleContainer> _articleContainer;

    public IndexModel(IOptions<ArticleContainer> articleContainer)
    {
        _articleContainer = articleContainer;
    }

    public void OnGet()
    {
        ArticleContainer = _articleContainer.Value;
    }
}

Index.cshtml.cs

<h1>@Model.ArticleContainer.ShownArticlesCount</h1>
Alper Ebicoglu
quelle
"ASP.NET Core" Welche Version?
Steve Smith
5

Sie ändern einfach ständig Dinge - nachdem sie gerade Visual Studio aktualisiert haben und die gesamte Projektbombe auf dem Weg zur Wiederherstellung hatten, sieht der neue Weg folgendermaßen 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);

    if (env.IsDevelopment())
    {
        // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
        builder.AddUserSecrets();
    }

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

Ich habe diese Zeile immer wieder verpasst!

.SetBasePath(env.ContentRootPath)
Monolithcode
quelle
1
Wie können wir die AppSettings-Werte in Testprojekten mit demselben Ansatz erhalten?
S.Siva
2
They just keep changing things. Dies. Fast jede Antwort auf dieser Seite gilt nur für eine bestimmte Version von .Net Core.
Steve Smith
4

.NET Core 2.1.0

  1. Erstellen Sie die JSON-Datei im Stammverzeichnis
  2. Auf Ihrem Code:
var builder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 
var config = builder.Build();

3. Installieren Sie die folgenden Abhängigkeiten:

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.json

4. Dann WICHTIG: Klicken Sie mit der rechten Maustaste auf die Datei appsettings.json -> klicken Sie auf Eigenschaften -> wählen Sie Kopieren, falls neuer: Geben Sie hier die Bildbeschreibung ein

  1. Schließlich können Sie Folgendes tun:

    config ["key1"]

In Anbetracht dessen, dass meine Konfigurationsdatei folgendermaßen aussehen wird:

{
    "ConnectionStrings": "myconnection string here",
    "key1": "value here"
}
Gregory
quelle
2

Sie können den folgenden Code ausprobieren. Das funktioniert bei mir.

public class Settings
{
    private static IHttpContextAccessor _HttpContextAccessor;

    public Settings(IHttpContextAccessor httpContextAccessor)
    {
        _HttpContextAccessor = httpContextAccessor;
    }

    public static void Configure(IHttpContextAccessor httpContextAccessor)
    {
        _HttpContextAccessor = httpContextAccessor;
    }

    public static IConfigurationBuilder Getbuilder()
    {
        var builder = new ConfigurationBuilder()
          .SetBasePath(Directory.GetCurrentDirectory())
          .AddJsonFile("appsettings.json");
        return builder;
    }

    public static string GetAppSetting(string key)
    {
        //return Convert.ToString(ConfigurationManager.AppSettings[key]);
        var builder = Getbuilder();
        var GetAppStringData = builder.Build().GetValue<string>("AppSettings:" + key);
        return GetAppStringData;
    }

    public static string GetConnectionString(string key="DefaultName")
    {
        var builder = Getbuilder();
        var ConnectionString = builder.Build().GetValue<string>("ConnectionStrings:"+key);
        return ConnectionString;
    }
}

Hier habe ich eine Klasse erstellt, um die Verbindungszeichenfolge und die App-Einstellungen abzurufen.

In der Datei Startup.cs müssen Sie die Klasse wie folgt registrieren.

public class Startup
{

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        var httpContextAccessor = app.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
        Settings.Configure(httpContextAccessor);
    }
}
Jishan Siddique
quelle
2

Für ASP.NET Core 3.1 können Sie dieser Dokumentation folgen:

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1

Wenn Sie ein neues ASP.NET Core 3.1-Projekt erstellen, wird die folgende Konfigurationszeile angezeigt Program.cs:

Host.CreateDefaultBuilder(args)

Dies ermöglicht Folgendes:

  1. ChainedConfigurationProvider: Fügt eine vorhandene IConfiguration als Quelle hinzu. Fügt im Standardkonfigurationsfall die Hostkonfiguration hinzu und legt sie als erste Quelle für die App-Konfiguration fest.
  2. appsettings.json mit dem JSON-Konfigurationsanbieter.
  3. appsettings.Environment.json mit dem JSON-Konfigurationsanbieter. Zum Beispiel appsettings.Production.json und appsettings.Development.json.
  4. App-Geheimnisse, wenn die App in der Entwicklungsumgebung ausgeführt wird.
  5. Umgebungsvariablen mit dem Konfigurationsanbieter für Umgebungsvariablen.
  6. Befehlszeilenargumente mit dem Befehlszeilenkonfigurationsanbieter.

Dies bedeutet, dass Sie IConfigurationWerte mit einem Zeichenfolgenschlüssel einfügen und abrufen können, auch verschachtelte Werte. MögenIConfiguration ["Parent:Child"];

Beispiel:

appsettings.json

{
  "ApplicationInsights":
    {
        "Instrumentationkey":"putrealikeyhere"
    }
}

WeatherForecast.cs

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;
    private readonly IConfiguration _configuration;

    public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var key = _configuration["ApplicationInsights:InstrumentationKey"];

        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}
Ogglas
quelle
@Ogglas ... wie könnte der Aufrufer von WeatherForecastController () die Klasse erhalten, die IConfiguration implementiert?
Johnny Wu vor
1

War das "Betrug"? Ich habe gerade meine Konfiguration in der Startup-Klasse statisch gemacht und kann dann von überall darauf zugreifen:

public class Startup
{
    // This method gets called by the runtime. Use this method to add services to the container.
    // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
    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)
            .AddEnvironmentVariables();

        Configuration = builder.Build();
    }

    public static IConfiguration Configuration { get; set; }
Brian Moore
quelle
1

Holen Sie es in Controller als Objekt per Aufruf Get<YourType>():

public IActionResult Index([FromServices] IConfiguration config)
{
    BillModel model = config.GetSection("Yst.Requisites").Get<BillModel>();
    return View(model);
}
Lapenkov Vladimir
quelle
1

Zuerst sollten Sie IConfiguration injizieren und dann zum Lesen aus Appsettings eine der folgenden Methoden verwenden:

  1. Abschnittsdaten abrufen

    var redisConfig = configuration.GetSection("RedisConfig");
  2. Holen Sie sich einen Wert innerhalb eines Abschnitts

    var redisServer = configuration.GetValue<string>("RedisConfig:ServerName");
  3. Verschachtelten Wert innerhalb des Abschnitts abrufen

    var redisExpireMInutes = configuration.GetValue<int>("RedisConfig:ServerName:ExpireMInutes");
Hamed Naeemaei
quelle
Das Injizieren funktioniert für Controller, aber was ist, wenn ich es wie hier in Middleware verwenden möchte ? EG Ich verwende Redis als Middleware, um http-Antworten zwischenzuspeichern.
Alexander Ryan Baggett
1

Der .NET Core 2.2 Weg

(Ohne Zweifel wird Microsoft es in der nächsten .NET-Version wieder in etwas völlig anderes ändern.)

1. appSettings.json

Es könnte ungefähr so ​​aussehen. Hier laden wir Setting1 und Setting2

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Setting1": "abc",
  "Setting2": 123
}

2. AppSettings.cs

Die POCO- Klasse für Setting1 und Setting2. Wir werden die Datei appsettings.json in dieses Klassenobjekt laden. Die Struktur der POCO-Klasse sollte mit der JSON-Datei übereinstimmen. Eigenschaften können bei Bedarf in anderen Eigenschaften / Klassen verschachtelt sein.

public class AppSettings
{
    public string Setting1 { get; set; }
    public int Setting2 { get; set; }
}

3 Startup.cs

Laden Sie appSettings.json in Ihr AppSettings-Objekt und verwenden Sie es:

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        AppSettings settings = new AppSettings();

        Configuration = configuration;
        configuration.Bind(settings);

        // Now start using it
        string setting1 = settings.Setting1;
        int setting2 = settings.Setting2;
    }
user1321471
quelle
0

Mit der neuesten Version von netcoreapp 3.1 können Sie dies ganz einfach ohne Abhängigkeiten von Drittanbietern tun.

Ich habe eine Übersicht dafür erstellt , aber Sie können diese Klasse verwenden, um eine JSON-Datei zu lesen und dynamische Eigenschaften zurückzugeben.

using System.Text.Json;
using System.IO;

class ConfigurationLoader
{

    private dynamic configJsonData;
    public ConfigurationLoader Load(string configFilePath = "appsettings.json")
    {
        var appSettings = File.ReadAllText(configFilePath);
        this.configJsonData = JsonSerializer.Deserialize(appSettings, typeof(object));
        return this;
    }

    public dynamic GetProperty(string key)
    {
        var properties = key.Split(".");
        dynamic property = this.configJsonData;
        foreach (var prop in properties)
        {
            property = property.GetProperty(prop);
        }

        return property;
    }
}

Ich habe dies speziell gemacht, damit ich eine appconfig.json in meiner Dotnet-Konsolenanwendung verwenden kann. Ich habe dies einfach in meine Program.MainFunktion aufgenommen:

var config = new ConfigurationLoader();
config.Load();
Console.WriteLine(config.GetProperty("Environment.Name"));

Und dies gibt ein dynamicObjekt für die Eigenschaft zurück. (Ein JsonElement, wenn es kein Grundelement ist). Meine appsettings.jsonDatei sieht folgendermaßen aus:

{
  "Environment": {
    "Token": "abc-123",
    "Name": "Production"
  }
}
Justin Gilman
quelle