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

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?

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.

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

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 :)

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

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" ]
    }
}

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": "Test@place.com",
  "Password": "P@ssw0rd!"
},
{
  "UserName": "TestUser2",
  "Email": "Test2@place.com",
  "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 };
}

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": "Test@place.com",
    "Password": "P@ssw0rd!"
  },
  {
    "UserName": "TestUser2",
    "Email": "Test2@place.com",
    "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'.

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

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

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

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