ASP.NET Core Holen Sie sich das Json-Array mithilfe der IConfiguration

In appsettings.json

{
      "MyArray": [
          "str1",
          "str2",
          "str3"
      ]
}

In Startup.cs

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

In HomeController

public class HomeController : Controller
{
    private readonly IConfiguration _config;
    public HomeController(IConfiguration config)
    {
        this._config = config;
    }

    public IActionResult Index()
    {
        return Json(_config.GetSection("MyArray"));
    }
}

Es gibt meine Codes oben, ich habe null Wie bekomme ich das Array?

Wenn Sie den Wert des ersten Elements auswählen möchten, sollten Sie Folgendes tun:

var item0 = _config.GetSection("MyArray:0");

Wenn Sie den Wert des gesamten Arrays auswählen möchten, sollten Sie Folgendes tun:

IConfigurationSection myArraySection = _config.GetSection("MyArray");
var itemArray = myArraySection.AsEnumerable();

Idealerweise sollten Sie in Betracht ziehen, das in der offiziellen Dokumentation vorgeschlagene Optionsmuster zu verwenden . Dies gibt Ihnen mehr Vorteile.

Sie können die folgenden zwei NuGet-Pakete installieren:

Microsoft.Extensions.Configuration    
Microsoft.Extensions.Configuration.Binder

Und dann haben Sie die Möglichkeit, die folgende Erweiterungsmethode zu verwenden:

var myArray = _config.GetSection("MyArray").Get<string[]>();

Fügen Sie eine Ebene in Ihre appsettings.json hinzu:

{
  "MySettings": {
    "MyArray": [
      "str1",
      "str2",
      "str3"
    ]
  }
}

Erstellen Sie eine Klasse, die Ihren Abschnitt darstellt:

public class MySettings
{
     public List<string> MyArray {get; set;}
}

Binden Sie in Ihrer Anwendungsstartklasse Ihr Modell und fügen Sie es in den DI-Dienst ein:

services.Configure<MySettings>(options => Configuration.GetSection("MySettings").Bind(options));

Und in Ihrem Controller erhalten Sie Ihre Konfigurationsdaten vom DI-Dienst:

public class HomeController : Controller
{
    private readonly List<string> _myArray;

    public HomeController(IOptions<MySettings> mySettings)
    {
        _myArray = mySettings.Value.MyArray;
    }

    public IActionResult Index()
    {
        return Json(_myArray);
    }
}

Sie können Ihr gesamtes Konfigurationsmodell auch in einer Eigenschaft in Ihrem Controller speichern, wenn Sie alle Daten benötigen:

public class HomeController : Controller
{
    private readonly MySettings _mySettings;

    public HomeController(IOptions<MySettings> mySettings)
    {
        _mySettings = mySettings.Value;
    }

    public IActionResult Index()
    {
        return Json(_mySettings.MyArray);
    }
}

Der Abhängigkeitsinjektionsdienst des ASP.NET Core funktioniert wie ein Zauber :)

Wenn Sie ein Array komplexer JSON-Objekte wie dieses haben:

{
  "MySettings": {
    "MyValues": [
      { "Key": "Key1", "Value":  "Value1" },
      { "Key": "Key2", "Value":  "Value2" }
    ]
  }
}

Sie können Einstellungen folgendermaßen abrufen:

var valuesSection = configuration.GetSection("MySettings:MyValues");
foreach (IConfigurationSection section in valuesSection.GetChildren())
{
    var key = section.GetValue<string>("Key");
    var value = section.GetValue<string>("Value");
}

Dies funktionierte für mich, um ein Array von Zeichenfolgen aus meiner Konfiguration zurückzugeben:

var allowedMethods = Configuration.GetSection("AppSettings:CORS-Settings:Allow-Methods")
    .Get<string[]>();

Mein Konfigurationsabschnitt sieht folgendermaßen aus:

"AppSettings": {
    "CORS-Settings": {
        "Allow-Origins": [ "http://localhost:8000" ],
        "Allow-Methods": [ "OPTIONS","GET","HEAD","POST","PUT","DELETE" ]
    }
}

Für den Fall, dass ein Array komplexer JSON-Objekte aus der Konfiguration zurückgegeben wird, habe ich die Antwort von @ djangojazz so angepasst , dass anonyme Typen und dynamische anstelle von Tupeln verwendet werden.

