web-dev-qa-db-fra.com

Comment s'assurer que cette chaîne est un JSON valide utilisant JSON.NET

J'ai une chaîne brute. Je veux juste valider si la chaîne est valide JSON ou non. J'utilise JSON.NET.

c#json.net
115
user960567

par code:

Votre meilleur choix est d'utiliser l'analyse dans un _try-catch_ et de capturer une exception en cas d'échec de l'analyse. (je ne connais aucune méthode TryParse)) .

(Utilisation de JSON.Net)

Le moyen le plus simple serait de Parse la chaîne à l'aide de JToken.Parse , ainsi que de vérifier si la chaîne commence par _{_ ou _[_ et se termine par _}_ ou _]_ respectivement (ajouté à partir de ceci réponse ) :

_private static bool IsValidJson(string strInput)
{
    strInput = strInput.Trim();
    if ((strInput.StartsWith("{") && strInput.EndsWith("}")) || //For object
        (strInput.StartsWith("[") && strInput.EndsWith("]"))) //For array
    {
        try
        {
            var obj = JToken.Parse(strInput);
            return true;
        }
        catch (JsonReaderException jex)
        {
            //Exception in parsing json
            Console.WriteLine(jex.Message);
            return false;
        }
        catch (Exception ex) //some other exception
        {
            Console.WriteLine(ex.ToString());
            return false;
        }
    }
    else
    {
        return false;
    }
}
_

La raison d’ajouter des vérifications pour _{_ ou _[_ etc était basée sur le fait que _JToken.Parse_ analyserait les valeurs telles que _"1234"_ ou _"'a string'"_ comme un jeton valide. L’autre option pourrait consister à utiliser les deux _JObject.Parse_ et _JArray.Parse_ dans l’analyse syntaxique et voir si l’un d’entre eux réussit, mais je crois qu’il est utile de rechercher _{}_ et _[]_ devrait être plus facile. (Merci @RhinoDevel pour pointant du doigt )

Sans JSON.Net

Vous pouvez utiliser .Net framework 4.5 Espace de noms System.Json , comme:

_string jsonString = "someString";
try
{
    var tmpObj = JsonValue.Parse(jsonString);
}
catch (FormatException fex)
{
    //Invalid json format
    Console.WriteLine(fex);
}
catch (Exception ex) //some other exception
{
    Console.WriteLine(ex.ToString());
}
_

(Mais, vous devez installer _System.Json_ via le gestionnaire de packages Nuget à l'aide de la commande: _PM> Install-Package System.Json -Version 4.0.20126.16343_ sur la console de Package Manager) (extrait de ici )

Manière non codée:

Habituellement, quand il y a une petite chaîne json et que vous essayez de trouver une erreur dans la chaîne json, alors je personnellement préfère utiliser les outils en ligne disponibles. Ce que je fais habituellement c'est:

168
Habib

Utilisez la méthode JContainer.Parse(str) pour vérifier si str est un JSON valide. Si cela lève une exception, alors ce n'est pas un Json valide.

JObject.Parse - Peut être utilisé pour vérifier si la chaîne est un objet Json valide
JArray.Parse - Peut être utilisé pour vérifier si la chaîne est un tableau Json valide
JContainer.Parse - Peut être utilisé pour rechercher à la fois un objet Json et un tableau.

29
Senthilkumar Viswanathan

En vous basant sur la réponse de Habib, vous pourriez écrire une méthode d'extension:

public static bool ValidateJSON(this string s)
{
    try
    {
        JToken.Parse(s);
        return true;
    }
    catch (JsonReaderException ex)
    {
        Trace.WriteLine(ex);
        return false;
    }
}

Ce qui peut alors être utilisé comme ceci:

if(stringObject.ValidateJSON())
{
    // Valid JSON!
}
14
Tom Beech

Juste pour ajouter quelque chose à la réponse de @ Habib, vous pouvez également vérifier si un JSON donné provient d'un type valide:

public static bool IsValidJson<T>(this string strInput)
{
    strInput = strInput.Trim();
    if ((strInput.StartsWith("{") && strInput.EndsWith("}")) || //For object
        (strInput.StartsWith("[") && strInput.EndsWith("]"))) //For array
    {
        try
        {
            var obj = JsonConvert.DeserializeObject<T>(strInput);
            return true;
        }
        catch // not valid
        {             
            return false;
        }
    }
    else
    {
        return false;
    }
}
8
Jalal

J'ai constaté que JToken.Parse analysait de manière incorrecte un JSON non valide, tel que:

{
"Id" : , 
"Status" : 2
}

Collez la chaîne JSON dans http://jsonlint.com/ - elle n'est pas valide.

Donc j'utilise:

 public static bool IsValidJson(this string input)
        {
            input = input.Trim();
            if ((input.StartsWith("{") && input.EndsWith("}")) || //For object
                (input.StartsWith("[") && input.EndsWith("]"))) //For array
            {
                try
                {
                    //parse the input into a JObject
                    var jObject = JObject.Parse(input);

                    foreach(var jo in jObject)
                    {
                        string name = jo.Key;
                        JToken value = jo.Value;

                        //if the element has a missing value, it will be Undefined - this is invalid
                        if (value.Type == JTokenType.Undefined)
                        {
                            return false;
                        }
                    }
                }
                catch (JsonReaderException jex)
                {
                    //Exception in parsing json
                    Console.WriteLine(jex.Message);
                    return false;
                }
                catch (Exception ex) //some other exception
                {
                    Console.WriteLine(ex.ToString());
                    return false;
                }
            }
            else
            {
                return false;
            }

            return true;
        }
5
Andrew Roberts

En ce qui concerne la réponse de Tom Beech; Je suis venu avec ce qui suit:

public bool ValidateJSON(string s)
{
    try
    {
        JToken.Parse(s);
        return true;
    }
    catch (JsonReaderException ex)
    {
        Trace.WriteLine(ex);
        return false;
    }
}

Avec une utilisation de ce qui suit:

if (ValidateJSON(strMsg))
{
    var newGroup = DeserializeGroup(strMsg);
}
2
HappyCoding

Cette méthode ne nécessite pas de bibliothèques externes

using System.Web.Script.Serialization;
bool IsValidJson(string json)
    {
        try {
            var serializer = new JavaScriptSerializer();
            dynamic result = serializer.DeserializeObject(json);
            return true;
        } catch { return false; }
    }
0
MostafaZ4