Linguaggi

C#

Generale #

Questa guida mostra come creare una struttura json e manipolare i dati

Creare una struttura #

La struttura deve sempre partire da un oggetto json. Di seguito viene mostrato come creare la root le proprietà, array e oggetti.

JObject root = new JObject()

root.add("string","hello");
root.add("byte","h");
root.add("integer",100);
root.add("long",9000000000000000000);
root.add("float",12.5);
root.add("decimal",15E-50);
root.add("boolean",true);
root.add("json empty object",new JObject());
root.add("json empty array",new JArray());
root.add("null",null);

 

Prendere le proprietà e modificare i valori #

Oggetti #

Di seguito viene mostrato come visualizzare il valore, sapendo a pripri il tipo di dato che è memorizzato all’interno

long value = root.getProperty("long").Value;

Questo restituisce l’istanza JPair con chiave e valore. La parola long è la chiave con cui è memorizzato il valore(il nome della proprietà nell’oggetto creato prima).

E’ possibile settare il valore, anche cambiando il tipo di dato

root.getProperty("long").Value = "Hellooooo";

Array #

Negli array, gli elementi possono essere recuperati tramite il loro indice.

using OpenLab.GeJSON;

JArray array = new JArray(new string[] { "item1", "item2", "item3", "item4", "item5" });

string item1 = array.GetItem(0).Value;
Console.WriteLine(item1);

array.GetProperty(0).Value = "Helooooo";
item1 = array.GetItem(0).Value;
Console.WriteLine(item1);

Prendere tutti gli elementi #

using OpenLab.GeJSON;

JArray array = new JArray(new string[] { "item1", "item2", "item3", "item4", "item5" });
foreach(var item in array.toArray())
{
    Console.WriteLine(item);
}

Verificare il tipo di una proprietà #

Prelevando una proprietà, come sopra, dobbiamo sapere a priori il tipo di dato di convertirlo in una variabile finita, oppure possiamo controllare il tipo di dato del valore con il metodo GetJsonType

