So stellen Sie sicher, dass die Zeichenfolge gültig ist JSON mit JSON.NET

Ich habe eine rohe Schnur. Ich möchte nur überprüfen, ob die Zeichenfolge gültige JSON ist oder nicht. Ich benutze JSON.NET.

Durch Code:

Am besten ist es, parse innerhalb einer try-catch und catch-Ausnahme zu verwenden, falls das Parsen fehlgeschlagen ist. (Ich TryParse keine TryParse Methode) .

(Verwenden von JSON.Net)

JToken.Parse wäre es, die Zeichenfolge mit JToken.Parse und zu prüfen, ob die Zeichenfolge mit { oder [ und endet mit } bzw. ] beginnt (aus dieser Antwort hinzugefügt) :

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

Der Grund für das Hinzufügen von Überprüfungen für { oder [ etc] basierte auf der Tatsache, dass JToken.Parse die Werte wie "1234" oder "'a string'" als gültiges Token JToken.Parse würde. Die andere Option könnte darin bestehen, sowohl JObject.Parse als auch JArray.Parse beim Parsen zu verwenden und zu sehen, ob einer von ihnen erfolgreich ist, aber ich glaube, die Suche nach {} und [] sollte einfacher sein. (Danke @RhinoDevel für das Aufzeigen )

Ohne JSON.Net

Sie können den .NET Framework 4.5 System.Json-Namespace verwenden , wie:

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

(Sie müssen System.Json über den Nuget-Paketmanager mit dem folgenden Befehl installieren: PM> Install-Package System.Json -Version 4.0.20126.16343 auf der Package Manager-Konsole) (von hier )

Nicht-Code-Weg:

Normalerweise, wenn es eine kleine JSON-Zeichenkette gibt und Sie versuchen, einen Fehler in der JSON-Zeichenkette zu finden, dann bevorzuge ich persönlich verfügbare Online-Werkzeuge. Was ich normalerweise mache ist:

  • JSON-String in JSONLint einfügen Der JSON-Validator, um zu sehen, ob es ein gültiger JSON ist.
  • Kopieren Sie später das korrekte JSON nach http://json2csharp.com/ und generieren Sie eine Vorlagenklasse dafür und de-serialisieren Sie es dann mit JSON.Net.

Verwenden Sie die JContainer.Parse(str) -Methode, um zu überprüfen, ob das Str ein gültiger Json ist. Wenn dies eine Ausnahme austriggers, ist es kein gültiger Json.

JObject.Parse – Kann verwendet werden, um zu überprüfen, ob die Zeichenfolge ein gültiges Json-Objekt ist
JArray.Parse – Kann verwendet werden, um zu prüfen, ob die Zeichenfolge ein gültiges Json-Array ist
JContainer.Parse – Kann verwendet werden, um nach JSON-Objekt und Array zu suchen

Aufbauend auf Habibs Antwort könnten Sie eine Erweiterungsmethode schreiben:

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

Welches kann dann so verwendet werden:

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

Um etwas zur @ Habib-Antwort hinzuzufügen, können Sie auch prüfen, ob JSON von einem gültigen Typ ist:

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

Ich habe festgestellt, dass JToken.Parse ungültiges JSON wie das folgende falsch analysiert:

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

Fügen Sie die JSON-Zeichenfolge in http://jsonlint.com/ ein – sie ist ungültig.

Also benutze ich:

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

In Bezug auf Tom Beechs Antwort; Ich habe stattdessen folgendes gefunden:

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

Mit einer Verwendung der folgenden:

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

Diese Methode benötigt keine externen Bibliotheken

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