ASP.NET Core Get Json Array à l'aide d'IConfiguration

168

Dans appsettings.json

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

Dans Startup.cs

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

Dans HomeController

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

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

Il y a mes codes ci-dessus, j'ai obtenu null Comment obtenir le tableau?

Max
la source

Réponses:

103

Si vous voulez choisir la valeur du premier article, vous devriez faire comme ceci-

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

Si vous voulez choisir la valeur du tableau entier, vous devriez faire comme ceci-

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

Idéalement, vous devriez envisager d'utiliser le modèle d'options suggéré par la documentation officielle. Cela vous donnera plus d'avantages.

Sanket
la source
23
Si vous avez un tableau d'objets comme "Clients": [ {..}, {..} ], vous devez appeler Configuration.GetSection("Clients").GetChildren().
halllo
40
Si vous avez un tableau de littéraux comme "Clients": [ "", "", "" ], vous devez appeler .GetSection("Clients").GetChildren().ToArray().Select(c => c.Value).ToArray().
halllo
6
Cette réponse produira en fait 4 éléments, le premier étant la section elle-même avec une valeur vide. C'est incorrect.
Giovanni Bassi
4
Je l'invoque avec succès comme ceci:var clients = Configuration.GetSection("Clients").GetChildren() .Select(clientConfig => new Client { ClientId = clientConfig["ClientId"], ClientName = clientConfig["ClientName"], ... }) .ToArray();
halllo
1
Aucune de ces options ne fonctionne pour moi car l'objet revient nul au point de "Clients" en utilisant l'exemple de hallo. Je suis convaincu que le json est bien formé car il fonctionne avec le décalage inséré dans la chaîne ["item: 0: childItem"] au format "Item": [{...}, {...}]
Clarence
283

Vous pouvez installer les deux packages NuGet suivants:

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

Et puis vous aurez la possibilité d'utiliser la méthode d'extension suivante:

var myArray = _config.GetSection("MyArray").Get<string[]>();
Razvan Dumitru
la source
13
C'est beaucoup plus simple que les autres réponses.
jao
14
C'est de loin la meilleure réponse.
Giovanni Bassi
15
Dans mon cas, l'application Web Aspnet core 2.1, incluait ces deux packages nuget. Donc, ce n'était qu'un changement de ligne. Merci
Shibu Thannikkunnath
Le plus simple!
Pablo
3
Il fonctionne également avec un tableau d'objets, par exemple _config.GetSection("AppUser").Get<AppUser[]>();
Giorgos Betsos
60

Ajoutez un niveau dans votre appsettings.json:

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

Créez une classe représentant votre section:

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

Dans la classe de démarrage de votre application, liez votre modèle et injectez-le dans le service DI:

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

Et dans votre contrôleur, récupérez vos données de configuration auprès du service 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);
    }
}

Vous pouvez également stocker l'intégralité de votre modèle de configuration dans une propriété de votre contrôleur, si vous avez besoin de toutes les données:

public class HomeController : Controller
{
    private readonly MySettings _mySettings;

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

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

Le service d'injection de dépendances d'ASP.NET Core fonctionne comme un charme :)

AdrienTorris
la source
Alors, comment utilisez-vous MySettingsdans Startup?
T.Coutlakis
J'obtiens une erreur indiquant qu'il faut une virgule entre "MySettings" et "MyArray".
Markus
35

Si vous avez un tableau d'objets JSON complexes comme celui-ci:

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

Vous pouvez récupérer les paramètres de cette façon:

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

Cela a fonctionné pour moi pour renvoyer un tableau de chaînes de ma configuration:

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

Ma section de configuration ressemble à ceci:

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

Pour le cas du retour d'un tableau d'objets JSON complexes à partir de la configuration, j'ai adapté la réponse de @ djangojazz pour utiliser des types anonymes et dynamiques plutôt que des tuples.

Étant donné une section de paramètres de:

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

Vous pouvez renvoyer le tableau d'objets de cette façon:

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 };
}
Jaycer
la source
C'est génial
Vladimir Demirev
11

Une sorte de vieille question, mais je peux donner une réponse mise à jour pour .NET Core 2.1 avec les normes C # 7. Disons que j'ai une liste uniquement dans appsettings.Development.json telle que:

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

Je peux les extraire partout où la configuration Microsoft.Extensions.Configuration.IConfiguration est implémentée et câblée comme ceci:

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

Maintenant, j'ai une liste d'objets bien typés qui sont bien typés. Si je vais à testUsers.First (), Visual Studio devrait maintenant afficher les options pour le 'UserName', 'Email' et 'Password'.

djangojazz
la source
9

Dans ASP.NET Core 2.2 et versions ultérieures, nous pouvons injecter IConfiguration n'importe où dans notre application, comme dans votre cas, vous pouvez injecter IConfiguration dans HomeController et l'utiliser comme ceci pour obtenir le tableau.

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

Vous pouvez obtenir le tableau directement sans incrémenter un nouveau niveau dans la configuration:

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

Forme courte:

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

Il renvoie un tableau de chaîne:

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

mojtaba karimi
la source
1
A travaillé pour moi. Merci. L'utilisation de Microsoft.Extensions.Configuration.Binder fonctionne également, mais je voudrais éviter de référencer un autre package Nuget si une seule ligne de code peut faire le travail.
Sau001
3

Cela a fonctionné pour moi; Créez un fichier json:

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

Ensuite, définissez une classe qui mappe:

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

paquets nuget:

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

Ensuite, chargez-le:

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);
Roland Roos
la source