using System;

using System.Collections.Generic;

using Newtonsoft.Json;

​

using BF = System.Reflection.BindingFlags;

​

namespace demo {

    public class Program {

        public static void Main() {

            Foo foo = new Foo {

                name = "root",

                va = 1,

                child = new Foo {

                    name = "root.child",

                    va = 2,

                },

            };

​

            // Show default serialization

            var settingsStock = new JsonSerializerSettings { Formatting = Formatting.Indented, };

            var jsonRef = JsonConvert.SerializeObject(foo, settingsStock);

            Console.WriteLine($"Default:\n{jsonRef}");

            // Mutated serialization/deserialization

            var settingsMutating = new JsonSerializerSettings {

                Formatting = Formatting.Indented,

                Converters = new List<JsonConverter> { new demo_serializer.FooConverter() },

            };

            var jsonMutated = JsonConvert.SerializeObject(foo, settingsMutating);

            Console.WriteLine($"Mutated:\n{jsonMutated}");

            var fooRestored = JsonConvert.DeserializeObject<Foo>(jsonMutated, settingsMutating);

            var jsonRestored = JsonConvert.SerializeObject(fooRestored, settingsStock);

            Console.WriteLine($"Restored:\n{jsonRestored}");

            if (jsonRestored.Length != jsonRef.Length)

                Console.WriteLine($"len mismatch {jsonRestored.Length} vs {jsonRef.Length}");

            for (int i = 0; i < jsonRef.Length; i++) {

                if (jsonRestored[i] != jsonRef[i]) {

                    Console.WriteLine($"mismatch at {i}, {jsonRestored[i].ToString()} vs {jsonRef[i].ToString()}, context=\n{jsonRef.Substring(0, i - 1)}");

                    break;

                }

            }

            if (jsonRestored != jsonRef)

                throw new ApplicationException();

        }

    }

    public class Foo {

        public string name;

        public int va;

        public Foo child;

    }

}

​

namespace demo_serializer {

    public class FooConverter : sample.InPlaceMutateConverter {

        public override bool CanConvert(Type objectType) { return objectType == typeof(demo.Foo); }

​

        protected override object MutateOnRead(object value) { return MutateAfterDeserialize((demo.Foo)value); }

​

        protected override object MutateOnWrite(object value, out bool typeWillMatchSelf) {

            typeWillMatchSelf = true;

            return MutateBeforeSerialize((demo.Foo)value);

        }

​

        demo.Foo MutateAfterDeserialize(demo.Foo foo) {

            if (foo is null)

                return null;

            if (foo.va % 100 == 0) {

                foo.va /= 100;

            } else {

                foo.va = (foo.va + 1) / 100;

            }

            return foo;

        }

        demo.Foo MutateBeforeSerialize(demo.Foo foo) {

            if (foo.va % 2 == 0) {

                return new demo.Foo { name = foo.name, va = foo.va * 100 };

            } else {

                foo.va = foo.va * 100 - 1;

                return foo;

            }

        }

    }

}

​

namespace sample {

    public class SerializerContext {

        public void peekWriter(JsonSerializer serializerProxy) {

            if (writer != null) return;

            if (verifySerializerProxy(serializerProxy)) {

                writer = serializerProxy.GetType().GetField("_serializerWriter", BF.Instance | BF.NonPublic).GetValue(serializerProxy);

                objectsStack = (List<object>)writer.GetType().GetField("_serializeStack", BF.Instance | BF.NonPublic).GetValue(writer);

            }

        }

​

        public void peekReader(JsonSerializer serializerProxy) {

            if (reader != null) return;

            if (verifySerializerProxy(serializerProxy)) {

                reader = serializerProxy.GetType().GetField("_serializerReader", BF.Instance | BF.NonPublic).GetValue(serializerProxy);

            }

        }

​

        public bool verifySerializerProxy(JsonSerializer serializerProxy) {

            var assembly = typeof(JsonSerializer).Assembly;

            var serializerProxyType = assembly.GetType("Newtonsoft.Json.Serialization.JsonSerializerProxy");

            return serializerProxyType != null && serializerProxyType.IsInstanceOfType(serializerProxy);

        }

​

        public object reader = null!; // internal Newtonsoft.Json.Serialization.JsonSerializerInternalReader

        public object writer = null!; // internal Newtonsoft.Json.Serialization.JsonSerializerInternalWriter

        public List<object> objectsStack = null!; // JsonSerializerInternalWriter._serializeStack

    }

    // In-place mutate/transform converter. Useful if new value maybe in same type, or maybe same object.

    public abstract class InPlaceMutateConverter : JsonConverter {

        public override bool CanRead {

            get {

                // Avoid next recurse to self

                if (avoidNextRecurse) {

                    avoidNextRecurse = false;

                    return false;

                } else {

                    return canRead;

                }

            }

        }

​

        public override bool CanWrite {

            get {

                // Avoid next recurse to self

                if (avoidNextRecurse) {

                    avoidNextRecurse = false;

                    return false;

                } else {

                    return canWrite;

                }

            }

        }

​

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) {

            serializerContext.peekReader(serializer);

            Type newObjectType = GetOutputTypeOnRead(objectType, existingValue, out avoidNextRecurse);

            object value = serializer.Deserialize(reader, newObjectType)!;

            return MutateOnRead(value);

        }

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {

            if (objectsStack == null) {

                serializerContext.peekWriter(serializer);

                objectsStack = serializerContext.objectsStack;

            }

            object newValue = MutateOnWrite(value, out avoidNextRecurse);

            // To defeat circular check

            if (newValue == value)

                objectsStack.Remove(objectsStack.Count - 1);

            serializer.Serialize(writer, newValue);

            // Restore stack

            if (newValue == value)

                objectsStack.Add(value);

        }

​

        protected virtual Type GetOutputTypeOnRead(Type objectType, object existingValue, out bool typeWillMatchSelf) {

            typeWillMatchSelf = true;

            return objectType;

        }

        protected virtual object MutateOnRead(object value) { return value; }

        // typeWillMatchSelf should be true, if converter will recurse to self: value type will still hit self.

        protected virtual object MutateOnWrite(object value, out bool typeWillMatchSelf) {

            typeWillMatchSelf = true;

            return value;

        }

​

        protected bool canRead = true;

        protected bool canWrite = true;

        protected SerializerContext serializerContext = new SerializerContext();

        List<object> objectsStack = null!;

        protected bool avoidNextRecurse = false;

    }

}