วิธีการตรวจสอบให้แน่ใจว่าสตริงนั้นเป็น JSON ที่ถูกต้องโดยใช้ JSON.NET

ฉันมีสตริงดิบ ฉันแค่ต้องการตรวจสอบว่าสตริงเป็น JSON ที่ถูกต้องหรือไม่ ฉันกำลังใช้ JSON.NET

ผ่านรหัส:

ทางออกที่ดีที่สุดของคุณคือการใช้การแยกวิเคราะห์ภายในtry-catchและจับยกเว้นในกรณีที่การแยกวิเคราะห์ล้มเหลว (ผมไม่ได้ตระหนักถึงการใดTryParseวิธีการ)

(ใช้ JSON.Net)

วิธีที่ง่ายที่สุดคือParseการใช้สตริงJToken.Parseและเพื่อตรวจสอบว่าสตริงเริ่มต้นด้วย{หรือ[และลงท้ายด้วย}หรือ]ตามลำดับ(เพิ่มจากคำตอบนี้) :

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

เหตุผลในการเพิ่มการตรวจสอบสำหรับ{หรือ[อื่น ๆ นั้นขึ้นอยู่กับข้อเท็จจริงที่JToken.Parseจะแยกค่าเช่น"1234"หรือ"'a string'"เป็นโทเค็นที่ถูกต้อง ตัวเลือกอื่น ๆ อาจจะใช้ทั้งสองJObject.ParseและJArray.Parseในการแยกวิเคราะห์และดูว่าคนของพวกเขาประสบความสำเร็จ แต่ผมเชื่อว่าการตรวจสอบ{}และ[]ควรจะง่าย (ขอบคุณ @RhinoDevel สำหรับการชี้ให้เห็น)

ไม่มี JSON.Net

คุณสามารถใช้. Net framework 4.5 System.Json namespaceเช่น:

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

(แต่คุณต้องติดตั้งSystem.Jsonผ่านผู้จัดการแพคเกจ Nuget โดยใช้คำสั่ง: PM> Install-Package System.Json -Version 4.0.20126.16343บนคอนโซลตัวจัดการแพคเกจ) (นำมาจากที่นี่ )

วิธีที่ไม่ใช่รหัส:

โดยปกติเมื่อมีสตริง json ขนาดเล็กและคุณพยายามที่จะหาข้อผิดพลาดในสตริง json แล้วฉันเองชอบที่จะใช้เครื่องมือออนไลน์ที่มีอยู่ สิ่งที่ฉันมักจะทำคือ:

• วางสตริง JSON ในJSONLint JSON Validatorและดูว่าเป็น JSON ที่ถูกต้องหรือไม่
• ต่อมาคัดลอก JSON ที่ถูกต้องไปที่http://json2csharp.com/และสร้างคลาสเทมเพลตสำหรับมันแล้วยกเลิกการทำให้เป็นอันดับโดยใช้ JSON.Net

ใช้JContainer.Parse(str)วิธีการตรวจสอบว่า str เป็น Json ที่ถูกต้อง หากสิ่งนี้มีข้อยกเว้นแสดงว่าไม่ใช่ Json ที่ถูกต้อง

JObject.Parse- สามารถใช้เพื่อตรวจสอบว่าสตริงเป็นวัตถุ Json ที่ถูกต้อง
JArray.Parse- สามารถใช้เพื่อตรวจสอบว่าสตริงนั้นเป็น Json Array ที่ถูกต้องหรือ
JContainer.Parseไม่ - สามารถใช้เพื่อตรวจสอบทั้งวัตถุ Json และ Array

จากคำตอบของ Habib คุณสามารถเขียนวิธีการขยายได้:

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

ซึ่งสามารถใช้ดังนี้:

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

เพียงเพิ่มบางสิ่งในคำตอบของ @ Habib คุณสามารถตรวจสอบว่า JSON ที่กำหนดนั้นมาจากประเภทที่ถูกต้อง:

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

ฉันพบว่า JToken.Parse แยกวิเคราะห์ JSON ที่ไม่ถูกต้องเช่นดังต่อไปนี้:

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

วางสตริง JSON ลงในhttp://jsonlint.com/ - มันไม่ถูกต้อง

ดังนั้นฉันใช้:

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

Option ตัวเลือกสำรองที่ไม่ได้ใช้ JSON.Net ⚠️

สำหรับ NET core / สุทธิ 5 ( ในการแสดงตัวอย่างเช่นการเขียนนี้ ) หนึ่งยังสามารถใช้System.Text.Jsonnamespace JsonDocumentและแยกใช้ ตัวอย่างเป็นวิธีการขยายตามการดำเนินงานของ namespace:

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

    return false;
}

เกี่ยวกับคำตอบของทอมบีช ฉันมากับสิ่งต่อไปนี้แทน:

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

ด้วยการใช้งานดังต่อไปนี้:

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

JToken.Typeสามารถใช้ได้หลังจากการแยกวิเคราะห์ที่ประสบความสำเร็จ สิ่งนี้สามารถใช้เพื่อกำจัดคำนำบางส่วนในคำตอบข้างต้นและให้ข้อมูลเชิงลึกสำหรับการควบคุมผลลัพธ์อย่างละเอียดยิ่งขึ้น อินพุตที่ไม่ถูกต้องทั้งหมด (เช่น"{----}".IsValidJson();จะยังคงมีข้อยกเว้น)

    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 สำหรับJToken.Type: https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Linq_JTokenType.htm

วิธีนี้ไม่ต้องการไลบรารีภายนอก

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

นี่คือวิธีการขยาย TryParse ตามคำตอบของ Habib:

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

การใช้งาน:

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

ฉันใช้อันนี้:

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