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

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

Durch Code:

Am besten verwenden Sie parse in a try-catchund fangen bei fehlgeschlagener Analyse eine Ausnahme ab. (Mir ist keine TryParseMethode bekannt) .

(Verwenden von JSON.Net)

Einfachste Weg , um würde Parsedie Zeichenfolge mit JToken.Parse, und auch zu überprüfen , ob die Zeichenfolge beginnt mit {oder [und endet mit }oder ]jeweils (von dieser aufgenommener Antwort ) :

private static bool IsValidJson(string strInput)
{
    if (string.IsNullOrWhiteSpace(stringValue)) { return false;}
    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 [usw. beruhte auf der Tatsache, dass JToken.Parsedie Werte wie "1234"oder "'a string'"als gültiges Token analysiert wurden . Die andere Möglichkeit könnte darin bestehen, beide JObject.Parseund das JArray.ParseParsen zu verwenden und zu prüfen, ob einer von ihnen erfolgreich ist, aber ich glaube, dass es einfacher ist , dies zu überprüfen {}und []sollte es auch sein. (Danke @RhinoDevel für den Hinweis )

Ohne JSON.Net

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

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 jedoch System.Jsonüber den Nuget-Paketmanager mit dem folgenden Befehl installieren : PM> Install-Package System.Json -Version 4.0.20126.16343on Package Manager Console) (von hier übernommen )

Non-Code-Weg:

Wenn es eine kleine JSON-Zeichenfolge gibt und Sie versuchen, einen Fehler in der JSON-Zeichenfolge zu finden, bevorzuge ich persönlich die Verwendung verfügbarer Online-Tools. Was ich normalerweise mache ist:

• Fügen Sie eine JSON-Zeichenfolge in JSONLint ein. Überprüfen Sie, ob es sich um eine gültige JSON- Zeichenfolge handelt .
• Kopieren Sie später den richtigen JSON nach http://json2csharp.com/, generieren Sie eine Vorlagenklasse dafür und de-serialisieren Sie ihn dann mit JSON.Net.

Verwenden Sie die JContainer.Parse(str)Methode, um zu überprüfen, ob der str ein gültiger Json ist. Wenn dies eine Ausnahme auslöst, handelt es sich nicht um einen gültigen 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 überprüfen, ob die Zeichenfolge ein gültiges Json-Array ist.
JContainer.Parse- Kann verwendet werden, um sowohl nach Json-Objekt als auch nach 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 der Antwort von @ Habib etwas hinzuzufügen, können Sie auch überprüfen, ob JSON von einem gültigen Typ stammt:

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

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

⚠️ Alternative Option ohne JSON.Net ⚠️

Für .Net Core / .Net 5 ( in der Vorschau zum jetzigen Zeitpunkt ) kann man auch den System.Text.JsonNamespace verwenden und mit dem analysieren JsonDocument. Beispiel ist eine Erweiterungsmethode, die auf den Namespace-Operationen basiert:

public static bool IsJsonValid(this string txt)
{
    try { return JsonDocument.Parse(txt) != null; } catch {}

    return false;
}

In Bezug auf die Antwort von Tom Beech; Ich habe mir stattdessen Folgendes ausgedacht:

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

JToken.Typeist nach erfolgreicher Analyse verfügbar. Dies kann verwendet werden, um einen Teil der Präambel in den obigen Antworten zu entfernen und Einblicke für eine genauere Kontrolle des Ergebnisses zu erhalten. Völlig ungültige Eingabe (z. B. "{----}".IsValidJson();wird immer noch eine Ausnahme ausgelöst ).

    public static bool IsValidJson(this string src)
    {
        try
        {
            var asToken = JToken.Parse(src);
            return asToken.Type == JTokenType.Object || asToken.Type == JTokenType.Array;
        }
        catch (Exception)  // Typically a JsonReaderException exception if you want to specify.
        {
            return false;
        }
    }

Json.Net-Referenz für JToken.Type: https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Linq_JTokenType.htm

Diese Methode erfordert 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; }
    }

Hier ist eine TryParse-Erweiterungsmethode, die auf Habibs Antwort basiert:

public static bool TryParse(this string strInput, out JToken output)
{
    if (String.IsNullOrWhiteSpace(strInput))
    {
        output = null;
        return false;
    }
    strInput = strInput.Trim();
    if ((strInput.StartsWith("{") && strInput.EndsWith("}")) || //For object
        (strInput.StartsWith("[") && strInput.EndsWith("]"))) //For array
    {
        try
        {
            output = JToken.Parse(strInput);
            return true;
        }
        catch (JsonReaderException jex)
        {
            //Exception in parsing json
            //optional: LogError(jex);
            output = null;
            return false;
        }
        catch (Exception ex) //some other exception
        {
            //optional: LogError(ex);
            output = null;
            return false;
        }
    }
    else
    {
        output = null;
        return false;
    }
}

Verwendung:

JToken jToken;
if (strJson.TryParse(out jToken))
{
    // work with jToken
}
else
{
    // not valid json
}

Ich benutze dieses:

  internal static bool IsValidJson(string data)
  {
     data = data.Trim();
     try
     {
        if (data.StartsWith("{") && data.EndsWith("}"))
        {
           JToken.Parse(data);
        }
        else if (data.StartsWith("[") && data.EndsWith("]"))
        {
           JArray.Parse(data);
        }
        else
        {
           return false;
        }
        return true;
     }
     catch
     {
        return false;
     }
  }