JPair pair = root.getProperty("long");
if(pair.GetJsonType() == JType.Long){
   long value = pair.Value;
else{
   int value = pair.Value;
}

Default value #

Se si vuole un valore di default, nel caso la proprietà non fosse presente nella struttura json si può usare questo metodo

JPair pair = root.getProperty("integer",50);

In questo case verrà restituito il valore 50 se non esiste la proprietà con chiave integer

Gestire un elemento che non esiste in un oggetto #

Nel caso una proprietà non esista viene lanciata un eccezione ElementNotFoundException, all’interno dell’eccezione è memorizzato l’elemento(JObject) su cui si è tentato di recuperare la proprietà.

try{
    JPair pair = root.GetProperty("integer");
    Console.WriteLine(pair.Value);
}
catch(ElementNotFoundException ex){
    Console.WriteLine(ex.element.ToString(false));
}

Nell’esempio, nel blocco catch viene recuperato l’elemento che dovrebbe contenere la proprietà integer e viene visualizzato in console la struttura con ToString

Prendere direttamente i valori #

Per prelevare direttamente in valori è possibile usare il metodo GetValue al posto di GetProperty

int val = root.GetValue("integer");
Console.WriteLine(val);

// or

int val = root.GetValue("integer",50);
Console.WriteLine(val);

Valori null #

I valori memorizzati in una proprietà di un oggetto o in un elemento possono essere nulli.

string? o = root.Get("string",null);

if(o != null)
{
    Console.WriteLine(o);
}
else
{
    Console.WriteLine("NULL");
}

In questo caso viene restituito null sia se la proprietà non esiste sia se il suo valore è null perché è stato specificato un valore di default. Nel caso il valore di default non venga specificato viene lanciata un eccezione ElementNotFoundException

try
{
    string? o = root.Get("string");

    if (o != null)
    {
        Console.WriteLine(o);
    }
    else
    {
        Console.WriteLine("NULL");
    }
}
catch (ElementNotFoundException ex)
{
    Console.WriteLine(ex.Message);
}

Alias #

Per velogizzare la scrittura del codice sono stati introdotti degli alias di GetValue e Getproperty().Value. Per prelevare i valori è possibile usare direttamente Get mentre per modificare un valore si può usare anche Set

var jsonString = @"
{ 
    'number' : 150E02,
    'scientific number' : '150E02',
    'obj' : {
        'innerObj' : {
            'p1' : 'v1',
            'p2' : 'v2'
        }
    }
    
}"; 
JObject o = new JObject(jsonString); 
Console.WriteLine(o.Get("obj").Get("innerObj").Get("p1"));

 

Navigare nella struttura #

E’ possibile risalire la struttura usando il metodo parent disponibile in JObject e JArray. Questo restituisce loggetto o l’array che contiene l’oggetto(o l’array) da cui viene chiamato parent . Se l’oggetto corrente non è contenuto in nessuna altro oggetto viene lanciata un eccezione NullReferenceException.

using OpenLab.GeJSON;

JObject root = new JObject(); 

JObject lvl1 = new JObject(); 
root.Add("level 1", lvl1);

lvl1.Add("test", "Helooooo");

JObject lvl2 = new JObject(); 
lvl1.Add("level 2", lvl2); try
{
    if (lvl2.Parent() is JObject)
    { 
        // is JObject
        JObject p = lvl2.Parent();
        Console.WriteLine(p.GetProperty("test"));
    }
    else
    { 
        // is array
        JArray a = lvl2.Parent();
        Console.WriteLine(a.GetItem(0));
    } 
}catch(NullReferenceException){
    throw;
}


//OUTPUT
Helooooo

Verifiche #

Se contiene, è vuoto, quanto contiene #

E’ possibile verificare se un oggetto contiene una proprietà con il metodo Contains che prende come parametro la chiave della proprietà

JObject o = new JObject("key1","value1");
o.Add("key2","value2");

if(o.Empty()){
    Console.WriteLine("Object is empty");
}

Console.WriteLine("How many properties? "+o.Size());
if(o.Contains("key2")){
    Console.WriteLine(o.GetValue("key2");
}

 

Conversioni #

Minificare json #

E’ possibile esportare la struttura json in testo senza spazi o ritorni a capo(minificata), i valori dei campi non vengono modificati.

JObject root = new JObject();
JArray array = new JArray(new String[] {"item1","item2","item3","item3","item4","item5"});
root.add("test",array);

Console.WriteLine(root.Minify());

//OUTPUT

{"test":["item1","item2","item3","item3","item4","item5"]}

Convertire in teso leggibile #

E’ possibile esportare la struttura json in un testo umanamente legibile con ritorni a capo, e rientri semplicemente usanto il metodo toString() su un JObject o un JArray

JObject root = new JObject(); 

JArray array = new JArray(new String[] {"item1","item2","item3","item3","item4","item5"}); 
root.Add("test",array); 

Console.WriteLine(root.ToString()); 

//OUTPUT 
{
    "test" : [
        "item1",
        "item2",
        "item3",
        "item3",
        "item4",
        "item5"
    ]
}

il metodo Tostring() prende due argomenti, il primo è un numero intero che indica quanto rinetro a sinistra inserire, il secondo argomento indica il carattere da usare come spazio nel rientro a sinistra. Di seguito un esempio inserendo come carattere di spazio dei puntini.

using OpenLab.GeJSON;

JObject root = new JObject(); JArray array = new JArray(new string[] { "item1", "item2", "item3", "item3", "item4", "item5" }); 
root.Add("test", array); 
Console.WriteLine(root.ToString(2,"."));

//OUTPUT

..{
..."test":
....[
....."item1",
....."item2",
....."item3",
....."item3",
....."item4",
....."item5"
....]
..}