Most performant way to check if a string is a well formatted JSON

[MithrilMan]

I know there are a couple of solutions to check if a string is a well formed JSON, like wrapping a JsonDocument.Parse or JsonSerializer.Deserialize call in a try-catch but I'm looking for a performant way to do that.

Does .Net6 have some performant API to do that (low allocation, no try/catch)?

[huoyaoyuan]

Try Utf8JsonReader.TrySkip, to "skip" the whole json body as a token.

[MithrilMan]

I would expect a static method to validate if a string is correctly JSON formatted, this is an instance method, I'll investigate to see if the reader can be used on a raw string in a performant way.

[MithrilMan]

@huoyaoyuan mmm I'm confused
I've tried this snippet

void Main()
{
	string x = @"
	{
		""property"":2,
		""p2"":{ 
			MALFORMEDJSON23-x5
		}
	}
	";

	byte[] stringContent = System.Text.Encoding.UTF8.GetBytes(x);
	Utf8JsonReader reader = new(stringContent);
	bool skipped = reader.TrySkip();
	Console.WriteLine($"Skipped: {skipped}");
	Console.WriteLine($"Skipped Bytes: {reader.BytesConsumed}");
}

and it returns true and it consumed 0 bytes (so basically it did nothing and I would have expected to see a false there
if I remove the malformed Json part it returns the same.

the only way to make it skip something is to use a proper json formatted document, use reader.Read() and then skip but of course this doesn't work for me because if it's an invalid json, reader.Read throws (and I'm not looking for a try/catch solution)

If I've missed your suggestion, can you explain better what you mean?
Thanks

[bartonjs]

I believe that TrySkip returned true because it moved from "no JSON yet" to "I found the {" (reader.TokenType is probably StartObject). For StartObject/StartArray you'd need a second call to TrySkip to see if it can get to the matching EndObject/EndArray.

[MithrilMan]

no matter where you put an invalid part, it does the same (e.g. start the string with a character like <

what I'm looking for is for a simple string.IsValidJson-like method but it seems I'm out of luck

The use case is to parse a manually edited context by a user and ensure it's a valid JSON, nothing more, but need to be low allocation - no try catch

I would expect a method to be able to navigate forward only like the Utf8JsonReader until the end of the document, stopping at the first error (returning false) and without materializing that json into a JsonDocument

@bartonjs FYI TokenType is None

dotnetfiddler to play with
https://dotnetfiddle.net/ciiYVk

[alexandrehtrb]

Following that suggestion, I made the code below... is this what you guys meant?
One thing is that reader.TrySkip() throws an exception when invalid JSON

using System.Text;
using System.Text.Json;
using Xunit;

namespace MyTests;

public static class JsonUtf8ReaderTests
{
    private static bool IsValidUtf8Json(string txt, JsonReaderOptions options = default)
    {
        byte[] utf8bytes = Encoding.UTF8.GetBytes(txt);
        Utf8JsonReader reader = new(utf8bytes, options);
        try
        {
            reader.Read();
        }
        catch
        {
            return false;
        }
        try
        {
            reader.TrySkip();
        }
        catch
        {
            return false;
        }
        return true;
    }

    [Theory]
    [InlineData("{a:1}")]
    [InlineData("[{]")]
    [InlineData("'John'")]
    [InlineData("{\"John says \"Hello!\"")]
    [InlineData("$1.00")]
    [InlineData("<99.00 * 0.15")]
    [InlineData("[\"Hello\", 3.14, true, ]")]
    [InlineData("[\"Hello\", 3.14, , true]")]
    [InlineData("[\"Hello\", 3.14, true}")]
    [InlineData("[\"Hello\", 3.14, true, \"name\": \"Joe\"]")]
    [InlineData("{\"name\": \"Joe\", \"age\": null, }")]
    [InlineData("{\"name\": \"Joe\", , \"age\": null}")]
    [InlineData("{\"name\": \"Joe\", \"age\": null]")]
    [InlineData("{\"name\": \"Joe\", \"age\": }")]
    [InlineData("{\"name\": \"Joe\", \"age\" }")]
    [InlineData("{{}}")]
    public static void Should_detect_invalid_jsons(string txt) =>
        Assert.False(IsValidUtf8Json(txt));

    [Theory]
    [InlineData("{\"a\":1}")]
    [InlineData("[1]")]
    [InlineData("\"John\"")]
    [InlineData("\"John says \"Hello!\"\"")]
    [InlineData("\"$1.00\"")]
    [InlineData("\"99.00 * 0.15\"")]
    [InlineData("[\"Hello\", 3.14, true, false]")]
    [InlineData("[\"Hello\", 3.14, \"oi\", true]")]
    [InlineData("[\"Hello\", 3.14, true]")]
    [InlineData("[\"Hello\", 3.14, true, \"name\", \"Joe\"]")]
    [InlineData("{\"name\": \"Joe\", \"age\": null }")]
    [InlineData("{\"name\": \"Joe\", \"a\":123, \"age\": null}")]
    [InlineData("{\"name\": \"Joe\", \"age\": null}")]
    [InlineData("{\"name\": \"Joe\", \"age\": 14}")]
    [InlineData("{\"name\": \"Joe\", \"age\":{\"value\":14 } }")]
    [InlineData("{\"v\":{\"v\":0}}")]
    public static void Should_detect_valid_jsons(string txt) =>
        Assert.True(IsValidUtf8Json(txt));
}