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

​

[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"), JsonProperty("Color")]

    public string Color { get; set; }

}

​

public class FooListResponseConverter : JsonConverter<FooListResponse>

{

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

    {

        var list = value == null ? null : value.FooList;

        if (list == null)

        {

            // TODO: decide what to do for a null list.  Maybe write an empty array?

            writer.WriteNull();

            return;

        }

        writer.WriteStartArray();

        writer.WriteStartObject();

        foreach (var foo in list)

        {

            writer.WritePropertyName("Foo"); // in more current C# versions, use nameof(FooListDeserializationDto.Foo)

            serializer.Serialize(writer, foo);

        }

        writer.WriteEndObject();

        writer.WriteEndArray();

    }

​

    class FooListDeserializationDto

    {

        [JsonIgnore] public readonly List<Foo> FooList = new List<Foo>();

        // Here we take advantage of the fact that, if Json.NET encounters duplicated property names during deserialization, it will call the setter multiple times.

        public Foo Foo { set { FooList.Add(value); } }

    }

​

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

    {

        var dtoList = serializer.Deserialize<List<FooListDeserializationDto>>(reader);

        if (dtoList == null)

        {

            // TODO: decide what to do for a null list.  Maybe return an empty FooListResponse?

            return null;

        }

        var list = dtoList.Count == 1 

             ? dtoList[0].FooList

             : dtoList.SelectMany(d => d.FooList).ToList();

        var fooListResponse = existingValue ?? new FooListResponse();

        fooListResponse.FooList = list;

        return fooListResponse;

    }

}

​

    class TestClass

    {

        public static void Test()

        {

            TestXml();

            Console.WriteLine();

            TestJson();

        }   

​

        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 string GetXml()

        {

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

<FooList>

    <Foo>

        <Name>George</Name>

        <Color>Blue</Color>

    </Foo>

    <Foo>

        <Name>Betty</Name>

        <Color>Green</Color>

    </Foo>

</FooList>";

        }

        static string GetRequiredJson()

        {

            return @"[

  {

    ""Foo"": {

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

      ""Color"": ""Blue""

    },

    ""Foo"": {

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

      ""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;

            }

        }

    }

​