ASP.NET Core Ottieni Json Array usando IConfiguration


168

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"));
    }
}

Ci sono i miei codici sopra, ho ottenuto null Come ottenere l'array?

Risposte:


103

Se vuoi scegliere il valore del primo oggetto, allora dovresti fare così:

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

Se vuoi scegliere il valore dell'intero array, allora dovresti fare così:

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

Idealmente, dovresti prendere in considerazione l'utilizzo del modello di opzioni suggerito dalla documentazione ufficiale. Questo ti darà più vantaggi.


23
Se hai una matrice di oggetti come "Clients": [ {..}, {..} ], dovresti invocare Configuration.GetSection("Clients").GetChildren().
halllo,

40
Se hai una serie di letterali come "Clients": [ "", "", "" ], dovresti invocare .GetSection("Clients").GetChildren().ToArray().Select(c => c.Value).ToArray().
halllo,

6
Questa risposta produrrà effettivamente 4 elementi, il primo è la sezione stessa con un valore vuoto. Non è corretto
Giovanni Bassi,

4
Lo invoco con successo in questo modo:var clients = Configuration.GetSection("Clients").GetChildren() .Select(clientConfig => new Client { ClientId = clientConfig["ClientId"], ClientName = clientConfig["ClientName"], ... }) .ToArray();
halllo

1
Nessuna di queste opzioni funziona per me poiché l'oggetto sta tornando nullo nel punto di "Clienti" usando l'esempio di hallo. Sono sicuro che il json sia ben formato poiché funziona con l'offset inserito nella stringa ["item: 0: childItem"] nel formato "Item": [{...}, {...}]
Clarence

283

È possibile installare i seguenti due pacchetti NuGet:

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

E poi avrai la possibilità di utilizzare il seguente metodo di estensione:

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

13
Questo è molto più semplice delle altre risposte.
jao,

14
Questa è di gran lunga la risposta migliore.
Giovanni Bassi,

15
Nel mio caso, la web app Aspnet core 2.1 includeva questi due pacchetti nuget. Quindi è stato solo un cambio di riga. Grazie
Shibu Thannikkunnath,

Il più semplice!
Pablo

3
Funziona anche con una serie di oggetti, ad es _config.GetSection("AppUser").Get<AppUser[]>();
Giorgos Betsos,

60

Aggiungi un livello in appsettings.json:

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

Crea una classe che rappresenti la tua sezione:

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

Nella classe di avvio dell'applicazione, associare il modello e iniettarlo nel servizio DI:

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

E nel controller, ottieni i dati di configurazione dal servizio DI:

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

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

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

Puoi anche memorizzare l'intero modello di configurazione in una proprietà nel controller, se hai bisogno di tutti i dati:

public class HomeController : Controller
{
    private readonly MySettings _mySettings;

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

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

Il servizio di iniezione di dipendenza di ASP.NET Core funziona proprio come un fascino :)


Quindi, come si usa MySettingsin avvio?
T.Coutlakis,

Viene visualizzato un errore che richiede una virgola tra "MySettings" e "MyArray".
Markus

35

Se si dispone di una matrice di oggetti JSON complessi come questo:

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

È possibile recuperare le impostazioni in questo modo:

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

30

Questo ha funzionato per me per restituire una serie di stringhe dalla mia configurazione:

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

La mia sezione di configurazione è simile alla seguente:

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

15

Nel caso di restituire una matrice di oggetti JSON complessi dalla configurazione, ho adattato la risposta di @ djangojazz per usare tipi anonimi e dinamici piuttosto che tuple.

Data una sezione delle impostazioni di:

"TestUsers": [
{
  "UserName": "TestUser",
  "Email": "Test@place.com",
  "Password": "P@ssw0rd!"
},
{
  "UserName": "TestUser2",
  "Email": "Test2@place.com",
  "Password": "P@ssw0rd!"
}],

È possibile restituire l'array di oggetti in questo modo:

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 };
}

Questo è fantastico
Vladimir Demirev il

11

Una specie di vecchia domanda, ma posso dare una risposta aggiornata per .NET Core 2.1 con gli standard C # 7. Supponiamo di avere un elenco solo in appsettings.Development.json come:

"TestUsers": [
  {
    "UserName": "TestUser",
    "Email": "Test@place.com",
    "Password": "P@ssw0rd!"
  },
  {
    "UserName": "TestUser2",
    "Email": "Test2@place.com",
    "Password": "P@ssw0rd!"
  }
]

Posso estrarli ovunque che Microsoft.Extensions.Configuration.IConfiguration sia implementato e cablato in questo modo:

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)>();

Ora ho un elenco di un oggetto ben scritto che è ben scritto. Se vado testUsers.First (), Visual Studio ora dovrebbe mostrare le opzioni per "UserName", "Email" e "Password".


9

In ASP.NET Core 2.2 e versioni successive possiamo iniettare IConfiguration ovunque nella nostra applicazione come nel tuo caso, puoi iniettare IConfiguration in HomeController e utilizzare in questo modo per ottenere l'array.

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

5

È possibile ottenere l'array direttamente senza incrementare un nuovo livello nella configurazione:

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

4

Forma breve:

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

Restituisce una matrice di stringhe:

{ "Str1", "str2", "str3"}


1
Ha funzionato per me. Grazie. Anche l'uso di Microsoft.Extensions.Configuration.Binder funziona, tuttavia vorrei evitare di fare riferimento a un altro pacchetto Nuget se una singola riga di codice può fare il lavoro.
Sau001,

3

Questo ha funzionato per me; Crea un file json:

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

Quindi, definisci alcune classi che mappano:

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

pacchetti nuget:

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

Quindi, caricalo:

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);
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.