#define USE_REFLECTION

//#define USE_SOURCEGEN

#if false

dotnet new console

dotnet add package NUnit

//Edit CSPROJ file and add:

    <PublishAot>true</PublishAot>

    <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>

//To  <PropertyGroup>

dotnet build -c Debug   

// Then modify USE_REFLECTION and USE_SOURCEGEN as required

​

#endif

​

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Threading;

using System.Diagnostics.CodeAnalysis;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

​

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

​

//https://stackoverflow.com/questions/56835040/net-core-3-0-jsonserializer-populate-existing-object

​

#nullable enable

​

    public static partial class JsonExtensions

    {

        public static void PopulateObject<T>(ReadOnlySpan<char> json, T value, JsonSerializerContext context) where T : class

        {

            ArgumentNullException.ThrowIfNull(context);

            PopulateObject(json, value, context, t => context.GetTypeInfo(t));

        }

​

        [RequiresUnreferencedCode("Use the method JsonExtensions.PopulateObject<T>(string json, T value, JsonSerializerContext context) instead")]

        [RequiresDynamicCode("Use the method JsonExtensions.PopulateObject<T>(string json, T value, JsonSerializerContext context) instead")]

        public static void PopulateObject<T>(ReadOnlySpan<char> json, T value, JsonSerializerOptions? options = default) where T : class

        {

            options = options ?? JsonSerializerOptions.Default;

            var originalResolver = options.TypeInfoResolver 

                ?? (JsonSerializer.IsReflectionEnabledByDefault 

                    ? new DefaultJsonTypeInfoResolver() : throw new JsonException("Reflection-based serialization is disabled, please use an explicit JsonSerializerContext"));

            PopulateObject(json, value, originalResolver, t => originalResolver.GetTypeInfo(t, options));

        }

        [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2026:RequiresUnreferencedCode",

            Justification = "The required warning was emitted for public static void PopulateObject<T>(string json, T value, JsonSerializerOptions? options = default)")]

        [UnconditionalSuppressMessage("AOT", "IL3050:RequiresDynamicCode", 

            Justification = "The required warning was emitted for public static void PopulateObject<T>(string json, T value, JsonSerializerOptions? options = default)")]

        static void PopulateObject<T>(ReadOnlySpan<char> json, T value, IJsonTypeInfoResolver originalResolver, Func<Type, JsonTypeInfo?> getOriginalTypeInfo) where T : class

        {

            ArgumentNullException.ThrowIfNull(value);

            ArgumentNullException.ThrowIfNull(originalResolver);

​

            if (value is IList list && list.IsFixedSize)

                throw new JsonException($"Fixed size lists of type {value.GetType()} cannot be populated with {nameof(JsonExtensions.PopulateObject)}<{typeof(T).Name}>()");

            var declaredType = typeof(T) == typeof(object) ? value.GetType() : typeof(T);

            var originalTypeInfo = getOriginalTypeInfo(declaredType);

            if (originalTypeInfo == null)

                throw new JsonException($"No JsonTypeInfo was generated for type {declaredType}");

            if (originalTypeInfo.Kind is JsonTypeInfoKind.None)

                throw new JsonException($"Object of type {value.GetType()} (kind {originalTypeInfo.Kind}) cannot be populated with {nameof(JsonExtensions.PopulateObject)}<{typeof(T).Name}>()");

            var originalOptions = originalTypeInfo.Options;

            JsonSerializerOptions populateOptions = new (originalOptions)

            {

                PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate,

                TypeInfoResolver = originalResolver

                    .WithAddedModifier(new RootObjectInjector<T>(value).WithRootObjectCreator)

                    .WithAddedModifier(PopulateProperties),

            };

​

            try

            {

                populateOptions.MakeReadOnly();

                if (populateOptions.GetTypeInfo(declaredType) == null)

                    throw new JsonException($"Object of type {declaredType} cannot be populated with {nameof(JsonExtensions.PopulateObject)}<{typeof(T).Name}>() using {originalResolver}");

                var returnedValue = JsonSerializer.Deserialize(json, declaredType, populateOptions);

                if (returnedValue is not null && !object.ReferenceEquals(returnedValue, value))

                    throw new JsonException($"A different object was returned for {returnedValue}");

            }

            catch (Exception ex)

            {

                throw new JsonException($"Object of type {declaredType} cannot be populated with {nameof(JsonExtensions.PopulateObject)}<{typeof(T).Name}>() using {originalResolver}", ex);

            }

        }

        class RootObjectInjector<T> where T : class

        {

            readonly Type valueType;

            T? value;

            public RootObjectInjector(T value) => (this.value, this.valueType) = (value ?? throw new ArgumentNullException(nameof(value)), valueType = value.GetType());

            internal void WithRootObjectCreator(JsonTypeInfo typeInfo)

            {

                if (valueType.IsAssignableTo(typeInfo.Type))

                {

                    var oldCreateObject = typeInfo.CreateObject;

                    typeInfo.CreateObject = () =>

                        Interlocked.Exchange(ref this.value, null) is {} rootValue 

                            ? rootValue : (oldCreateObject is not null ? oldCreateObject() : throw new JsonException($"No default creator exists for {typeInfo.Type}."));

                }

            }

        }

        static void PopulateProperties(JsonTypeInfo typeInfo) 

        {

            // Set PreferredPropertyObjectCreationHandling unless explicitly set by attributes

            if (typeInfo.Kind == JsonTypeInfoKind.Object)

                typeInfo.PreferredPropertyObjectCreationHandling ??= JsonObjectCreationHandling.Populate;

        }

    }

