Obtenha valor do JToken que pode não existir (práticas recomendadas)

Qual é a prática recomendada para recuperar valores JSON que podem nem mesmo existir em C # usando Json.NET ?

No momento, estou lidando com um provedor JSON que retorna JSON que às vezes contém determinados pares de chave / valor e às vezes não. Tenho usado (talvez incorretamente) este método para obter meus valores (exemplo para obter um duplo):

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

Isso funciona bem, mas quando há muitos deles é complicado. Acabei escrevendo um método de extensão e só depois de escrevê-lo me pergunto se não estava sendo burro ... de qualquer forma, aqui está o método de extensão (eu só incluo casos para double e string, mas na realidade tenho alguns Mais):

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

E aqui está um exemplo de uso do método de extensão:

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

BTW, por favor, perdoe o que pode ser uma pergunta realmente estúpida, já que parece que algo deveria haver uma função embutida para ... Eu tentei a documentação do Google e Json.NET , no entanto, sou inepto em encontrar a solução para minha dúvida ou não está claro na documentação.

É basicamente para isso que Value()serve o método genérico . Você obtém exatamente o comportamento que deseja se combiná-lo com tipos de valor anuláveis ​​e o ??operador:

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

Eu escreveria GetValuecomo abaixo

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

Dessa forma, você pode obter o valor não apenas dos tipos básicos, mas também de objetos complexos. Aqui está um exemplo

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

Veja como você pode verificar se o token existe:

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

Ele verifica se "Itens" existe em "Resultado".

Este é um exemplo que NÃO funciona e causa exceção:

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

Você pode simplesmente fazer o typecast e ele fará a conversão para você, por exemplo

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

Ele retornará automaticamente nullse a referida chave não estiver presente no objeto, portanto, não há necessidade de testá-la.

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

por exemplo

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

Isso cuida de nulos

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

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

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