यह सुनिश्चित करने के लिए कि स्ट्रिंग JSON.NET का उपयोग करके वैध JSON है

147

मेरे पास एक कच्चा तार है। मैं केवल यह पुष्टि करना चाहता हूं कि स्ट्रिंग वैध JSON है या नहीं। मैं JSON.NET का उपयोग कर रहा हूं।

c# json.net

— user960567
स्रोत

207

कोड के माध्यम से:

आपकी सबसे अच्छी शर्त 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 ढांचे का उपयोग कर सकते हैं 4.5 System.Json नाम स्थान , जैसे:

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पैकेज मैनेजर कंसोल पर) ( यहां से लिया गया )

गैर-कोड तरीका:

आमतौर पर, जब एक छोटा सा जंस स्ट्रिंग होता है और आप जसोन स्ट्रिंग में कोई गलती खोजने की कोशिश कर रहे होते हैं, तो मैं व्यक्तिगत रूप से उपलब्ध ऑन-लाइन टूल्स का उपयोग करना पसंद करता हूं । मैं आमतौर पर क्या करता हूं:

JSONLint JSON Validator में JSON स्ट्रिंग पेस्ट करें और देखें कि क्या यह वैध JSON है।
बाद में सही JSON को http://json2csharp.com/ पर कॉपी करें और इसके लिए एक टेम्प्लेट क्लास बनाएं और फिर JSON.Net का उपयोग करके इसे क्रमबद्ध करें।

— हबीब
स्रोत

3

रनटाइम में यह कैसे कर सकते हैं। मैं सत्यापन उद्देश्य के लिए ट्राई कैच का उपयोग नहीं करना चाहता

— user960567

1

आप अपने JSON के लिए एक स्कीमा बना सकते हैं और बाद में उस स्कीमा के विरुद्ध सत्यापित कर सकते हैं देखें: Json.NET 3.5 बीटा 2 - JSON स्कीमा सत्यापन

— हबीब

1

किसी भी तरह से एक कोशिश ब्लॉक के बिना यह करने के लिए? जब तक मैं एक अज्ञात के साथ काम नहीं कर रहा हूं, मैं कोशिश ब्लॉकों का उपयोग नहीं करता हूं। मुझे JsonConvert.TryDeserializeObject जैसी किसी चीज़ की तलाश है। ऑपरेशनल ट्राई कैच सिर्फ सादे खराब कोड हैं।

— जॉर्डन

1

JSON.Net का उपयोग करना: यह अपवाद नहीं हैJToken.Parse("1234") :! यदि स्ट्रिंग के साथ [या शुरू होता है, तो पहले जांच करना एक अच्छा विचार हो सकता है {। एक अन्य विकल्प उपयोग JObject.Parse()और है JArray.Parse()।

— राइनोवेवेल

1

JToken.Parse("{a:1}")करता नहीं है, भले ही यह अमान्य JSON है अपवाद फेंक - aउद्धृत किया जाना चाहिए ( stackoverflow.com/q/949449/3116322 )

— Ande

31

JContainer.Parse(str)जाँच करने के लिए विधि का उपयोग करें कि क्या str एक वैध Json है। यदि यह अपवाद फेंकता है तो यह एक वैध जसन नहीं है।

JObject.Parse- यह जांचने के लिए इस्तेमाल किया जा सकता है कि क्या स्ट्रिंग एक वैध Json ऑब्जेक्ट है
JArray.Parse- यह जांचने के लिए उपयोग किया जा सकता है कि क्या स्ट्रिंग एक वैध Json Array है
JContainer.Parse- Json ऑब्जेक्ट और Array दोनों के लिए जाँच करने के लिए उपयोग किया जा सकता है

— सेंथिलकुमार विश्वनाथन
स्रोत

17

JContainer के बजाय यह JToken का उपयोग करने के लिए अधिक वैध है क्योंकि पार्स () विधि इस स्तर पर घोषित की गई है

— डेनिस द मेनेस

6

मैं मान रहा हूं कि आप JSON.Net के बारे में बात कर रहे हैं: JContainer उस तरह से काम नहीं करता है, क्योंकि यह सभी वांछित मामलों में अपवाद नहीं फेंकेगा । उदाहरण: JContainer.Parse("1234");।

— राइनोवेवेल

गलत उत्तर, JContainer.Parse कुछ भी काम करता है

— टूलकिट

19

हबीब के उत्तर पर निर्माण, आप एक विस्तार विधि लिख सकते हैं:

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

— टॉम बिच
स्रोत

1

JToken.Parse(s);रिटर्न trueभी अगरJToken.Parse(123);

— Makeluv

2

trueइस अमान्य के लिए लौटें JSON:{A:{"B": 1}}

— मेहदी डेगानी

अच्छा विस्तार तरीका है :) हालांकि यह शायद "IsValidJson" के रूप में बेहतर होगा।

— म्लादेन बी।

11

@ हबीब के उत्तर में कुछ जोड़ने के लिए, आप यह भी जांच सकते हैं कि क्या 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;
    }
}