Gegeben ein Einstellungsabschnitt von:

"TestUsers": [
{
  "UserName": "TestUser",
  "Email": "[email protected]",
  "Password": "P@ssw0rd!"
},
{
  "UserName": "TestUser2",
  "Email": "[email protected]",
  "Password": "P@ssw0rd!"
}],

Sie können das Objektarray folgendermaßen zurückgeben:

public dynamic GetTestUsers()
{
    var testUsers = Configuration.GetSection("TestUsers")
                    .GetChildren()
                    .ToList()
                    .Select(x => new {
                        UserName = x.GetValue<string>("UserName"),
                        Email = x.GetValue<string>("Email"),
                        Password = x.GetValue<string>("Password")
                    });

    return new { Data = testUsers };
}

Eine alte Frage, aber ich kann eine für .NET Core 2.1 aktualisierte Antwort mit C # 7-Standards geben. Angenommen, ich habe eine Auflistung nur in appsettings.Development.json wie:

"TestUsers": [
  {
    "UserName": "TestUser",
    "Email": "[email protected]",
    "Password": "P@ssw0rd!"
  },
  {
    "UserName": "TestUser2",
    "Email": "[email protected]",
    "Password": "P@ssw0rd!"
  }
]

Ich kann sie überall dort extrahieren, wo die Microsoft.Extensions.Configuration.IConfiguration wie folgt implementiert und verkabelt ist:

var testUsers = Configuration.GetSection("TestUsers")
   .GetChildren()
   .ToList()
    //Named tuple returns, new in C# 7
   .Select(x => 
         (
          x.GetValue<string>("UserName"), 
          x.GetValue<string>("Email"), 
          x.GetValue<string>("Password")
          )
    )
    .ToList<(string UserName, string Email, string Password)>();

Jetzt habe ich eine Liste eines gut typisierten Objekts, das gut typisiert ist. Wenn ich testUsers.First () gehe, sollte Visual Studio jetzt Optionen für 'Benutzername', 'E-Mail' und 'Passwort' anzeigen.

In ASP.NET Core 2.2 und höher können wir IConfiguration an einer beliebigen Stelle in unserer Anwendung einfügen, wie in Ihrem Fall. Sie können IConfiguration in HomeController einfügen und auf diese Weise das Array abrufen.

string[] array = _config.GetSection("MyArray").Get<string[]>();

Sie können das Array direkt abrufen, ohne eine neue Ebene in der Konfiguration zu erhöhen:

public void ConfigureServices(IServiceCollection services) {
    services.Configure<List<String>>(Configuration.GetSection("MyArray"));
    //...
}

Kurzform:

var myArray= configuration.GetSection("MyArray")
                        .AsEnumerable()
                        .Where(p => p.Value != null)
                        .Select(p => p.Value)
                        .ToArray();

Es gibt ein Array von Zeichenfolgen zurück:

{"str1", "str2", "str3"}

Das hat bei mir funktioniert; Erstellen Sie eine JSON-Datei:

{
    "keyGroups": [
        {
            "Name": "group1",
            "keys": [
                "user3",
                "user4"
            ]
        },
        {
            "Name": "feature2And3",
            "keys": [
                "user3",
                "user4"
            ]
        },
        {
            "Name": "feature5Group",
            "keys": [
                "user5"
            ]
        }
    ]
}

Definieren Sie dann eine Klasse, die zugeordnet ist:

public class KeyGroup
{
    public string name { get; set; }
    public List<String> keys { get; set; }
}

Nuget-Pakete:

Microsoft.Extentions.Configuration.Binder 3.1.3
Microsoft.Extentions.Configuration 3.1.3
Microsoft.Extentions.Configuration.json 3.1.3

Dann laden Sie es:

using Microsoft.Extensions.Configuration;
using System.Linq;
using System.Collections.Generic;

ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();

configurationBuilder.AddJsonFile("keygroup.json", optional: true, reloadOnChange: true);

IConfigurationRoot config = configurationBuilder.Build();

var sectionKeyGroups = 
config.GetSection("keyGroups");
List<KeyGroup> keyGroups = 
sectionKeyGroups.Get<List<KeyGroup>>();

Dictionary<String, KeyGroup> dict = 
            keyGroups = keyGroups.ToDictionary(kg => kg.name, kg => kg);