using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Text.RegularExpressions;

​

using System.Xml;

using System.Xml.Serialization;

using System.Xml.Linq;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using Xunit;

​

//https://stackoverflow.com/questions/79608961/problem-with-serializing-object-structure-with-newtonsoft-json-net

// Written using C# 6/7 syntax to be compatible with .NET Framework 4.x which is where Json.NET is still mainly used.

​

[Newtonsoft.Json.JsonConverter(typeof(FooListResponseConverter))] // I added the full namespace to clarify this is not System.Text.Json.JsonConverter

[Serializable, XmlType(AnonymousType = true), XmlRoot(Namespace = "", ElementName = "FooList", IsNullable = false)]

public class FooListResponse

{

    [XmlElement("Foo", IsNullable = false)]

    public List<Foo> FooList { get; set; }

}

​

[Serializable]

public class Foo

{

    [XmlElement("Name"), JsonProperty("Name")]

    public string Name { get; set; }

​

    [XmlElement("Color")]

    [JsonConverter(typeof(ListAsListOfObjectsWithDuplicateNameConverter<string>), 

                   new object [] { "Color" })]

    public List<string> Colors { get; set; }

}

​

public class FooListResponseConverter : WrappedListAsListOfObjectsWithDuplicateNameConverter<FooListResponse, Foo>

{

    public FooListResponseConverter() : base("Foo") { }

}

​

public class WrappedListAsListOfObjectsWithDuplicateNameConverter<TWrapper, TItem> : JsonConverter<TWrapper> where TWrapper : new()

{

    // Apply when you have a wrapper object containing a single List<TItem> property which is serialized as an object with a single property whose value 

    // is an object with repeating property names that is wrapped in some container array:

    readonly string name;

    public WrappedListAsListOfObjectsWithDuplicateNameConverter(string name) 

    {

        if (name == null)

            throw new ArgumentNullException("name");

        this.name = name;

    }

​

    static void GetContractAndProperty(JsonSerializer serializer, Type objectType, out JsonObjectContract contract, out JsonProperty property)

    {

        var c = serializer.ContractResolver.ResolveContract(objectType);

        if (!(c is JsonObjectContract))

            throw new JsonSerializationException(string.Format("Contract for {0} was of wrong type {1}", objectType, c.GetType()));

        contract = (JsonObjectContract)c;

        property = contract.Properties.Where(p => !p.Ignored).Single();

        if (!typeof(List<TItem>).IsAssignableFrom(property.PropertyType))

            throw new JsonSerializationException(string.Format("Invalid type {0} for property {1}", property.PropertyType, property.UnderlyingName));

    }

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

    {

        JsonObjectContract contract;

        JsonProperty property;

        GetContractAndProperty(serializer, typeof(TWrapper), out contract, out property);

        if (value == null)

        {

            writer.WriteNull();

            return;

        }

        JsonExtensions.WriteListAsListOfObjectsWithDuplicateName<TItem>(writer, (List<TItem>)property.ValueProvider.GetValue(value), serializer, name);

    }

​

    public override TWrapper ReadJson(JsonReader reader, Type objectType, TWrapper existingValue, bool hasExistingValue, JsonSerializer serializer)

    {

        JsonObjectContract contract;

        JsonProperty property;

        GetContractAndProperty(serializer, typeof(TWrapper), out contract, out property);

        var existingListValue = hasExistingValue && existingValue != null 

            ? (List<TItem>)property.ValueProvider.GetValue(existingValue)

            : null;

        var list = JsonExtensions.ReadListAsListOfObjectsWithDuplicateName<TItem>(reader, property.PropertyType, existingListValue, serializer, name);

        var value = hasExistingValue && existingValue != null ? existingValue : (TWrapper)contract.DefaultCreator();

        property.ValueProvider.SetValue(value, list);

        return value;

    }

}

​

public class ListAsListOfObjectsWithDuplicateNameConverter<T> : JsonConverter<List<T>>

{

    // Apply when you have a List<T> which is serialized as a single object with repeating property names that is wrapped in some container array:

    readonly string name;

    public ListAsListOfObjectsWithDuplicateNameConverter(string name) 

