Valid JSON Test

Question

I'm currently using this method to test a string if it valid JSON. The JToken class depends on Newtonsoft.Json.Linq.

public static bool IsValidJson(this string stringValue)
{
    bool returnValue = false;
    string value = null;

    if (!String.IsNullOrEmpty(stringValue))
        value = stringValue.Trim();

    if (!String.IsNullOrWhiteSpace(value) &&
        ((value.StartsWith("{") && value.EndsWith("}")) || //For object
         (value.StartsWith("[") && value.EndsWith("]")))) //For array
    {
        try
        {
            value = stringValue.Trim();

            var obj = JToken.Parse(value);
            returnValue = true;
        }
        catch
        {
            returnValue = false;
        }
    }
    else
    {
        returnValue = false;
    }

    return returnValue;
}

Any recommendations to improve?

Answer 1

You can reduce indenting by checking the string value upfront to check if it's null or whitespace. No need for the check if IsNullOrEmpty as IsNullOrWhiteSpace accounts for that check as well. You are also trimming the stringValue twice and reassigning it to value object.

Also you should only catch exceptions that you can handle.

public static bool IsValidJson(this string stringValue)
{
    if (string.IsNullOrWhiteSpace(stringValue))
    {
        return false;
    }

    var value = stringValue.Trim();

    if ((value.StartsWith("{") && value.EndsWith("}")) || //For object
        (value.StartsWith("[") && value.EndsWith("]"))) //For array
    {
        try
        {
            var obj = JToken.Parse(value);
            return true;
        }
        catch (JsonReaderException)
        {
            return false;
        }
    }

    return false;
}

Answer 2

I would not do that. Sure you can replace strings if not valid but you're going down a rabbit hole, better force valid json or you will keep getting more and more errors if you're not fixing them upstream. Also what's the json standard, there are a few that are valid

I use

JsonSerializerSettings settings = new JsonSerializerSettings() { Formatting = Formatting.Indented, Error = IgnoreErrors };

and then I solve the errors by dealing with the source of the issue

private static void IgnoreErrors(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs e)
{
   Logger.LogError($"Error in GLOBAL json Serialization of {e.ErrorContext.Member} on path {e.ErrorContext.Path}");
    e.ErrorContext.Handled = true;
}

You can use this using

jsonText= JsonConvert.SerializeObject(MyObject, settings)

and back

JsonConvert.PopulateObject(jsonText, MyObject, settings)

in the above it would not populate the items that failed and get the errors logged.

Answer 3

Well, no code samples, just some general considerations here.

To give you any advice, first of all we need to know, what is your goal? What is the mission of this code?

In one of the comments you mention something about cost. If it is valid to assume that you need to process many such JSONs concurrently, I'd optimise for throughput and memory and use a streaming parser. This type of parser is effectively a state-machine, which takes symbol by symbol and makes a transition to the next state according to its previous state and processed symbol. This is basically the same method which is used in processing regular expressions.

If on some step you find out that no valid transition can be made - throw a (single) exception.

As an output from this parser you then can produce a stream of more high-level values than just JSON tokens. Say, if you need to process large array, you can push to that stream every element of this array. I think, you could pass JSON-Path expression as an input to flush to stream every time when matching JSON structure ends.

In addition to being quite effective, this approach would give you clean, readable and testable code which is aligned with JSON semantics. Though state-machines can be quite verbose.

If you'd like to accomplish it as an exercise - this would be good approach. But if you just need some working code - use an existing JSON streaming parser.

Answer 4

JContainer is the base class for:

• JArray
• JObject
• JProperty

Here would be your new method using the JContainer.Parse() method:

public static bool IsValidJson(this string value)
{
    try
    {
        var json = JContainer.Parse(value);
        return true;
    }
    catch
    {
        return false;
    }
}

Answer 5

And yet another version. A simple flip of the initial test ..... @ t3chb0t, as I can NOT comment ... Hum, This version is more concise covers ALL cases with the desired return value. How do you think it is inferior AND/OR a simple code dump with no thought given to it?

public static bool IsValidJson(string stringValue)
{
  if (string.IsNullOrWhiteSpace(stringValue) == false)
  {
    var value = stringValue.Trim();
    if ((value.StartsWith("{") && value.EndsWith("}")) || //For object
        (value.StartsWith("[") && value.EndsWith("]"))) //For array
    {
      try
      {
        var obj = JToken.Parse(value);
        return true;
      }
      catch (JsonReaderException)
      {
        return false;
      }
    }
  }

  return false;
}

Answer 6

Do you need a separate value for the input?
Do you need to have separate test for null or white space ?
Just trim it and run the one condition - if it is empty or white space it will quickly fail that test.
Also from Charles only the exception you can handle.

public static bool IsValidJson(this string stringValue)
{
    stringValue = stringValue.Trim();   
    if ( (stringValue.StartsWith("{") && stringValue.EndsWith("}")) //For object  
         ||
         (stringValue.StartsWith("[") && stringValue.EndsWith("]")) //For array
       )  
    {
        try
        {
            var obj = JToken.Parse(stringValue);
            return true;
        }
        catch (JsonReaderException)
        {
            return false;
        }
    }
    else 
    {
        return false;
    }
}