using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Buffers;

​

using System.Text.Json;

using System.Text.Json.Serialization;

​

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

​

//How to deserialize an object with known and unknown property names, and typed values?

//https://stackoverflow.com/questions/60192534/deserialise-json-iin-c-sharp-using-system-text-json-with-complex-property-name

//https://stackoverflow.com/questions/40088941/how-to-deserialize-a-child-object-with-dynamic-numeric-key-names

//https://dotnetfiddle.net/pxxZBn

​

    class Users

    {

        [JsonPropertyName("parentname")]

        public string ParentName { get; set; }

​

        [JsonIgnore]

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

        [JsonExtensionData]

        // A setter required by JsonSerializer even for preallocated dictionaries, and even though it's not called.  https://github.com/dotnet/runtime/issues/32197

        public IDictionary<string, JsonElement> ExtensionData { get => UserTable.ToExtensionDictionary(); set => throw new NotImplementedException(); }

    }

​

    public class User

    {

        public string name { get; set; }

        public string state { get; set; }

        public string id { get; set; }

    }

​

    public static partial class JsonExtensions

    {

        public static IDictionary<string, JsonElement> ToExtensionDictionary<TValue>(this IDictionary<string, TValue> dictionary, JsonSerializerOptions options = null)

        {

            if (dictionary == null)

                throw new ArgumentNullException();

            return new DictionaryValueAdapter<string, TValue, JsonElement>(dictionary, e => e.ToObject<TValue>(options), v => JsonElementFromObject(v, options));

        }

        // Taken from this answer https://stackoverflow.com/a/59047063/3744182

        // To https://stackoverflow.com/questions/58138793/system-text-json-jsonelement-toobject-workaround

        // These may be obsolete in System.Text.Json 5.0, see https://github.com/dotnet/runtime/issues/31274

        public static T ToObject<T>(this JsonElement element, JsonSerializerOptions options = null)

        {

            var bufferWriter = new ArrayBufferWriter<byte>();

            using (var writer = new Utf8JsonWriter(bufferWriter))

                element.WriteTo(writer);

            return JsonSerializer.Deserialize<T>(bufferWriter.WrittenSpan, options);

        }

​

        public static T ToObject<T>(this JsonDocument document, JsonSerializerOptions options = null)

        {

            if (document == null)

                throw new ArgumentNullException(nameof(document));

            return document.RootElement.ToObject<T>(options);

        }       

        public static JsonDocument JsonDocumentFromObject<T>(T item, JsonSerializerOptions options = null)

        {

            var bytes = JsonSerializer.SerializeToUtf8Bytes(item, options);

            return JsonDocument.Parse(new ReadOnlyMemory<byte>(bytes));

        }

        public static JsonElement JsonElementFromObject<T>(T item, JsonSerializerOptions options = null)

        {

            using var doc = JsonDocumentFromObject(item, options);

            return doc.RootElement.Clone();

        }

    }

    // A minimal implementation sufficient for adapting a typed dictionary for use by JsonExtensionData

    public class DictionaryValueAdapter<TKey, TValueIn, TValueOut> : IDictionary<TKey, TValueOut>, IDictionary 

    {

        public IDictionary<TKey, TValueIn> Dictionary { get; }

        readonly Func<TValueOut, TValueIn> toInner;

        readonly Func<TValueIn, TValueOut> toOuter;

​

        public DictionaryValueAdapter(IDictionary<TKey, TValueIn> dictionary, Func<TValueOut, TValueIn> toInner, Func<TValueIn, TValueOut> toOuter)

        {

            this.Dictionary = dictionary ?? throw new ArgumentNullException(nameof(dictionary));

            this.toInner = toInner ?? throw new ArgumentNullException(nameof(toInner));

            this.toOuter = toOuter ?? throw new ArgumentNullException(nameof(toOuter));

        }

​

        // The key and value collections could be implemented using a similar collection adapter pattern.

        // See e.g. ReadOnlyCollectionAdapter<TIn, TOut> from this answer https://stackoverflow.com/a/24356662/3744182

        // to https://stackoverflow.com/questions/24356083/c-sharp-cast-list-of-mytype-to-list-of-objects

​

        #region IDictionary<TKey,TValueOut> Members

        public bool TryGetValue(TKey key, out TValueOut value)

        {

            if (Dictionary.TryGetValue(key, out var inner))

            {

                value = toOuter(inner);

                return true;

            }

            value = default(TValueOut);

            return false;

        }

        public void Add(TKey key, TValueOut value) => Dictionary.Add(key, toInner(value));

        public bool ContainsKey(TKey key) => Dictionary.ContainsKey(key);

        public ICollection<TKey> Keys => Dictionary.Keys; 

        public bool Remove(TKey key) => Dictionary.Remove(key);

        public TValueOut this[TKey key] { get => toOuter(Dictionary[key]); set => Dictionary[key] = toInner(value); }

        public ICollection<TValueOut> Values => throw new NotImplementedException(); // TODO

        #endregion

        #region ICollection<KeyValuePair<TKey,TValueOut>> Members

​

        public void Add(KeyValuePair<TKey, TValueOut> item) => Dictionary.Add(new KeyValuePair<TKey, TValueIn>(item.Key, toInner(item.Value)));

        public void Clear() => Dictionary.Clear();

        public bool Contains(KeyValuePair<TKey, TValueOut> item) => Dictionary.Contains(new KeyValuePair<TKey, TValueIn>(item.Key, toInner(item.Value)));

        public int Count => Dictionary.Count;

        public bool IsReadOnly => Dictionary.IsReadOnly;

        public bool Remove(KeyValuePair<TKey, TValueOut> item) => Dictionary.Remove(new KeyValuePair<TKey, TValueIn>(item.Key, toInner(item.Value)));

        public void CopyTo(KeyValuePair<TKey, TValueOut>[] array, int arrayIndex) => throw new NotImplementedException(); // TODO

​

        #endregion

        #region IEnumerable<KeyValuePair<TKey,TValueOut>> Members

​

        public IEnumerator<KeyValuePair<TKey, TValueOut>> GetEnumerator() => Dictionary.Select(p => new KeyValuePair<TKey, TValueOut>(p.Key, toOuter(p.Value))).GetEnumerator();

​

        #endregion

        #region IEnumerable Members

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();

​

        #endregion

        #region IDictionary Members // JsonExtensionData requires the dictionary to implement IDictionary (not documented).

        void IDictionary.Add(object key, object value) => Add((TKey)key, (TValueOut)value);

        bool IDictionary.Contains(object key) => ContainsKey((TKey)key);

        object IDictionary.this[object key] { get => this[(TKey)key]; set => this[(TKey)key] = (TValueOut)value; }

        IDictionaryEnumerator IDictionary.GetEnumerator() => new DictionaryEnumerator<TKey, TValueOut>(this.GetEnumerator());

        void IDictionary.Remove(object key) => Remove((TKey)key);

        bool IDictionary.IsFixedSize => false; // TODO

        ICollection IDictionary.Keys => throw new NotImplementedException(); // TODO

        ICollection IDictionary.Values => throw new NotImplementedException(); // TODO

        #endregion

        #region ICollection Members

        void ICollection.CopyTo(Array array, int index) => throw new NotImplementedException(); // TODO

        bool ICollection.IsSynchronized => false; // TODO

        object ICollection.SyncRoot => throw new NotImplementedException(); // TODO

        #endregion

    }

    public class DictionaryEnumerator<TKey, TValue> : IDictionaryEnumerator

    {

        // Adapted from this answer https://stackoverflow.com/a/29085259 

        // To https://stackoverflow.com/questions/29084989/how-do-you-implement-the-idictionaryenumerator-getenumerator-method-in-idict

        // By https://stackoverflow.com/users/613130/xanatos

        // by upgrading c# syntax to .Net Core 3

        public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator) => this.Enumerator = enumerator ?? throw new ArgumentNullException();