​

    public class ComplexModel

    {

        public ComplexModel? NestedModel { get; set; }

        public List<string> Strings { get; set; } = new();

        public Inner Inner { get; set; } = new();

    }

​

    public class Inner

    {

        public List<int> Integers { get; set; } = new();

        public Dictionary<string, string> Dictionary { get; } = new();

    };

​

    public record ImmutableModel(List<string> Strings, Inner Inner);

​

    public record RecursiveImmutableModel(List<string> Strings, RecursiveImmutableModel? Inner = null);

​

#if USE_SOURCEGEN

​

    [JsonSerializable(typeof(Model))]

    [JsonSerializable(typeof(ComplexModel))]

    [JsonSerializable(typeof(ImmutableModel))]

    [JsonSerializable(typeof(RecursiveImmutableModel))]

    [JsonSerializable(typeof(List<int>))]

    [JsonSerializable(typeof(Dictionary<string, string>))]

    [JsonSerializable(typeof(int))]

    [JsonSerializable(typeof(string))]

    [JsonSerializable(typeof(IConvertible))]

    public partial class MySerializationContext : JsonSerializerContext;

​

#endif

​

    public abstract class JsonSerializerTester

    {

        public abstract string Serialize<TValue>(TValue value);

​

        public abstract void PopulateObject<TValue>(string json, TValue value) where TValue : class;

    }

​

#if USE_REFLECTION

    public class ReflectionJsonSerializerTester(JsonSerializerOptions? options) : JsonSerializerTester

    {

        public override string Serialize<TValue>(TValue value) => JsonSerializer.Serialize(value, options);

​

        public override void PopulateObject<TValue>(string json, TValue value) where TValue : class =>

            JsonExtensions.PopulateObject<TValue>(json, value, options);

    }

#endif

​

    public class SourceGenerationsonSerializerTester(JsonSerializerContext context) : JsonSerializerTester

    {

        public override string Serialize<TValue>(TValue value) => JsonSerializer.Serialize(value, typeof(TValue), context);

​

        public override void PopulateObject<TValue>(string json, TValue value) where TValue : class =>

            JsonExtensions.PopulateObject<TValue>(json, value, context);

    }

​

    // The model from https://stackoverflow.com/questions/56835040/net-core-3-0-jsonserializer-populate-existing-object

​

    public class Model

    {

        public string? Title { get; set; }

        public string? Link { get; set; }

        public string? Head { get; set; }

    }

​

    partial class TestClass

    {

        public static void Test()

        {

#if USE_REFLECTION

            TestModel();

            Console.WriteLine();

            Test(new ReflectionJsonSerializerTester(new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }), true);

#endif

#if USE_SOURCEGEN

            TestModelSourceGen();

            Console.WriteLine();

​

            Test(new SourceGenerationsonSerializerTester(MySerializationContext.Default), false);

#endif

        }

​

#if USE_REFLECTION

        public static void TestModel()

        {

            var model = new Model();

​

            var json1 = """{"Title": "Startpage", "Link": "/index" }""";

            var json2 = """{"Head": "Latest news", "Link": "/news" }""";

            var options = new JsonSerializerOptions

            {

                // Add whatever options here you want, e.g.

                PropertyNameCaseInsensitive = true,

                WriteIndented = true,

            };

            JsonExtensions.PopulateObject(json1, model, options);

            JsonExtensions.PopulateObject(json2, model, options);

            var newJson = JsonSerializer.Serialize(model, options);

​

            var expectedJson =  """

                                {

                                    "Title": "Startpage",

                                    "Head": "Latest news",

                                    "Link": "/news"

                                }               

                                """;

            Assert.That(JsonNode.DeepEquals(JsonNode.Parse(newJson), JsonNode.Parse(expectedJson))); // Passes

            Console.WriteLine(newJson);

        }

