using System;

using System.Collections.Generic;

using System.Collections;

using System.Text;

using System.Linq;

//using System.Xml.Serialization;

//using System.Xml;

using System.Xml.Linq;

using System.IO;

using System.Runtime.Serialization;

using System.Reflection;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Serialization;

using Newtonsoft.Json.Converters;

​

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

​

//https://stackoverflow.com/questions/68756740/deserialization-to-poco-from-json-created-of-xml-document-does-not-work-with-arr

​

    public class ListFromDataContractXmlConverter : JsonConverter

    {

        readonly IContractResolver resolver;

​

        public ListFromDataContractXmlConverter() : this(null) { }

​

        public ListFromDataContractXmlConverter(IContractResolver resolver)

        {

            // Use the global default resolver if none is passed in.

            this.resolver = resolver ?? new JsonSerializer().ContractResolver;

        }

​

        static bool CanConvert(Type objectType, IContractResolver resolver)

        {

            Type itemType;

            JsonArrayContract contract;

            return CanConvert(objectType, resolver, out itemType, out contract);

        }

​

        static bool CanConvert(Type objectType, IContractResolver resolver, out Type itemType, out JsonArrayContract contract)

        {

            if ((itemType = objectType.GetListItemType()) == null)

            {

                itemType = null;

                contract = null;

                return false;

            }

            // Ensure that [JsonObject] is not applied to the type.

            if ((contract = resolver.ResolveContract(objectType) as JsonArrayContract) == null)

                return false;

            var itemContract = resolver.ResolveContract(itemType);

            // Not implemented for jagged arrays.

            if (itemContract is JsonArrayContract)

                return false;

            return true;

        }

​

        public override bool CanConvert(Type objectType) { return CanConvert(objectType, resolver); }

​

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

        {

            Type itemType;

            JsonArrayContract contract;

​

            if (!CanConvert(objectType, serializer.ContractResolver, out itemType, out contract))

                throw new JsonSerializationException(string.Format("Invalid type for {0}: {1}", GetType(), objectType));

            var list = (IList)(existingValue ?? contract.DefaultCreator());

            switch (reader.MoveToContentAndAssert().TokenType)

            {

                case JsonToken.Null:

                    // This is how Json.NET transcodes an empty DataContractSerializer XML list when no namespace is present.

                    break;

                case JsonToken.StartArray:

                    {

                        serializer.Populate(reader, list);

                    }

                    break;

                case JsonToken.StartObject:

                    while (reader.ReadToContentAndAssert().TokenType != JsonToken.EndObject)

                    {

                        var name = (string)reader.AssertTokenType(JsonToken.PropertyName).Value;

                        reader.ReadToContentAndAssert();

                        if (name.StartsWith("@"))

                        {

                            // It's an attribute.

                            if (!name.StartsWith("@xmlns:") && name.EndsWith("nil") && reader.TokenType == JsonToken.String && ((string)reader.Value) == "true")

                                // It's not a namespace, it's the {http://www.w3.org/2001/XMLSchema-instance}nil="true" null indicator attribute.

                                list = null;

                        }

                        else

                        {

                            // It's an element.

                            if (reader.TokenType == JsonToken.StartArray)

                                // The list had multiple items

                                serializer.Populate(reader, list);

                            else

                                // The list had a single item. This is it.

                                list.Add(serializer.Deserialize(reader, itemType));

                        }

                    }

                    break;

                default:

                    throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));

            }

            return list;

        }

​

        public override bool CanWrite => false;

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader AssertTokenType(this JsonReader reader, JsonToken tokenType) => 

            reader.TokenType == tokenType ? reader : throw new JsonSerializationException(string.Format("Unexpected token {0}, expected {1}", reader.TokenType, tokenType));

        public static JsonReader ReadToContentAndAssert(this JsonReader reader) =>

            reader.ReadAndAssert().MoveToContentAndAssert();

​

        public static JsonReader MoveToContentAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            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)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (!reader.Read())

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

            return reader;

        }

​

        public static Type GetListItemType(this Type type)

        {

            // Quick reject for performance

            if (type.IsPrimitive || type.IsArray || type == typeof(string))

                return null;

            while (type != null)

            {

                if (type.IsGenericType)

                {

                    var genType = type.GetGenericTypeDefinition();

                    if (genType == typeof(List<>))

                        return type.GetGenericArguments()[0];

                }

                type = type.BaseType;

            }

            return null;

        }

    }

