Comment assurez-vous que la chaîne est valide JSON à l'aide de JSON.NET

J'ai une chaîne brute. Je veux juste vérifier si la chaîne est JSON valide ou pas. Je suis à l'aide d'JSON.NET.

InformationsquelleAutor user960567 | 2013-02-20

158

À L'Aide De Code:

Votre meilleur pari est d'utiliser les analyser à l'intérieur d'un try-catch et attraper une exception en cas d'échec de l'analyse. (Je ne suis pas au courant de tout TryParse méthode).

(À L'Aide De JSON.Net)

Façon la plus simple serait de Parse la chaîne à l'aide de JToken.Parse, et aussi pour vérifier si la chaîne commence par { ou [ et se termine avec } ou ] respectivement (ajouté à partir de ce 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 pour ajouter des contrôles pour { ou [ etc a été basée sur le fait que JToken.Parse serait d'analyser les valeurs telles que la "1234" ou "'a string'" comme un jeton valide. L'autre option pourrait être d'utiliser les deux JObject.Parse et JArray.Parse dans l'analyse et voir si quelqu'un d'entre eux réussit, mais je crois que la vérification de {} et [] devrait être plus facile. (Merci @RhinoDevel pour pointage sortir)

Sans JSON.Net

Vous pouvez utiliser .Net framework 4.5 Système.Json espace de noms ,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 Nuget package manager à l'aide de la commande: PM> Install-Package System.Json -Version 4.0.20126.16343 sur la Console du Gestionnaire de Package) (prises de ici)

Non Code moyen:

Généralement, quand il y a une petite chaîne json et que vous essayez de trouver une erreur dans la chaîne json, puis j'ai personnellement préfèrent utiliser les outils en ligne. Ce que je fais habituellement est:
- Coller chaîne JSON dans JSONLint Le JSON Validateur et de voir si
  ses un JSON valide.
- Plus tard, une copie du bon de JSON à http://json2csharp.com/ et
  générer un modèle de classe et donc dé-sérialiser
  à l'aide de JSON.Net.
- Comment pouvez le faire au moment de l'exécution. Je ne veux pas utiliser try catch pour vocation de validation
- Vous pouvez créer un Schéma pour votre JSON et vérifier par la suite à l'encontre de ce schéma, voir: Json.NET 3.5 Bêta 2 – JSON de la validation du schéma
- Pourquoi schéma? J'ai besoin de valider JSON en général.
- Aucun moyen de le faire sans un bloc try? Je n'utilise pas essayer de blocs sauf si je fais face à un inconnu. Je suis à la recherche de quelque chose comme JsonConvert.TryDeserializeObject. Opérationnel essayez les captures sont tout simplement mauvais code.
- Je suis d'accord, TryParse groupe de méthodes doit toujours être utilisée si elle est disponible. Ici, ils ne le sont pas. Donc try-catch est la seule manière possible, ou si vous souhaitez écrire votre propre deserializer... Une chose de plus à ajouter, si vous essayez de valider json, alors probablement que vous traitez avec inconnu
- Il est connu que c'est une information qui est théoriquement disponible et constante dans le champ d'application de la thread en cours ou de l'application. Si c'est un état (c'est à dire, JSON texte est en cours de validité) qui est garanti de rester vrai ou faux pour la vie de l'unité de travail, vous n'avez pas besoin d'un try catch. D'autre part, si c'est quelque chose qui n'est pas garanti d'être constant (c'est à dire ne ce fichier existe, dois-je disposer d'une connexion internet, ect...), alors que nécessite un try catch.
- Belle réponse. Cependant, j'ai un problème lorsque je veux passer mon JSON grâce à node.js lorsque la chaîne JSON est valide. Malheureusement, node.js est un peu plus strict: il ne traite pas de virgule flottante en JSON tableaux, et avec des caractères espace (comme \u00a0, l'espace insécable). Pour le moment, je suis la désérialisation et la sérialisation pour contourner, mais qui semble un peu lourd solution pour ce que je veux. De toute façon de le faire sans l'reserialization étape?
- Cela ressemble à quelque chose qu'il faut ajuster à node.js fin, malheureusement je n'ai pas d'expérience avec node.js peut-être vous pouvez poser une nouvelle question à l'égard de node.js, fournir un exemple qui devrait être bonne C# fin, mais ne parvient pas à node.js j'espère que vous aurez la réponse de la communauté.
- merci pour la suggestion. C'est Google moteur V8 de la mise en œuvre de JSON.parse que je suis en utilisant (évidemment, parce que c'est dans le nœud), et il ne semble pas être un moyen de lui dire d'être " moins strict. Il est intéressant de noter que irréguliers caractères espace, virgule flottante et les apostrophes sont pas JSON valide, et ces C# solutions semblent être un peu plus tolérant (comme c'est, peut-être, commun dans le monde Windows).
- Utilisation de la JSON.Net: Ce n' pas lancer une exception: JToken.Parse("1234")! Peut-être une bonne idée de vérifier tout d'abord, si la chaîne commence par [ ou {. Une autre alternative est l'utilisation JObject.Parse() et JArray.Parse().
- c'est un excellent point. Je ne savais pas que JToken.Parse serait se comporter comme ça. Après avoir regardé la documentation JToken.Parse ont travaillé pour "'a astring'" ainsi. Modifié ma réponse en conséquence. Merci encore pour le pointant à l'extérieur.
- Pas besoin de vérifier pour { et [. Utilisez simplement JToken.Parse et de vérifier la valeur de retour est JObject ou JArray.
- Je ne comprends pas... Pourquoi "1234" n'est pas une chaîne JSON valide? Si c'est le cas, alors qu'est-ce que la représentation JSON de le nombre 1234? Ou la valeur booléenne faux ? J'ai fait quelques recherches et selon les dernières spec RFC 7159 JSON permet à des valeurs simples, comme les nombres, etc. Pour citer le change de section à la page 14: "a Changé la définition de "JSON texte" de sorte qu'il peut être n'importe quelle valeur JSON, suppression de la contrainte qu'elle soit un objet ou un tableau."
- JToken.Parse("{a:1}") n' pas jeter l'exception, même si ce n'est pas valide JSON - a devrait être cité (stackoverflow.com/q/949449/3116322)
- N'est-ce pas RFC 7159 juste un projet de norme (voir ici)? J'ai eu mes informations d' [json.org](json.org) où il y a un lien vers le ECMA-404 Standard. Je ne suis pas vraiment sûr de savoir comment l'ensemble de la normalisation des œuvres de trucs, mais c'est le côté par exemple Douglas Crockford est le référencement..
- JSON normes sont source de confusion pour moi aussi. Il semble que ECMA-404 ne permettent json texte, mais il n'est pas permis s'il est utilisé comme un type de média internet https://www.quora.com/Is-Text-valid-JSON-by-itself
- Potentiellement coûteux de vérifier puisque vous ne sera probablement juste de le répéter si elle retourne true; je voudrais revenir un successResult objet avec un bool success et object result de sorte que l'analyse n'est pas répété.
- Certainement ne marche pas pour moi d'essayer d'Analyser une "JSON" Chaîne avec 2 "Tête" des Éléments sur le Haut Niveau à l'ignore et coupe automatiquement hors tension 1 des 2 Éléments Head - Donc pas de Valider le JSON de mal, mais il fait droit lui-même, il suffit d'écraser le dictionnaire le json est safed, en. À l'aide de C# avec Newtonsoft (code exact ci-dessus)
- J'ai vérifié dans le ECMA-ST Standard et il y a un Objet est clairement défini comme { <string> : <valeur> } ... donc pas il ne peut pas être valide {un:"lksf"} .... À partir de la Norme: Une chaîne de caractères est une séquence de points de code Unicode enveloppé avec des guillemets (U+0022) Et d'un Objet est défini comme { <string> : <valeur> } - donc ne permettant pas {un:"lksdf"}, car un est pas de string dans leur définition
- Cette accepte également une virgule.
InformationsquelleAutor Habib
28

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

JObject.Parse - Peut être utilisé pour vérifier si la chaîne de caractères 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 vérifier à la fois l'objet Json & Tableau
- Au lieu de JContainer c'est plus valide pour le type d'utilisation des JToken depuis la méthode Parse() est déclarée à ce niveau
- Je suis en supposant que vous en parler JSON.Net: JContainer n' pas travailler de cette façon, parce qu'il ne lance pas d'exception dans tous les cas voulu. Exemple: JContainer.Parse("1234");.
InformationsquelleAutor Senthilkumar Viswanathan

Bâtiment Habib réponse, 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;
    }
}

Qui peut ensuite être utilisé comme ceci:

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

JToken.Parse(s); retourne true même si JToken.Parse(123);
Retour true pour cette invalide JSON: {A:{"B": 1}}
Belle méthode d'extension pour avoir 🙂 Mais il serait mieux nommé "IsValidJson".

InformationsquelleAutor Tom Beech

Juste ajouter quelque chose à l' @Habib réponse, vous pouvez également vérifier si la donnée JSON est à partir 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;
    }
}

