I'm using System.Text.Json and I want to intercept the instances that gets created when I'm deserializing

Question

I want to deserialize a JSON file into a List<Person> and I want to intercept the instances of Person that gets created (not the instance of List<Person> but this might be helpful too) is it possible to do it by implementing a custom IJsonTypeInfoResolver or deriving from DefaultJsonTypeInfoResolver?

I've tried to derive from DefaultJsonTypeInfoResolver and create a custom resolver by overriding GetTypeInfo but I'm not sure how to get the created instances of Person.

I've checked some of the properties and methods on JsonTypeInfo through debugging but I couldn't really understand what I should do or how I should use the API and the documentation seems lacking for my specific case, unfortunately.

Here is an example:

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
    TypeInfoResolver = new JsonPersonResolver()
};

options.Converters.Add(new JsonDateTimeConverter());
options.Converters.Add(new JsonDateOnlyConverter());
options.Converters.Add(new JsonColorConverter());
options.Converters.Add(new JsonDecimalConverter());

var people = await JsonSerializer.DeserializeAsync<List<Person>>(stream, options);

sealed record Person
{
    public string FullName { get; set; }
    public int Age { get; set; }
}

sealed class JsonCustomResolver : DefaultJsonTypeInfoResolver
{
    public override JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions options)
    {
        var info = base.GetTypeInfo(type, options);

        // Do what?

        return info;
    }
}

Answer 1

You can get a callback every time an instance of Person is created by adding a DefaultJsonTypeInfoResolver modifier that invokes a custom OnDeserializing or OnDeserialized callback for the Person type.

First, define the following extension methods for DefaultJsonTypeInfoResolver:

public static class JsonExtensions
{
    public static DefaultJsonTypeInfoResolver AddOnDeserializing<T>(this DefaultJsonTypeInfoResolver resolver, Action<T> onDeserializing)
    {
        resolver.Modifiers.Add(typeInfo => 
                               {
                                   if (typeof(T) == typeInfo.Type) // Or typeof(T).IsAssignableFrom(typeinfo.Type) if you prefer
                                   {
                                       if (typeInfo.OnDeserializing == null)
                                           typeInfo.OnDeserializing = (o) => onDeserializing((T)o);
                                       else
                                       {
                                           var old = typeInfo.OnDeserializing;
                                           typeInfo.OnDeserializing = (o) => { old(o); onDeserializing((T)o); };
                                       }
                                   }
                               });
        return resolver;
    }
    public static DefaultJsonTypeInfoResolver AddOnDeserialized<T>(this DefaultJsonTypeInfoResolver resolver, Action<T> onDeserialized)
    {
        resolver.Modifiers.Add(typeInfo => 
                               {
                                   if (typeof(T) == typeInfo.Type) // Or typeof(T).IsAssignableFrom(typeinfo.Type) if you prefer
                                   {
                                       if (typeInfo.OnDeserialized == null)
                                           typeInfo.OnDeserialized = (o) => onDeserialized((T)o);
                                       else
                                       {
                                           var old = typeInfo.OnDeserialized;
                                           typeInfo.OnDeserialized = (o) => { old(o); onDeserialized((T)o); };
                                       }
                                   }
                               });
        return resolver;
    }
}

Now you will be able to capture the creation of all Person objects wherever they are created in your deserialized object graph by adding an appropriate Action<Person>:

List<Person> allPeopleCreatedAnywhere = new();
Action<Person> personCreated = p => { Console.WriteLine("Intercepted persion {0}", p); allPeopleCreatedAnywhere.Add(p); };
var options = new JsonSerializerOptions
{
    TypeInfoResolver = new DefaultJsonTypeInfoResolver()
        // Use AddOnDeserializing if you want to intercept the Person before it is populated
        // Use AddOnDeserialized if you want to intercept the Person after it is populated.
        .AddOnDeserialized(personCreated)
        // Add other modifiers as required
        ,
    // Add other settings and converters as required
    PropertyNameCaseInsensitive = true,
};

var people = await JsonSerializer.DeserializeAsync<List<Person>>(stream, options);

Console.WriteLine("A total of {0} people were intercepted.", allPeopleCreatedAnywhere.Count);  

Notes:

• As explained in the docs:

  Serialization callbacks are only supported for Object metadata.

  Thus you will only be able to get intercept instances of c# types that are serialized as JSON objects. If you try to intercept instances of types serialized as JSON arrays such as List<Person> or primitives such as DateTime with this technique, System.Text.Json will throw an exception.

• I recommended this approach because it doesn't require a converter, and it works with objects that have parameterized constructors. An alternative might be to chain something to JsonTypeInfo.CreateObject, however that wouldn't work with parameterized constructors.

Demo fiddle here.