JSON contract modifiers cannot be used with source generation

[TomEdwardsEnscape]

Description

It does not appear to be possible to customise JSON contracts with modifiers at the same time as using System.Text.Json source generation. A workaround is available but is extremely limited, functioning only in the most trivial of cases.

Reproduction Steps

Execute ReproCase.SerialiseWithModifiers from the code below. It should throw an exception, but it does not because the modifier is not executed.

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization.Metadata;

namespace JsonReproCase;

[JsonSerializable(typeof(ReproCase))]

internal partial class JsonContext : JsonSerializerContext;

public class ReproCase
{
    public static void SerialiseWithModifiers()
    {
        var contextWithModifiers = new JsonContext(new JsonSerializerOptions
        {
            TypeInfoResolver = JsonContext.Default.WithAddedModifier(DoStuff),
        });
        JsonSerializer.Serialize(new ReproCase(), contextWithModifiers.ReproCase);
    }

    private static void DoStuff(JsonTypeInfo info)
    {
        throw new Exception("Stuff was done");
    }
}

Expected behavior

It must be possible to add modifiers to a source-generated JsonContext at the same time as configuring other options. I would expect the code given above to achieve this.

It is not enough to add modifiers to the source generated context class. It must be possible to define them per operation at runtime.

Actual behavior

The constructor of JsonSerializerContext forcibly overwrites JsonSerializerOptions.TypeInfoResolver with itself. All appended modifiers are lost.

Regression?

No response

Known Workarounds

A workaround has been suggested on StackOverflow. Unfortunately this solution only works on the top-level JsonTypeInfo object, and child objects still don't see the modifier. I've not been able to find the offending line but it seems likely that JsonTypeInfo.OriginatingResolver is involved, because this points to the "raw" source-generated resolver.

Configuration

.Net 9

Other information

No response

[eiriktsarpalis]

The overwriting behavior of JsonSerializerContext predates contract customization and cannot be changed today. I would suggest avoiding use of JsonSerializerContext altogether, just construct a JsonSerializerOptions with applied modifiers and pass that instance directly to JsonSerializer.

[eiriktsarpalis]

Sadly I have found that it only works for the top-level object (or perhaps type?)

That should not be the case. Do you have a repro showing this?

[TomEdwardsEnscape]

I've worked out why only the top-level object was processed: you need to use the object returned by WithAddedModifier twice, like this:

var contextWithModifier = JsonContext.Default.WithAddedModifier(DoStuff);
var typeInfo = (JsonTypeInfo<ReproCase>)contextWithModifier
    .GetTypeInfo(typeof(ReproCase), options: new() { TypeInfoResolver = contextWithModifier })!;

I was previously setting options to the JsonSerializerOptions object already present in our method, which we really ought to use. Since that's not possible we instead have to merge it and the modifier-bearing type resolver together, which means manually copying all values to a new options object because MakeReadOnly might have been called on the one we already have and it's not a struct or record...ugh.

I have given up on trying to use this system. Diving into the deserialised data structure to manually make the adjustments I need has proved to be considerably less of a hassle.

[eiriktsarpalis]

I've worked out why only the top-level object was processed: you need to use the object returned by WithAddedModifier twice, like this:

Again, this shouldn't be the case. If you could provide a standalone minimal repro we might be able to provide guidance.

[TomEdwardsEnscape]

using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization.Metadata;

namespace JsonReproCase;

[JsonSerializable(typeof(ReproCase))]

internal partial class JsonContext : JsonSerializerContext;

public class ReproCase
{
    public ChildType? ChildObject { get; set; }

    public static void SerialiseWithModifiers()
    {
        var contextWithModifier = JsonContext.Default.WithAddedModifier(DoStuff);
        var typeInfo = (JsonTypeInfo<ReproCase>)contextWithModifier
            .GetTypeInfo(typeof(ReproCase), options: JsonSerializerOptions.Default)!;

        JsonSerializer.Serialize(new ReproCase { ChildObject = new() { Value = 4 } }, typeInfo);
    }

    private static void DoStuff(JsonTypeInfo info)
    {
        Debug.WriteLine(info.Type);
    }
}

public class ChildType
{
    public int Value { get; set; }
}

[eiriktsarpalis]

This is not applying the modifier everywhere because you're calling the IJsonTypeInfoResolver directly with JsonSerializerOptions.Default. Try changing it to this:

using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization.Metadata;

[JsonSerializable(typeof(ReproCase))]

internal partial class JsonContext : JsonSerializerContext;

public class ReproCase
{
    public ChildType? ChildObject { get; set; }

    public static void Main()
    {
        JsonSerializerOptions options = new() { TypeInfoResolver = JsonContext.Default.WithAddedModifier(DoStuff) };
        var typeInfo = options.GetTypeInfo(typeof(ReproCase));
        JsonSerializer.Serialize(new ReproCase { ChildObject = new() { Value = 4 } }, typeInfo);
    }

    private static void DoStuff(JsonTypeInfo info)
    {
        Debug.WriteLine(info.Type);
    }
}

public class ChildType
{
    public int Value { get; set; }
}

[theoractice]

I am in a similar situation: an Encoder must be passed to JsonSerializerOptions to avoid unicode character escaping, but I cannot find a way to do this when building with nativeaot.
Repro with System.Text.Json 9.0:

using System.Text.Json;
using System.Text.Json.Serialization;

namespace NativeAotDev;

public class Config
{
    public string Version { get; set; } = "中文";
}

public partial class Program
{
    [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase, WriteIndented = true)]
    [JsonSerializable(typeof(Config))]
    public partial class ConfigJsonContext : JsonSerializerContext { }

    static void Main(string[] args)
    {
        var config = new Config();
        var json = JsonSerializer.Serialize(config, ConfigJsonContext.Default.Config);
        // json = Regex.Unescape(json);
        Console.WriteLine(json);
    }
}

Of course I can use Regex.Unescape to unescape the serialized string, but the key point is that not everything can be configured via source generator and the generated JsonSerializerOptions is marked as readonly so it cannot be modified:

        public partial class ConfigJsonContext
        {
            private readonly static global::System.Text.Json.JsonSerializerOptions s_defaultOptions = new()
            {
                PropertyNamingPolicy = global::System.Text.Json.JsonNamingPolicy.CamelCase,
                WriteIndented = true,
            };
        ...

Edit: as @eiriktsarpalis said above, now I found the solution:

        private static JsonSerializerOptions Options = new()
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = true,
            Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(UnicodeRanges.All),
            TypeInfoResolver = AppBarJsonContext.Default
        };
...

var json = JsonSerializer.Serialize(config, Options.GetTypeInfo(typeof(Config)));