InformationsquelleAutor Jalal

J'ai trouvé que JToken.Analyser les traite de façon incorrecte invalid JSON telles que les suivantes:

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

Coller la chaîne JSON dans http://jsonlint.com/ - il 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;
        }

Ce n'est pas une défaillance de Chaîne JSON ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf voici la documentation au format JSON Standard ECMA et en vertu du Point 5 JSON Valeurs, vous pouvez voir une valeur peut prendre la valeur null comme valeur. Alors c'est juste un bug dans le jsonlint interprète
Dominik, une valeur JSON selon ma lecture de la spécification de vous lié doit avoir des jeton valide, avec la valeur null littérale du texte représentant une valeur null. Les valeurs valides sont "un objet, tableau, nombre, chaîne de caractères, true, false ou null" selon la spécification que vous l'avez mentionné. AFAICS il n'y a aucune valeur valide avec aucune valeur du jeton.
Il semble que ça va être OK avec invalid JSON qui ressemble à ceci { name : "l am invalid JSON" }

InformationsquelleAutor Andrew Roberts

2

Concernant Tom Hêtre de la réponse; 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 l'suivantes:
```
if (ValidateJSON(strMsg))
{
    var newGroup = DeserializeGroup(strMsg);
}
```
- Ce n'est pas nouveau, - vous avez fait une extension de la méthode de ne pas être une méthode d'extension. Tom Hêtres de réponse peut déjà réaliser ce dont vous avez besoin (En général, je voudrais aussi froncer les sourcils sur l'ajout de l'extension des méthodes de ce genre sur string, mais cette réponse ne devrait vraiment un) de ne pas être ici ou b) de dire "j'ai utilisé Tom Hêtre réponse" sans le this, c'est à dire sans en faire une extension de membre) - à la fois cette réponse et l'référencé un ont le même souci de concision et de ses faiblesses. Si vous devez faire de ce point, il suffit de mettre un commentaire sur l'autre réponse.
InformationsquelleAutor 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; }
    }

InformationsquelleAutor MostafaZ4

Vous devez vous connecter pour publier un commentaire.