— जलाल
स्रोत

7

मैंने पाया कि 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;
}

— एंड्रयू रॉबर्ट्स
स्रोत

यह अमान्य JSON स्ट्रिंग नहीं है ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf यहाँ JSON मानक ECMA का प्रलेखन है और बिंदु 5 JSON मानों के तहत आप देख सकते हैं मान मान के रूप में शून्य ले सकते हैं । तो इसके सिर्फ एक बग जोसन्ट दुभाषिया में है

— डोमिनिक

4

डॉमिनिक, एक JSON मान, जो आपके द्वारा जुड़ी गई युक्ति के मेरे रीड के अनुसार कुछ मान्य टोकन होना चाहिए, शाब्दिक अशक्त पाठ के साथ अशक्त मान का प्रतिनिधित्व करता है। मान्य मान "एक वस्तु, सरणी, संख्या, स्ट्रिंग, सच्चा, गलत या अशक्त" है जो आपके द्वारा निर्दिष्ट युक्ति के अनुसार है। AFAICS का कोई वैल्यू टोकन नहीं है।

— कीर्तिलैंडर

ऐसा लगता है कि यह अमान्य JSON के साथ ठीक होगा जो इस तरह दिखता है{ name : "l am invalid JSON" }

— Jon49

2

। वैकल्पिक विकल्प JSON.Net का उपयोग करना नहीं ⚠️

.Net Core / .Net 5 के लिए ( इस लेखन के अनुसार पूर्वावलोकन में ) कोई भी System.Text.Jsonनाम और पार्स का उपयोग कर सकता है JsonDocument। उदाहरण नामस्थान के संचालन पर आधारित एक विस्तार विधि है:

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

    return false;
}

— ΩmegaMan
स्रोत

1

टॉम बीच के जवाब के बारे में; मैं इसके बजाय निम्नलिखित के साथ आया:

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

— HappyCoding
स्रोत

3

यह उपन्यास नहीं है - आपने एक विस्तार विधि बनाई है एक विस्तार विधि नहीं है। टॉम बीच का जवाब आपको पहले से ही प्राप्त हो सकता है string, जिसकी आपको आवश्यकता है (सामान्य तौर पर, मैं इस तरह के विस्तार के तरीकों को जोड़ने पर भी भड़क जाऊंगा , लेकिन यह उत्तर वास्तव में या तो होना चाहिए) ए या बी नहीं होना चाहिए "मैंने टॉम बीच के उत्तर का उपयोग किया " बिना this, यह एक विस्तार सदस्य) किए बिना यानी - दोनों इस उत्तर और संदर्भित एक समान संक्षिप्तता और कमजोरियों है। अगर आपको यह बात समझ में आनी चाहिए, तो दूसरे उत्तर पर टिप्पणी करें।

— रूबेन बार्टेलिंक

1

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

— रैंडी लार्सन
स्रोत

0

इस पद्धति के लिए बाहरी पुस्तकालयों की आवश्यकता नहीं है

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

— MostafaZ4
स्रोत

0

यहाँ हबीब के उत्तर पर आधारित एक TryParse एक्सटेंशन पद्धति है:

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
}

— jaybro
स्रोत

0

मैं इस एक का उपयोग कर रहा हूँ:

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

— यौषा अलायबौ
स्रोत