​

    [DataContract(Name = "Person", Namespace = "http://schemas.datacontract.org/2004/07/Workflows.MassTransit.Hosting.Serialization")]

    public sealed class Person

    {

        [DataMember]

        public string Name { get; set; }

​

        [DataMember]

        public List<int> Numbers { get; set; }

    }

​

    [DataContract(Name = "Person", Namespace = "http://schemas.microsoft.com/2003/10/Serialization/Arrays")]

    public sealed class Person2

    {

        [DataMember(Order = 2)]

        public string Name { get; set; }

​

        [DataMember(Order = 1)]

        public List<int> Numbers { get; set; }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            Test(new Person { Name = "Test", Numbers = new List<int> { 1, 2, 3 } });

            Test(new Person { Name = "Test", Numbers = new List<int> { 1 } });

            Test(new Person { Name = "Test", Numbers = new List<int> { } });

            Test(new Person { Name = "Test", Numbers = null });

​

            Test(new Person2 { Name = "Test", Numbers = new List<int> { 1, 2, 3 } });

            Test(new Person2 { Name = "Test", Numbers = new List<int> { 1 } });

            Test(new Person2 { Name = "Test", Numbers = new List<int> { } });

            Test(new Person2 { Name = "Test", Numbers = null });

​

            Test(new List<int> { 1, 2, 3 });

            Test(new List<int> { 1 });

            Test(new List<int> {  });

​

            Test(new List<string> { "A", "B", "C" });

            Test(new List<string> { "A" });

            Test(new List<string> {  });

​

            Test(new List<Person> { new Person { Name = "Test", Numbers = new List<int> { } }, new Person { Name = "Test", Numbers = new List<int> { } } });

            Test(new List<Person> { new Person { Name = "Test", Numbers = new List<int> { } } });

            Test(new List<Person> { });

​

            // Jagged lists are not implemented, so check an exception is thrown.

            Assert.Throws<JsonSerializationException>(() => Test(new List<List<int>> { new () { 1, 2, 3 } }));

        }

        static void Test<Person>(Person person)

        {

            var xmlString = DataContractSerializerHelper.ToContractXml(person);

​

            Console.WriteLine("\nTesting {0} with XML:", person);

            Console.WriteLine(xmlString);

​

            var xelement = XElement.Parse(xmlString);

            var jsonFromXml = JsonConvert.SerializeXNode(xelement, Formatting.Indented, omitRootObject: true);

            Console.WriteLine("Intermediate JSON:");

            Console.WriteLine(jsonFromXml);

            var settings = new JsonSerializerSettings

            {

                Converters = { new ListFromDataContractXmlConverter() },

            };

            var deserializedPerson = JsonConvert.DeserializeObject<Person>(jsonFromXml, settings);

​

            var personBackJson = JsonConvert.SerializeObject(deserializedPerson, Formatting.Indented);

            Console.WriteLine("Resulting {0} re-serialized to JSON:", deserializedPerson);

            Console.WriteLine(personBackJson);

            Assert.AreEqual(JsonConvert.SerializeObject(person), JsonConvert.SerializeObject(deserializedPerson));

        }

    }

​

    public static partial class DataContractSerializerHelper

    {

        public static string ToContractXml<T>(this T obj, DataContractSerializer serializer = null, System.Xml.XmlWriterSettings settings = null)

        {

            serializer = serializer ?? new DataContractSerializer(obj == null ? typeof(T) : obj.GetType());

            using (var textWriter = new StringWriter())

            {

                settings = settings ?? new System.Xml.XmlWriterSettings { Indent = true };

                using (var xmlWriter = System.Xml.XmlWriter.Create(textWriter, settings))

                {

                    serializer.WriteObject(xmlWriter, obj);

                }

                return textWriter.ToString();

            }

        }

​

        public static T FromContractXml<T>(string xml, DataContractSerializer serializer = null)

        {

            using (var textReader = new StringReader(xml ?? ""))

            using (var xmlReader = System.Xml.XmlReader.Create(textReader))

            {

                return (T)(serializer ?? new DataContractSerializer(typeof(T))).ReadObject(xmlReader);

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  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.Location.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;

        }

    }

​