#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.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

​

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

​

//https://stackoverflow.com/questions/79285045/how-can-add-comments-when-serialize-to-json

​

#nullable enable

​

public sealed class JsonCommentAttribute : JsonConverterAttribute

{

    readonly string Comment;

    public JsonCommentAttribute(string Comment) { this.Comment = Comment; }

    public override JsonConverter CreateConverter (Type typeToConvert) { return new JsonCommentConverter(Comment); }

}

​

public class JsonCommentConverter : JsonCommentConverter<object> 

{

    public JsonCommentConverter(string comment) : base(comment){ }

}

​

public class JsonCommentConverter<TBase> : DefaultConverterFactory<TBase>

{

    readonly string CommentWithDelimiters;

​

    public JsonCommentConverter(string comment) 

    { 

        this.CommentWithDelimiters = " /*" + comment + "*/";

    }

​

    protected override void Write<T>(Utf8JsonWriter writer, T value, JsonSerializerOptions modifiedOptions) 

    {

        // TODO: in .NET 9 investigate https://learn.microsoft.com/en-us/dotnet/api/microsoft.toolkit.highperformance.buffers.arraypoolbufferwriter-1 to avoid string allocations.

        var json = JsonSerializer.Serialize(value, modifiedOptions);

        writer.WriteRawValue(json + CommentWithDelimiters, skipInputValidation : true);

    }

​

    protected override JsonSerializerOptions ModifyOptions(JsonSerializerOptions options) 

    { 

        var modifiedOptions = base.ModifyOptions(options);

        modifiedOptions.WriteIndented = false;

        return modifiedOptions;

    }

}

​

public abstract class DefaultConverterFactory<TBase> : JsonConverterFactory

{

    // Adapted from this answer https://stackoverflow.com/a/78512783/3744182

    // To https://stackoverflow.com/questions/78507408/in-system-text-json-is-it-possible-to-minify-only-array-items

    class DefaultConverter<TConcrete> : JsonConverter<TConcrete> where TConcrete : TBase

    {

        readonly JsonSerializerOptions modifiedOptions;

        readonly DefaultConverterFactory<TBase> factory;

​

        public DefaultConverter(JsonSerializerOptions modifiedOptions, DefaultConverterFactory<TBase> factory) { this.modifiedOptions = modifiedOptions; this.factory = factory; }

​

        public override void Write(Utf8JsonWriter writer, TConcrete value, JsonSerializerOptions options) { factory.Write(writer, value, modifiedOptions); }

        // In .NET 9 use

        // return public override TConcrete? Read

        public override TConcrete Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { return factory.Read<TConcrete>(ref reader, typeToConvert, modifiedOptions); }

    }

​

    protected virtual JsonSerializerOptions ModifyOptions(JsonSerializerOptions options) { return options.CopyAndRemoveConverter(this.GetType()); }

​

    // In .NET 9 use

    // return public override T? Read(

    protected virtual TConcrete Read<TConcrete>(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions modifiedOptions) where TConcrete : TBase

    {

        // In .NET 9 use

        // return (T?)

        return (TConcrete)JsonSerializer.Deserialize(ref reader, typeToConvert, modifiedOptions);

    }

​

    protected virtual void Write<TConcrete>(Utf8JsonWriter writer, TConcrete value, JsonSerializerOptions modifiedOptions) where TConcrete : TBase

    { 

        JsonSerializer.Serialize(writer, value, modifiedOptions); 

    }

​

    public sealed override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) 

    { 

        var modifiedOptions =  ModifyOptions(options);

        if (typeToConvert == typeof(TBase))

            return new DefaultConverter<TBase>(modifiedOptions, this);

        else

            // In .NET 9 apply ! to the end of this line to suppress a nullable warning

            return (JsonConverter)Activator.CreateInstance(typeof(DefaultConverter<>).MakeGenericType(typeof(TBase), typeToConvert), new object [] {modifiedOptions, this });

    }

    public override bool CanConvert(Type typeToConvert) { return typeof(TBase).IsAssignableFrom(typeToConvert); }

}

​

public static partial class JsonExtensions

{

    public static JsonSerializerOptions CopyAndRemoveConverter(this JsonSerializerOptions options, Type converterType)

    {

        var copy = new JsonSerializerOptions(options);

        for (var i = copy.Converters.Count - 1; i >= 0; i--)

            if (copy.Converters[i].GetType() == converterType)

                copy.Converters.RemoveAt(i);

        return copy;

    }

}

​

#nullable disable

​

public class Person

{

    [JsonComment("Name of the person")]

    public string Name { get; set; }

​

    [JsonComment("Age of the person")]

    public int Age { get; set; }

}

​

#if USE_SOURCEGEN

​

    [JsonSerializable(typeof(Person))]

    public partial class MySerializationContext : JsonSerializerContext;

​

#endif

​

​

class TestClass

{

    public static void Test()

    {

#if USE_REFLECTION  

        TestReflection();

#endif

​

#if USE_SOURCEGEN

        TestSourceGen();

#endif

    }   

#if USE_REFLECTION  

    static void TestReflection()

    {

        var person = new Person { Name = "Jack", Age = 22 };

        var options = new JsonSerializerOptions

        {

            ReadCommentHandling = JsonCommentHandling.Skip,

            // Add other options as required, e.g.

            WriteIndented = true,

        };

​

        var json = JsonSerializer.Serialize(person, options);

        var person2 = JsonSerializer.Deserialize<Person>(json, options);

        Console.WriteLine(json);

        Assert.That(person.Age == person2?.Age);

        Assert.That(person.Name == person2?.Name);

    }   

#endif

​

#if USE_SOURCEGEN

    static void TestSourceGen()

    {

        var person = new Person { Name = "Jack", Age = 22 };

        var options = new JsonSerializerOptions

        {

            ReadCommentHandling = JsonCommentHandling.Skip,

            // Add other options as required, e.g.

            WriteIndented = true,

        };

​

        var json = JsonSerializer.Serialize(person, options);

        var person2 = JsonSerializer.Deserialize<Person>(json, options);

        Console.WriteLine(json);

        Assert.That(person.Age == person2?.Age);

        Assert.That(person.Name == person2?.Name);

    }

#endif  

}

​

​

    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;

            }

        }

    }

​