Ottieni valore da JToken che potrebbe non esistere (best practice)

Qual è la procedura migliore per il recupero dei valori JSON che potrebbero non esistere nemmeno in C # utilizzando Json.NET ?

In questo momento ho a che fare con un provider JSON che restituisce JSON che a volte contiene determinate coppie chiave / valore e talvolta no. Ho usato (forse in modo errato) questo metodo per ottenere i miei valori (esempio per ottenere un doppio):

if(null != jToken["width"])
    width = double.Parse(jToken["width"].ToString());
else
    width = 100;

Ora funziona bene, ma quando ce ne sono molti è ingombrante. Ho finito per scrivere un metodo di estensione, e solo dopo averlo scritto mi sono chiesto se forse stavo facendo lo stupido ... comunque, ecco il metodo di estensione (includo solo casi per double e string, ma in realtà ne ho parecchi Di Più):

public static T GetValue<T>(this JToken jToken, string key,
                            T defaultValue = default(T))
{
    T returnValue = defaultValue;

    if (jToken[key] != null)
    {
        object data = null;
        string sData = jToken[key].ToString();

        Type type = typeof(T);

        if (type is double)
            data = double.Parse(sData);
        else if (type is string)
            data = sData;

        if (null == data && type.IsValueType)
            throw new ArgumentException("Cannot parse type \"" + 
                type.FullName + "\" from value \"" + sData + "\"");

        returnValue = (T)Convert.ChangeType(data, 
            type, CultureInfo.InvariantCulture);
    }

    return returnValue;
}

Ed ecco un esempio di utilizzo del metodo di estensione:

width = jToken.GetValue<double>("width", 100);

A proposito, per favore perdona quella che potrebbe essere una domanda davvero stupida, dal momento che sembra che dovrebbe esserci una funzione incorporata per ... Ho provato Google e la documentazione di Json.NET , tuttavia non sono in grado di trovare la soluzione per la mia domanda o non è chiara nella documentazione.

Questo è più o meno lo scopo del metodo generico Value(). Ottieni esattamente il comportamento che desideri se lo combini con tipi di valore nullable e l' ??operatore:

width = jToken.Value<double?>("width") ?? 100;

Vorrei scrivere GetValuecome sotto

public static T GetValue<T>(this JToken jToken, string key, T defaultValue = default(T))
{
    dynamic ret = jToken[key];
    if (ret == null) return defaultValue;
    if (ret is JObject) return JsonConvert.DeserializeObject<T>(ret.ToString());
    return (T)ret;
}

In questo modo puoi ottenere il valore non solo dei tipi di base ma anche degli oggetti complessi. Ecco un esempio

public class ClassA
{
    public int I;
    public double D;
    public ClassB ClassB;
}
public class ClassB
{
    public int I;
    public string S;
}

var jt = JToken.Parse("{ I:1, D:3.5, ClassB:{I:2, S:'test'} }");

int i1 = jt.GetValue<int>("I");
double d1 = jt.GetValue<double>("D");
ClassB b = jt.GetValue<ClassB>("ClassB");

Ecco come puoi verificare se il token esiste:

if (jobject["Result"].SelectToken("Items") != null) { ... }

Controlla se "Articoli" esiste in "Risultato".

Questo è un esempio NON funzionante che causa un'eccezione:

if (jobject["Result"]["Items"] != null) { ... }

Puoi semplicemente typecast, e farà la conversione per te, ad es

var with = (double?) jToken[key] ?? 100;

Tornerà automaticamente nullse detta chiave non è presente nell'oggetto, quindi non è necessario testarla.

TYPE variable = jsonbody["key"]?.Value<TYPE>() ?? DEFAULT_VALUE;

per esempio

bool attachMap = jsonbody["map"]?.Value<bool>() ?? false;

Questo si prende cura dei null

var body = JObject.Parse("anyjsonString");

body?.SelectToken("path-string-prop")?.ToString();

body?.SelectToken("path-double-prop")?.ToObject<double>();