Is there an equivalent for JRaw in System.Text.Json

Question

I'm migrating an ASP.NET Core 2 application to ASP.NET Core 3. My controllers need to return objects that have a property which is already a JSON string, so it looks something like this:

public class Thing {
    public int Id { get; set; }
    public string Name { get; set; }
    public string Data { get; set; } // JSON Data
}

var thing = new Thing
{
    Id = 1,
    Name = "Thing",
    Data = "{\"key\":\"value\"}"
};

Thing should be serialized so that the Data property is not a string, but part of the JSON object. Like this:

{
    "id": 1,
    "name": "Thing",
    "data": {
        "key": "value"
    }
}

In .NET Core 2 and Newtonsoft.Json I used JRaw as the type for Data, so the serializer knew that the property is already serialized as JSON and didn't try to represent it as a string.

.NET Core 3 uses System.Text.Json, which is incompatible with JRaw. Is there an equivalent that does the same thing? I was able to use JsonElement as the type for Data and convert the string with JsonDocument.Parse(jsonString).RootElement. This produces the desired result, but I'd like to avoid an unnecessary deserialize+serialize step, since the data object may be relatively big.

Answer 1

.NET 6 has introduced Utf8JsonWriter.WriteRawValue(string json, bool skipInputValidation = false):

Writes the input as JSON content. It is expected that the input content is a single complete JSON value. ...

When writing untrusted JSON values, do not set skipInputValidation to true as this can result in invalid JSON being written, or an invalid overall payload being written to the writer instance.

Thus you can now introduce the following converters:

/// <summary>
/// Serializes the contents of a string value as raw JSON.  The string is validated as being an RFC 8259-compliant JSON payload
/// </summary>
public class RawJsonConverter : JsonConverter<string>
{
    public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        using var doc = JsonDocument.ParseValue(ref reader);
        return doc.RootElement.GetRawText();
    }

    protected virtual bool SkipInputValidation => false;

    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) =>
        // skipInputValidation : true will improve performance, but only do this if you are certain the value represents well-formed JSON!
        writer.WriteRawValue(value, skipInputValidation : SkipInputValidation);
}

/// <summary>
/// Serializes the contents of a string value as raw JSON.  The string is NOT validated as being an RFC 8259-compliant JSON payload
/// </summary>
public class UnsafeRawJsonConverter : RawJsonConverter
{
    protected override bool SkipInputValidation => true;
}

And apply the converter of your choice to your data model:

public class Thing {
    public int Id { get; set; }
    public string Name { get; set; }
    [JsonConverter(typeof(UnsafeRawJsonConverter))]
    public string Data { get; set; } // JSON Data
}

Notes:

• Utf8JsonReader does not appear to have an equivalent method to read a raw value of any type, so JsonDocument is still required to deserialize a raw JSON value.

• Utf8JsonWriter.WriteRawValue(null) and Utf8JsonWriter.WriteRawValue("null") generate identical JSON, namely null. When deserialized, doc.RootElement.GetRawText() seems to return a null value for both, rather than a string containing the token null.

• You seem to be concerned about performance, so I applied UnsafeRawJsonConverter to your data model. However, you should only use this converter if you are certain that Data contains well-formed JSON. If not, use RawJsonConverter:

   [JsonConverter(typeof(RawJsonConverter))]
   public string Data { get; set; } // JSON Data
  

• In .NET 5 and earlier WriteRawValue() does not exist, so you will have to parse the incoming string to a JsonDocument and write that:

   public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
   {
       using var doc = JsonDocument.Parse(value);
       doc.WriteTo(writer);
   }
  

  This of course checks that value is well-formed; there is no ability to write raw JSON and skip input validation in earlier releases.

Demo fiddle here.