How to use Options pattern for appsettings.json complex array

Question

I have the following appsettings.json in a .NET Core Console Application. The examples shown on this Options pattern page do not cover complex type app settings.

How do I iterate through columns for each report type in the following app settings?

{
  "Reports": [
    {
      "name": "Roles",
      "fileName": "roles.csv",
      "columns": [
        {
          "name": "ROLE_ID",
          "default": ""
        },
        {
          "name": "NAME",
          "default": ""
        },
        {
          "name": "AVAILABILITY_IND",
          "default": "YES"
        }
      ]
    },
    {
      "name": "Accounts",
      "fileName": "accounts.csv",
      "columns": [
        {
          "name": "ROLE",
          "default": "NONE"
        },
        {
          "name": "USER_ID",
          "default": ""
        },
        {
          "name": "LASTNAME",
          "default": ""
        },
        {
          "name": "FIRSTNAME",
          "default": ""
        }
      ]
    }
  ]
}

So you want to bind an array of a class, containing an array of another class type? Just because the examples use primitive types for simplicity, doesn't mean you can't combine the concepts from different examples. — Jeremy Lakeman
– Jeremy Lakeman, Commented Feb 3, 2021 at 23:40
If this were simple, the OP wouldn't be asking the question. I'm in the EXACT same boat. I mean, I would think it's fairly common to want to have an array of objects as part of configuration in a JSON file, and yet, the OOB Options Pattern does not seem to support this configuration "pattern". And I want to use the Options Pattern because I want to validate the configuration via IValidateOptions<T>. — fourpastmidnight
– fourpastmidnight, Commented Sep 26, 2024 at 19:13

Rena · Accepted Answer · 2021-02-04 06:16:49Z

You could read nested array like below:

public class HomeController : Controller
{
    private readonly IConfiguration _configuration;
    public HomeController(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public IActionResult Index()
    {
        //read the first report's columns array's first item's name------"ROLE_ID"
        var data = _configuration.GetSection("Reports:0:columns:0:name");
        return View();
    }

For how to foreach all the key and value:

var model = _configuration.GetSection("Reports").AsEnumerable();
foreach (var kv in model)
{
    Console.WriteLine("{0}: {1}", kv.Key, kv.Value);
}

You could also deserialize the json to model and get the item from the model:

Model:

public class Rootobject
{
    public Report[] Reports { get; set; }
}

public class Report
{
    public string name { get; set; }
    public string fileName { get; set; }
    public Column[] columns { get; set; }
}

public class Column
{
    public string name { get; set; }
    public string _default { get; set; }
}

Controller:

var json = System.IO.File.ReadAllText("yourJsonfile.json");
var DeserializeModel = JsonSerializer.Deserialize<Rootobject>(json);

Notes:

If your json file is not default appsettings.json.Someting like:test.json etc.And you also want to read it from IConfiguration,you need remember to register it in Startup.cs:

public class Startup
{
    public Startup(IConfiguration configuration, IWebHostEnvironment env)
    {
        configuration = new ConfigurationBuilder().SetBasePath(env.ContentRootPath)
        .AddJsonFile("test.json")
        .Build();

        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

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

This is not object oriented. Also inside a controller is not normal to read settings files from the hard drive and then deserialize them. The correct pattern is to use dependency injection to pass settings into the controller. Because you could have other layers of settings like command line args and environment variables that get overlayed on top of the settings file... even further you can have multiple settings files which also a common pattern in .net core
IConfiguration in asp.net core takes care of the settings layers for a bunch of sources and any custom sources you'd like to add. It's built-in DI, so this is not reading direct from file.
OK, I get you can inject an IConfiguration into your class, but the OP was wanting to use the Options Pattern. PLUS, using IConfiguration, how would one go about validation? Using the Options Pattern, we get the IValidateOptions<T>, but that doesn't seem useful when working with IConfifuration directly.

Collectives™ on Stack Overflow

How to use Options pattern for appsettings.json complex array

1 Answer 1

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Related