#endif

#if USE_SOURCEGEN

        [JsonSerializable(typeof(Model))]

        public partial class ModelSerializationContext : JsonSerializerContext;

        public static void TestModelSourceGen()

        {

            var model = new Model();

​

            var json1 = """{"Title": "Startpage", "Link": "/index" }""";

            var json2 = """{"Head": "Latest news", "Link": "/news" }""";

            JsonExtensions.PopulateObject(json1, model, ModelSerializationContext.Default);

            JsonExtensions.PopulateObject(json2, model, ModelSerializationContext.Default);

            var newJson = JsonSerializer.Serialize(model, ModelSerializationContext.Default.Model);

​

            var expectedJson = 

                """

                {

                    "Title": "Startpage",

                    "Head": "Latest news",

                    "Link": "/news"

                }               

                """;

            Assert.That(JsonNode.DeepEquals(JsonNode.Parse(newJson), JsonNode.Parse(expectedJson))); // Passes

            Console.WriteLine(newJson);

        }

#endif

        static void Test(JsonSerializerTester tester, bool immutableShouldWork = true)

        {

            TestModel(tester);

            Console.WriteLine();

            TestComplexModel(tester);

            Console.WriteLine();

            TestImmutable(tester);

            Console.WriteLine();

            TestList(tester);

            Console.WriteLine();

            TestDictionary(tester);

            Console.WriteLine();

​

            TestArray(tester);

            Console.WriteLine();

​

            TestString(tester);

            Console.WriteLine();

​

            TestInt(tester);

            Console.WriteLine();

​

            TestIConvertibleInt(tester);

            Console.WriteLine();

​

            if (immutableShouldWork)

            {

                TestRecursiveImmutable(tester);

            }

            else

            {

                // This will fail in source gen mode with the error:

                // System.Text.Json.JsonException: Object of type RecursiveImmutableModel cannot be populated with PopulateObject<RecursiveImmutableModel>() using MySerializationContext

                // ---> System.InvalidOperationException: Setting init-only properties is not supported in source generation mode.

                var ex = Assert.Throws<JsonException>(() => TestRecursiveImmutable(tester));

                Console.WriteLine("Caught expected exception when testing RecursiveImmutableModel: {0}", ex?.Message);

            }

            Console.WriteLine();

​

            TestWhenCreateObjectIsUsed();

            Console.WriteLine();

        }   