​

        readonly IEnumerator<KeyValuePair<TKey, TValue>> Enumerator;

​

        public DictionaryEntry Entry => new DictionaryEntry(Enumerator.Current.Key, Enumerator.Current.Value);

        public object Key => Enumerator.Current.Key;

        public object Value => Enumerator.Current.Value;

        public object Current => Entry;

        public bool MoveNext() => Enumerator.MoveNext();

        public void Reset() => Enumerator.Reset();

    }

​

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

​

            var options = new JsonSerializerOptions { WriteIndented = true };

            var users1 = JsonSerializer.Deserialize<Users>(json, options);

            Assert.AreEqual(3, users1.UserTable.Count);

            var json2 = JsonSerializer.Serialize(users1, options);

            Console.WriteLine(json2);

            Assert.IsTrue(Newtonsoft.Json.Linq.JToken.DeepEquals(Newtonsoft.Json.Linq.JToken.Parse(json), Newtonsoft.Json.Linq.JToken.Parse(json2)), "JToken.DeepEquals");

​

            var users2 = JsonSerializer.Deserialize<Users>(json2, options);

            users2.UserTable.Add("Foo User", new User { name = "foo name" });

​

            var json3 = JsonSerializer.Serialize(users2, options);

            var users3 = JsonSerializer.Deserialize<Users>(json3, options);

            Assert.AreEqual(4, users3.UserTable.Count);

​

            var json4 = JsonSerializer.Serialize(users3, options);

            Console.WriteLine(json4);

            Assert.AreEqual(json3, json4);

            Assert.IsTrue(users1.UserTable.Keys.SequenceEqual(users3.UserTable.Keys.Take(users1.UserTable.Keys.Count)));

            Assert.IsTrue(users1.UserTable.Values.Select(v => v.name).SequenceEqual(users3.UserTable.Values.Select(v => v.name).Take(users1.UserTable.Keys.Count)));

        }   

        static string GetJson()

        {

            var json = @"{

        ""parentname"":""test"",

        ""100034"" : {

            ""name""  : ""tom"",

            ""state"" : ""WA"",

            ""id""    : ""cedf-c56f-18a4-4b1""

        },

        ""10045"" : {

            ""name""  : ""steve"",

            ""state"" : ""NY"",

            ""id""    : ""ebb2-92bf-3062-7774""

        },

        ""12345"" : {

            ""name""  : ""mike"",

            ""state"" : ""MA"",

            ""id""    : ""fb60-b34f-6dc8-aaf7""

        }

    }";

            return json;

        }   

    }

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine(string.Format("{0} version: {1}", typeof(JsonSerializer).Namespace, typeof(JsonSerializer).Assembly.FullName));

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​