Cách đảm bảo chuỗi đó là JSON hợp lệ khi sử dụng JSON.NET

Tôi có một chuỗi thô. Tôi chỉ muốn xác thực xem chuỗi có hợp lệ JSON hay không. Tôi đang sử dụng JSON.NET.

Thông qua mã:

Đặt cược tốt nhất của bạn là sử dụng phân tích cú pháp bên trong a try-catchvà bắt ngoại lệ trong trường hợp phân tích cú pháp không thành công. (Tôi không biết về bất kỳ TryParsephương pháp nào ) .

(Sử dụng JSON.Net)

Cách đơn giản nhất sẽ là Parsesử dụng chuỗi JToken.Parsevà cũng để kiểm tra xem chuỗi bắt đầu bằng {hoặc [kết thúc bằng }hoặc ]tương ứng (được thêm từ câu trả lời này ) :

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

Lý do để thêm kiểm tra cho {hoặc [vv dựa trên thực tế là JToken.Parsesẽ phân tích các giá trị như "1234"hoặc "'a string'"như một mã thông báo hợp lệ. Tùy chọn khác có thể là sử dụng cả hai JObject.Parsevà JArray.Parsephân tích cú pháp và xem có ai trong số họ thành công không, nhưng tôi tin rằng việc kiểm tra {}và []sẽ dễ dàng hơn. (Cảm ơn @RhinoDevel đã chỉ ra)

Không có JSON.Net

Bạn có thể sử dụng không gian tên .Net framework 4.5 System.Json , như:

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

(Nhưng, bạn phải cài đặt System.Jsonthông qua trình quản lý gói Nuget bằng lệnh: PM> Install-Package System.Json -Version 4.0.20126.16343trên Bảng điều khiển quản lý gói) (lấy từ đây )

Cách phi mã:

Thông thường, khi có một chuỗi json nhỏ và bạn đang cố gắng tìm một lỗi trong chuỗi json, thì tôi cá nhân thích sử dụng các công cụ trực tuyến có sẵn. Những gì tôi thường làm là:

• Dán chuỗi JSON vào JSONLint Trình xác thực JSON và xem liệu JSON của nó có hợp lệ không.
• Sau đó sao chép JSON chính xác vào http://json2csharp.com/ và tạo một lớp mẫu cho nó và sau đó hủy tuần tự hóa nó bằng JSON.Net.

Sử dụng JContainer.Parse(str)phương pháp để kiểm tra xem str có phải là Json hợp lệ không. Nếu điều này ném ngoại lệ thì đó không phải là một Json hợp lệ.

JObject.Parse- Có thể được sử dụng để kiểm tra xem chuỗi có phải là đối tượng Json hợp lệ không
JArray.Parse- Có thể được sử dụng để kiểm tra xem chuỗi có phải là Mảng Json hợp lệ hay không
JContainer.Parse- Có thể được sử dụng để kiểm tra cả đối tượng Json & Array

Dựa trên câu trả lời của Habib, bạn có thể viết một phương pháp mở rộng:

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

Mà sau đó có thể được sử dụng như thế này:

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

Chỉ cần thêm một cái gì đó vào câu trả lời của @ Habib, bạn cũng có thể kiểm tra xem JSON đã cho có thuộc loại hợp lệ không:

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

Tôi thấy rằng JToken.Pude phân tích cú pháp JSON không hợp lệ, chẳng hạn như sau:

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

Dán chuỗi JSON vào http://jsonlint.com/ - không hợp lệ.

Vì vậy, tôi sử dụng:

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 Tùy chọn thay thế Không sử dụng JSON.Net

Đối với .Net Core / .Net 5 ( trong bản xem trước khi viết bài này ), người ta cũng có thể sử dụng System.Text.Jsonkhông gian tên và phân tích cú pháp bằng cách sử dụng JsonDocument. Ví dụ là một phương thức mở rộng dựa trên các hoạt động không gian tên:

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

    return false;
}

Về câu trả lời của Tom Beech; Tôi đã đưa ra những điều sau đây:

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

Với cách sử dụng như sau:

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

JToken.Typecó sẵn sau khi phân tích thành công. Điều này có thể được sử dụng để loại bỏ một số lời mở đầu trong các câu trả lời ở trên và cung cấp cái nhìn sâu sắc để kiểm soát kết quả tốt hơn. Đầu vào hoàn toàn không hợp lệ (ví dụ, "{----}".IsValidJson();vẫn sẽ đưa ra một ngoại lệ).

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

Tham khảo Json.Net cho JToken.Type: https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Linq_JTokenType.htmlm

Phương pháp này không yêu cầu thư viện bên ngoài

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

Đây là một phương pháp mở rộng TryPude dựa trên câu trả lời của 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;
    }
}

Sử dụng:

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

Tôi đang sử dụng cái này:

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