using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.Collections.Concurrent;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using Microsoft.VisualStudio.Extensibility.UI;

​

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

​

using R3;

​

//https://stackoverflow.com/questions/78770520/json-net-how-to-serialize-and-deserialize-custom-types-in-custom-way

​

​

public class TestData

{

    public List<Resource> resourceList = new();

    public ObservableList<Resource> observableResourceList = new();

    public ReactiveProperty<int> number = new ();

    public ReactiveProperty<string> word = new ();

    public ReactiveProperty<string> anotherWord = new (); // Added for testing purposes

    public ReactiveProperty<string> nullInitially; // Added for testing purposes

    public ReactiveProperty<int> nullIntInitially; // Added for testing purposes

    public ReactiveProperty<int?> nullNullableIntInitially; // Added for testing purposes

​

    public TestData() { }

​

    public static TestData Create() =>

        new ()

        {

            resourceList = { new Resource("banana", 10), new Resource("apple", 3) },

            observableResourceList = { new Resource("oBanana", 5), new Resource("oApple", 2) },

            number = new ReactiveProperty<int>(9),

            word = new ReactiveProperty<string>("word string"),

        };

}

​

public class Resource

{

    public readonly string Name;

    public ReactiveProperty<int> Count;

​

    public Resource(string name, int count)

    {

        Name = name;

        Count = new ReactiveProperty<int>(count);

    }

}

​

#nullable enable

​

/*===============*/

​

public class ReactivePropertyJsonConverter<T> : JsonConverter<ReactiveProperty<T>>

{

    public override ReactiveProperty<T>? ReadJson(JsonReader reader, Type objectType, ReactiveProperty<T>? existingValue, bool hasExistingValue, JsonSerializer serializer)

    {

        var isNull = reader.MoveToContentAndAssert().TokenType == JsonToken.Null;

        if (isNull && typeof(T).IsValueType && Nullable.GetUnderlyingType(typeof(T)) == null)

            return null;

        var innerValue = !isNull ? serializer.Deserialize<T>(reader) : default(T);

        if (hasExistingValue && existingValue != null)

            existingValue.Value = (innerValue ?? default(T))!;

        else if (objectType == typeof(ReactiveProperty<T>))

            existingValue = innerValue == null ? new() : new(innerValue!);

        else

            // ReactiveProperty<T> was subclassed, use parameterized constructor.

            existingValue = innerValue == null 

                ? (ReactiveProperty<T>)Activator.CreateInstance(objectType)!

                // Here we assume the subclass has a parameterized constructor taking the value as a a single argument.

                : (ReactiveProperty<T>)Activator.CreateInstance(objectType, innerValue)!;

        return existingValue;

    }

​

    public override void WriteJson(JsonWriter writer, ReactiveProperty<T>? value, JsonSerializer serializer) => 

        serializer.Serialize(writer, value == null ? default(T?) : value.Value);

}

​

public static partial class JsonExtensions

{

    public static JsonReader MoveToContentAndAssert(this JsonReader reader)

    {

        ArgumentNullException.ThrowIfNull(reader);

        if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.

            reader.ReadAndAssert();

        while (reader.TokenType == JsonToken.Comment) // Skip past comments.

            reader.ReadAndAssert();

        return reader;

    }

​

    public static JsonReader ReadAndAssert(this JsonReader reader)

    {

        ArgumentNullException.ThrowIfNull(reader);

        if (!reader.Read())

            throw new JsonReaderException("Unexpected end of JSON stream.");

        return reader;

    }

}

​

/*==============*/

​

public class ReactivePropertyJsonConverter : JsonConverter

{

    static readonly ConcurrentDictionary<Type, JsonConverter> Converters = new();

​

    static JsonConverter CreateReactivePropertyConverterOfT(Type valueType) =>

        (JsonConverter)Activator.CreateInstance(typeof(ReactivePropertyJsonConverter<>).MakeGenericType(valueType))!;

​

    static JsonConverter GetReactivePropertyConverterOfT(Type valueType) =>

        Converters.GetOrAdd(valueType, CreateReactivePropertyConverterOfT);

​

    static Type? GetReactivePropertyValueType(Type objectType) =>

        objectType.BaseTypesAndSelf().Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ReactiveProperty<>)).FirstOrDefault()?.GetGenericArguments()[0];

    public override bool CanConvert(Type objectType) => GetReactivePropertyValueType(objectType) != null;

​

    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer) => 

        GetReactivePropertyConverterOfT(GetReactivePropertyValueType(objectType)!).ReadJson(reader, objectType, existingValue, serializer);

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

    {

        if (value == null)

            writer.WriteNull();

        else

            GetReactivePropertyConverterOfT(GetReactivePropertyValueType(value.GetType())!).WriteJson(writer, value, serializer);

    }

}

​

public static partial class JsonExtensions

{

    public static IEnumerable<Type> BaseTypesAndSelf(this Type type)

    {

        while (type != null)

        {

            yield return type;

            type = type.BaseType!;

        }

    }

}

​

/*=====================================================*/

​

public class DataStorageAgent

{

    static UTF8Encoding DefaultEncoding { get; } = new UTF8Encoding(false, true);   

    static JsonSerializerSettings DefaultSettings { get; } = new ()

    {

        Converters = { new ReactivePropertyJsonConverter() },

        Formatting = Formatting.Indented,

    };

​

    public T? Load<T>(string saveFilePath) where T : class

    {

        try

        {

            using var textReader = new StreamReader(saveFilePath, DefaultEncoding);

            using var jsonReader = new JsonTextReader(textReader);

            return JsonSerializer.CreateDefault(DefaultSettings).Deserialize<T>(jsonReader);

        }

        catch (Exception ex)

        {

            Debug.LogError(ex);

            return default(T);

        }

    }

​

    public void Save(object saveData, string saveFilePath)

    {

        using var textWriter = new StreamWriter(saveFilePath, false, DefaultEncoding);

        JsonSerializer.CreateDefault(DefaultSettings).Serialize(textWriter, saveData);

    }

}

​

static class Debug 

{

    public static void LogError(object s) => Console.WriteLine(s);

}

​

    class TestClass

    {

        public static void Test()

        {

            string fileName = "Question78770520.json";

            var testData = TestData.Create();

​

            var agent = new DataStorageAgent();

            agent.Save(testData, fileName);

            var json = File.ReadAllText(fileName);

            Console.WriteLine(json);

            var test2 = agent.Load<TestData>(fileName);

            agent.Save(test2!, fileName);

            var json2 = File.ReadAllText(fileName);

​

            if (json != json2)

                Console.WriteLine(json2);

​

            Assert.That(json == json2);

            File.Delete(fileName);

        }   

    }

​

    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("{0} version: {1}", typeof(JsonSerializer).Namespace, typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine("{0} version: {1}", typeof(R3.ReactiveProperty<>).Namespace, typeof(R3.ReactiveProperty<>).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​