    {

        if (name == null)

            throw new ArgumentNullException("name");

        this.name = name;

    }

​

    public override void WriteJson(JsonWriter writer, List<T> value, JsonSerializer serializer)

    {

        JsonExtensions.WriteListAsListOfObjectsWithDuplicateName<T>(writer, value, serializer, name);

    }

​

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

    {

        return JsonExtensions.ReadListAsListOfObjectsWithDuplicateName<T>(reader, objectType, existingValue, serializer, name);

    }

}

​

public class ListAsObjectWithDuplicateNameConverter<T> : JsonConverter<List<T>>

{

    // Apply when you have a List<T> which is serialized as a single object with repeating property names

    readonly string name;

    public ListAsObjectWithDuplicateNameConverter(string name) 

    {

        if (name == null)

            throw new ArgumentNullException("name");

        this.name = name;

    }

​

    public override void WriteJson(JsonWriter writer, List<T> value, JsonSerializer serializer)

    {

        JsonExtensions.WriteListAsObjectWithDuplicateName<T>(writer, value, serializer, name);

    }

​

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

    {

        return JsonExtensions.ReadListAsObjectWithDuplicateName<T>(reader, objectType, existingValue, serializer, name);

    }

}

​

public static partial class JsonExtensions

{

    static List<T> CreateList<T>(Type objectType, List<T> existingValue, JsonSerializer serializer)

    {

        return existingValue ?? (objectType == typeof(List<T>) 

                                 ? new List<T>() 

                                 : (List<T>)serializer.ContractResolver.ResolveContract(objectType).DefaultCreator());

    }

    public static void WriteListAsListOfObjectsWithDuplicateName<T>(JsonWriter writer, List<T> value, JsonSerializer serializer, string name)

    {

        if (value == null)

        {

            writer.WriteNull();

            return;

        }

        writer.WriteStartArray();

        WriteListAsObjectWithDuplicateName<T>(writer, value, serializer, name);

        writer.WriteEndArray();

    }

    public static List<T> ReadListAsListOfObjectsWithDuplicateName<T>(JsonReader reader, Type objectType, List<T> existingValue, JsonSerializer serializer, string name)

    {

        if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)

            return null;

        else if (reader.TokenType != JsonToken.StartArray)

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

        var list = CreateList(objectType, existingValue, serializer);

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

            // When an existing list is passed in, ReadListAsObjectWithDuplicateName() appends to it.

            ReadListAsObjectWithDuplicateName<T>(reader, objectType, list, serializer, name);

        return list;

    }

    public static void WriteListAsObjectWithDuplicateName<T>(JsonWriter writer, List<T> value, JsonSerializer serializer, string name)

    {

        if (value == null)

        {

            writer.WriteNull();

            return;

        }

        writer.WriteStartObject();

        foreach (var foo in value)

        {

            writer.WritePropertyName(name);

            serializer.Serialize(writer, foo);

        }

        writer.WriteEndObject();

    }

​

    public static List<T> ReadListAsObjectWithDuplicateName<T>(JsonReader reader, Type objectType, List<T> existingValue, JsonSerializer serializer, string name)

    {

        if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)

            return null;

        else if (reader.TokenType != JsonToken.StartObject)

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

        var list = CreateList(objectType, existingValue, serializer);

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

        {

            if (reader.TokenType != JsonToken.PropertyName)

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

            var propertyName = (string)reader.Value;

            reader.ReadAndAssert();

            if (!string.Equals(name, propertyName, StringComparison.OrdinalIgnoreCase))

            {

                // TODO: decide whether to skip the values of unexpected property names, or throw an exception.

                // reader.Skip();

                throw new JsonSerializationException(string.Format("Unexpected property name {0}", propertyName));

            }

            else

                list.Add(serializer.Deserialize<T>(reader));

        }

        return list;

    }

​

    public static JsonReader ReadToContentAndAssert(this JsonReader reader)

    {

        return reader.ReadAndAssert().MoveToContentAndAssert();

    }

