Create an array of dictionaries dynamically?

If we use

http://json2csharp.com/

you'll be able to get the c# structure for that json, which doesn't need anyDictionary<>

public class Grupo1
{
    public string llave1 { get; set; }
    public string llave2 { get; set; }
}

public class Grupo2
{
    public string llave1 { get; set; }
    public string llave2 { get; set; }
}

public class Informe
{
    public List<Grupo1> grupo1 { get; set; }
    public List<Grupo2> grupo2 { get; set; }
}

public class RootObject
{
    public List<Informe> informe { get; set; }
}                               

But perhaps the Grupo1and Grupo2could be defined simply asGrupo

The idea is that using the library

Newtonsoft.Json

deserialize that json to the class using

RootObject obj = JsonConvert.DeserializeObject<RootObject>(json);

Remember that the json has a structure that you must respect, you cannot apply properties such as keys as if they were the key of a dictionary, that does not work

If you are going to serialize a dictionary

Serialize to Dictionary

you could make one contain the other like being

Dictionary<string, List<Grupo>> dic = new Dictionary<string, List<Grupo>>();

var grupo1 = new List<Grupo>() {
     new Grupo() { llave1 = "01", llave2 = "02"},
     new Grupo() { llave1 = "01", llave2 = "02"} 
  };

dic.Add("grupo1", grupo1);

var grupo2 = new List<Grupo>() {
     new Grupo() { llave1 = "xx", llave2 = "xx"}
  };

dic.Add("grupo2", grupo2);

If you want to add something additional you would use

var lista = dic["grupo2"] as List<Grupo>;
lista.Add(new Grupo() { llave1 = "xx", llave2 = "xx"});

You can use lists, dictionaries, and a wrapper class.

First the class that will do the wrapper:

public class CustomWrap
{
    public List<Dictionary<string, List<Dictionary<string, string>>>> informe { get; set; }

    public CustomWrap()
    {
        informe = new List<Dictionary<string, List<Dictionary<string, string>>>>();
    }
}

It is an extremely simple class, it only has one property that is informeand a constructor that initializes said property.

Now I place how to fill or use the class CustomWrap:

static void Main(string[] args)
{
    CustomWrap jsonObjTest = new CustomWrap();

    Dictionary<string, List<Dictionary<string, string>>> grupo1 = new Dictionary<string, List<Dictionary<string, string>>>();
    Dictionary<string, List<Dictionary<string, string>>> grupo2 = new Dictionary<string, List<Dictionary<string, string>>>();
    Dictionary<string, List<Dictionary<string, string>>> grupo3 = new Dictionary<string, List<Dictionary<string, string>>>();

    grupo1.Add("grupo1", new List<Dictionary<string, string>>());
    grupo1["grupo1"].Add(new Dictionary<string, string>() { { "llave1", "01" }, { "llave2", "02" } });
    grupo1["grupo1"].Add(new Dictionary<string, string>() { { "llave1", "11" }, { "llave2", "12" } });

    grupo2.Add("grupo2", new List<Dictionary<string, string>>());
    grupo2["grupo2"].Add(new Dictionary<string, string>() { { "llave1", "54" }, { "llave2", "62" } });
    grupo2["grupo2"].Add(new Dictionary<string, string>() { { "llave1", "35" }, { "llave2", "23" } });

    grupo3.Add("grupo3", new List<Dictionary<string, string>>());
    grupo3["grupo3"].Add(new Dictionary<string, string>() { { "llave1", "54" }, { "llave2", "62" }, { "llave3", "100" } });
    grupo3["grupo3"].Add(new Dictionary<string, string>() { { "llave1", "35" }, { "llave2", "23" }, { "llave3", "124" } });
    grupo3["grupo3"].Add(new Dictionary<string, string>() { { "llave1", "35" }, { "llave2", "23" }, { "llave3", "634" } });

    jsonObjTest.informe.Add(grupo1);
    jsonObjTest.informe.Add(grupo2);
    jsonObjTest.informe.Add(grupo3);

    string json = JsonConvert.SerializeObject(jsonObjTest, Formatting.Indented);
}

Which the output or the value of the variable jsonis:

{
  "informe": [
    {
      "grupo1": [
        {
          "llave1": "01",
          "llave2": "02"
        },
        {
          "llave1": "11",
          "llave2": "12"
        }
      ]
    },
    {
      "grupo2": [
        {
          "llave1": "54",
          "llave2": "62"
        },
        {
          "llave1": "35",
          "llave2": "23"
        }
      ]
    },
    {
      "grupo3": [
        {
          "llave1": "54",
          "llave2": "62",
          "llave3": "100"
        },
        {
          "llave1": "35",
          "llave2": "23",
          "llave3": "124"
        },
        {
          "llave1": "35",
          "llave2": "23",
          "llave3": "634"
        }
      ]
    }
  ]
}

For each group a dictionary is created where its value will be a list. Also note that within the class CustomWrapyou can create methods to add groups and keys, always validating the keys added to the dictionaries so that they are not repeated and exceptions are thrown.

The code that I leave you does not mean that it is the most elegant solution, since it becomes a bit tedious and confusing to see a dictionary within lists and lists within a dictionary. To give it a bit more clarity (as I put in the previous paragraph), create your own add, delete and edit methods. Below I leave the list and dictionary documentation links where you can find more information on how to add and delete.

Something else that can be identified is that for each group a dictionary is created which will only contain a key with its value, which for me is wasting the use of a dictionary, although for the example it works perfectly. I advise you that if you can change the json structure to a much simpler one, it will make your job easier.

In the example I use JsonConvert.SerializeObjectto obtain the json, this library can be downloaded from the NuGet package manager. Below I leave the link to the library.

List : Represents a list of strongly typed objects that can be accessed by index.

Dictionary : Represents a collection of keys and values.

Newtonsoft.Json : This is a good choice when the JSON you are reading or writing is close to a .NET class. Documentation .

It occurs to me that you create a method to perform the increase or decrease, I leave you an example.

static void Main(string[] args)
{
    Dictionary<string, object>[] valor = new Dictionary<string, object>[10];//Declaramos nuestra variable

    valor[0] = new Dictionary<string, object>();//inicializamos
    valor[0].Add("llave1", "01");//agregamos el dato
    valor[1] = new Dictionary<string, object>();
    valor[1].Add("llave2", "02");
    valor[2] = new Dictionary<string, object>();
    valor[2].Add("llave1", "11");
    valor[3] = new Dictionary<string, object>();
    valor[3].Add("llave2", "12");

    Resize(ref valor, 20);//llamamos al metodo que cambiara el tamaño, pasamos el parametro del diccionario y el valor.
}

public static void Resize(ref Dictionary<string, object>[] origen, int resize)//Método que realizara el cambio
{
    Dictionary<string, object>[] temp = new Dictionary<string, object>[resize];//creamos un diccionario temporal el cual llevara el nuevo tamaño
    int cont = 0;//inicializamos un contador
    foreach (var item in origen)//recorremos el diccionario de origen
    {
        temp[cont] = item;//llenamos los datos
        cont++;//incrementamos el contador
    }
    origen = null;//liberamos la memoria de la variable.
    origen = temp;//asignamos la nueva memoria de temp a origen.
}

It may not be the most elegant way, but it's what occurred to me at the time.

Otherwise use

            List<Dictionary<string, object>> valor = new List<Dictionary<string, object>>();//Lista dinámica
            Dictionary<string, object> item = new Dictionary<string, object>();
            item.Add("01", "01");
            valor.Add(item);//debes conocer el item que agregas y el que eliminas
            valor.Remove(item);