​

        public static void TestModel(JsonSerializerTester tester)

        {

            var model = new Model();

​

            var json1 = """{"title": "Startpage", "link": "/index" }""";

            var json2 = """{"head": "Latest news", "link": "/news" }""";

            tester.PopulateObject(json1, model);

            tester.PopulateObject(json2, model);

            var newJson = tester.Serialize(model);

​

            var expectedJson = 

                """

                {

                    "title": "Startpage",

                    "head": "Latest news",

                    "link": "/news"

                }               

                """;

            Assert.That(JsonNode.DeepEquals(JsonNode.Parse(newJson), JsonNode.Parse(expectedJson))); // Passes

            Console.WriteLine(newJson);

        }

        static void TestRecursiveImmutable(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing {0}:", nameof(RecursiveImmutableModel));

            RecursiveImmutableModel original = new(["a", "b"], new(["y", "z"]));

            var json = tester.Serialize(original);

            Console.WriteLine(json);

            RecursiveImmutableModel populated = new(new(), new(new()));

            var strings = populated.Strings;

            var inner = populated.Inner;

            var innerStrings = inner!.Strings;

            var innerInner= inner!.Inner;

            tester.PopulateObject(json, populated);

​

            Assert.That(strings == populated.Strings);

            Assert.That(inner == populated.Inner);

            Assert.That(innerStrings == populated.Inner?.Strings); 

            Assert.That(innerInner == populated.Inner?.Inner); 

        }

        static void TestImmutable(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing {0}:", nameof(ImmutableModel));

            var original = new ImmutableModel(["a", "b"], new() { Integers = [1, 2], Dictionary = {{"a", "a"}, {"b", "b" }} });

​

            var json = tester.Serialize(original);

            Console.WriteLine(json);

            var populated = new ImmutableModel(new(), new());

            var strings = populated.Strings;

            var inner = populated.Inner;

            var innerIntegers = inner.Integers;

            var innerDictionary = inner.Dictionary;

            tester.PopulateObject(json, populated);

            Assert.That(strings == populated.Strings);

            Assert.That(inner == populated.Inner);

            Assert.That(innerIntegers == populated.Inner?.Integers); 

            Assert.That(innerDictionary == populated.Inner?.Dictionary); 

            var json2 = tester.Serialize(populated);

            Assert.That(json == json2);

        }

        static void TestComplexModel(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing {0}:", nameof(ComplexModel));

            var original = new ComplexModel

            {

                NestedModel = new() { Strings = ["z"] },

                Strings = ["a", "b"],

            };

            original.Inner.Integers.Add(1);

            original.Inner.Dictionary.Add("a", "b");

            var json = tester.Serialize(original);

            Console.WriteLine(json);

            var populated = new ComplexModel { NestedModel = new() };

            var strings = populated.Strings;

            var nested = populated.NestedModel;

            var nestedStrings = nested.Strings;

            var inner = populated.Inner;

            var innerIntegers = inner.Integers;

            var innerDictionary = inner.Dictionary;

            tester.PopulateObject(json, populated);

            Assert.That(strings == populated.Strings);

            Assert.That(nested == populated.NestedModel);

            Assert.That(nestedStrings == populated.NestedModel?.Strings);

            Assert.That(inner == populated.Inner);

            Assert.That(innerIntegers == populated.Inner?.Integers); 

            Assert.That(innerDictionary == populated.Inner?.Dictionary); 

            var json2 = tester.Serialize(populated);

            Assert.That(json == json2);

        }

        static void TestDictionary(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing Dictionary<string, string>:");

​

            Dictionary<string, string> original = new() { {"a", "a"}, {"b", "b" }};

            var json = tester.Serialize(original);

            Console.WriteLine(json);

            Dictionary<string, string> populated = new();

            tester.PopulateObject(json, populated);

            Assert.That(populated.Count == original.Count);

            Assert.That(populated.SequenceEqual(original));

        }

        static void TestList(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing List<int>:");

​

            List<int> list = new();

            tester.PopulateObject("[0, 1, 2]", list);

            Assert.That(list.SequenceEqual([0, 1, 2]));

            Console.WriteLine("   Test passed.");

        }

        static void TestWhenCreateObjectIsUsed()

        {

#if USE_REFLECTION

            if (!JsonSerializer.IsReflectionEnabledByDefault)

                return;

            Box<int> counter = new();

            HashSet<object> returnedValues = new();

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver()

                    .WithAddedModifier(JsonExtensions.WithDebugCreator(counter, returnedValues)),

            };

            var list = JsonSerializer.Deserialize<List<int>>("[1, 2, 3]", options);

            Assert.That(returnedValues.Contains(list!));

            var collection = JsonSerializer.Deserialize<ObservableCollection<int>>("[1, 2, 3]", options);

            Assert.That(returnedValues.Contains(collection!));

#endif

        }

        static void TestArray(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing int [] array:");

​

            int [] array = new int [3];

            var ex = Assert.Throws<JsonException>(() => tester.PopulateObject("[0, 1, 2]", array));

            Console.WriteLine("   Failed as expected with message: \"{0}\".", ex?.Message);

        }

​

        static void TestString(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing string:");

​

            var ex = Assert.Throws<JsonException>(() => tester.PopulateObject("\"hello\"", "some string"));

            Console.WriteLine("   Failed as expected with message: \"{0}\".", ex?.Message);

        }

​

        static void TestInt(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing string:");

​

            object obj = default(int);

            var ex = Assert.Throws<JsonException>(() => tester.PopulateObject("32", obj));

            Console.WriteLine("   Failed as expected with message: \"{0}\".", ex?.Message);

        }

​

        static void TestIConvertibleInt(JsonSerializerTester tester)

        {

            Console.WriteLine("Testing string:");

​

            IConvertible obj = default(int);

            var ex = Assert.Throws<JsonException>(() => tester.PopulateObject<IConvertible>("32", obj));

            Console.WriteLine("   Failed as expected with message: \"{0}\".", ex?.Message);

        }

    }

​

    public class Box<T> where T : struct

    {

        public T Value;

    }

​

    public static partial class JsonExtensions

    {

        public static Action<JsonTypeInfo> WithDebugCreator(Box<int> counter, HashSet<object> returnedValues) => typeInfo =>

        {

            var oldCreateObject = typeInfo.CreateObject;

            if (oldCreateObject != null)

            {

                typeInfo.CreateObject = () =>

                {

                    Console.WriteLine($"Custom CreateObject() called for type {typeInfo.Type}, count = {++counter.Value}");

                    var obj = oldCreateObject();

                    returnedValues.Add(obj);

                    return obj;

                };

            }

        };

    }

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine("System.Text.Json version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​