​

    public static JsonReader MoveToContentAndAssert(this JsonReader reader)

    {

        if (reader == null)

            throw new ArgumentNullException("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)

    {

        if (reader == null)

            throw new ArgumentNullException("reader");

        if (!reader.Read())

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

        return reader;

    }

}

​

​

    class TestClass

    {

        public static void Test()

        {

            TestXml();

            Console.WriteLine();

            TestJson();

            Console.WriteLine();

​

            TestNull();

            Console.WriteLine(GetRequiredJson());

        }   

​

        static void TestJson()

        {

            var inputXml = GetXml();

            var fooListResponse = inputXml.LoadFromXml<FooListResponse>();

            var json = JsonConvert.SerializeObject(fooListResponse, Newtonsoft.Json.Formatting.Indented);

            var fooListResponse2 = JsonConvert.DeserializeObject<FooListResponse>(json);

            var json2 = JsonConvert.SerializeObject(fooListResponse2, Newtonsoft.Json.Formatting.Indented);

            Console.WriteLine("Re-serialized {0}:", fooListResponse);

            Console.WriteLine(json);

            Assert.Equal(json, json2);

            Assert.Equal(fooListResponse.FooList.Count, 2);

            Assert.True(json2.ReplaceWhitespace() == GetRequiredJson().ReplaceWhitespace());

        }

        public static void TestXml()

        {

            var inputXml = GetXml();

            var fooListResponse = inputXml.LoadFromXml<FooListResponse>();

            var xml = fooListResponse.GetXml(omitStandardNamespaces : true);

            Console.WriteLine("Re-serialized {0}:", fooListResponse);

            Console.WriteLine(xml);

​

            Assert.Equal(XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(inputXml)), true);

​

            Assert.Equal(fooListResponse.FooList.Count, 2);

        }

​

        static void TestNull()

        {

            var tests = new []

            {

                "[]",

                "[null]",

                "[{}]",

                "[{},null,{}]",

            };

            foreach (var json in tests)

            {

                var fooListResponse = JsonConvert.DeserializeObject<FooListResponse>(json);

                Assert.Equal(0, fooListResponse.FooList.Count);

                Console.WriteLine(JsonConvert.SerializeObject(fooListResponse));

            }

        }

        static string GetXml()

        {

            return @"<?xml version=""1.0"" encoding=""utf-8""?>

<FooList>

    <Foo>

        <Name>George</Name>

        <Color>Blue</Color>

        <Color>Yellow</Color>

    </Foo>

    <Foo>

        <Name>Betty</Name>

        <Color>Green</Color>

    </Foo>

</FooList>";

        }

        static string GetRequiredJson()

        {

            return @"[

  {

    ""Foo"": {

      ""Name"": ""George"",

      ""Colors"": [ { ""Color"": ""Blue"", ""Color"": ""Yellow"" } ]

    },

    ""Foo"": {

      ""Name"": ""Betty"",

      ""Colors"": [ { ""Color"": ""Green"" } ]

    }

  }

]";

        }

    }

​

    public static class StringExtensions

    {

        //https://stackoverflow.com/a/6219488

        //https://stackoverflow.com/questions/6219454/efficient-way-to-remove-all-whitespace-from-string

        private static readonly Regex sWhitespace = new Regex(@"\s+");

        public static string ReplaceWhitespace(this string input, string replacement = "") 

        {

            return sWhitespace.Replace(input, replacement);

        }

    }

​

    public static class XmlSerializationHelper

    {

        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)

        {

            serial = serial ?? new XmlSerializer(typeof(T));

            using (var reader = new StringReader(xmlString))

            {

                return (T)serial.Deserialize(reader);

            }

        }

​

        public static string GetXml<T>(this T obj, XmlSerializer serializer = null, bool omitStandardNamespaces = false)

        {

            XmlSerializerNamespaces ns = null;

            if (omitStandardNamespaces)

            {

                ns = new XmlSerializerNamespaces();

                ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.

            }           

            using (var textWriter = new StringWriter())

            {

                var settings = new XmlWriterSettings() { Indent = true }; // For cosmetic purposes.

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

                    (serializer ?? new XmlSerializer(obj.GetType())).Serialize(xmlWriter, obj, ns);

                return textWriter.ToString();

            }

        }

    }

​

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("{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;

            }

        }

    }

​