using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Threading.Tasks;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/74875289/im-using-system-text-json-and-i-want-to-intercept-the-instances-that-gets-creat

​

//#nullable enable

​

    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;

        }

    }

​

    sealed record Person

    {

        public string FullName { get; set; }

        public int Age { get; set; }

    }

​

    public class Program

    {

        public static async Task Test()

        {

            Action<List<Person>> listCreated = l => { Console.WriteLine("Created list {0}", l); }; // System.Text.Json throws an exception if I try to add this modifier

​

            var list = new List<Person> { new Person { FullName = "John Doe", Age = 101 }, new Person { FullName = "Alice Bob", Age = 99 } };

            using var stream = new MemoryStream();

            await JsonSerializer.SerializeAsync(stream, list);

            stream.Position = 0;

            List<Person> allPeopleCreatedAnywhere = new();

            Action<Person> personCreated1 = p => allPeopleCreatedAnywhere.Add(p);

            Action<Person> personCreated2 = p => Console.WriteLine("Intercepted persion {0}", p);

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver()

                    // Use AddOnDeserializing if you want to incercept the Person before it is populated

                    // Use AddOnDeserialized if you want to intercept the Person after it is populated.

                    .AddOnDeserialized(personCreated1)

                    .AddOnDeserialized(personCreated2)

                    // 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);  

            Assert.AreEqual(list.Count, allPeopleCreatedAnywhere.Count);

        }

        public static async Task Main(string[] args)

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version);

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                await Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​