questions/50471935/serialize-a-list-of-objects-inheriting-from-class-a-to-xml-so-the-names-of-the | C# Online Compiler

questions/50471935/serialize-a-list-of-objects-inheriting-from-class-a-to-xml-so-the-names-of-the by dbc_MinLength

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.IO;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;

// https://stackoverflow.com/questions/50471935/serialize-a-list-of-objects-inheriting-from-class-a-to-xml-so-the-names-of-the

    public class RootObject
    {
        public AListObject AList { get; set; }
    }

    public class AListObject
    {
        public List<A> SerializedListObjects { get; set; }
    }

    public class A
    {
    }

    public class B : A
    {
    }

    public class C : A
    {
    }

    public class D : C
    {
    }

    public class ComplexRootObject
    {
        public MidObjectDerived MidObject { get; set; }
    }

    public class MidObject
    {
        public List<A> SerializedListObjects { get; set; }

        public List<A> AnotherSerializedListObjects { get; set; }
    }

    public class MidObjectDerived : MidObject
    {
        public List<A> DerivedSerializedListObjects { get; set; }
    }

    public interface IXmlSerializerFactory
    {
        XmlSerializer CreateSerializer(Type rootType);
    }

    public static class AListSerializerFactory
    {
        static readonly XmlArrayItemTypeOverrideSerializerFactory instance;

        static AListSerializerFactory()
        {
            // Include here a list of all types that have a List<A> property.
            // You could use reflection to find all such public types in your assemblies.
            var declaringTypeList = new []
            {
                typeof(AListObject),
            };

            // Include here a list of all base types with a corresponding mapping 
            // to find all derived types in runtime.   Here you could use reflection
            // to find all such types in your assemblies, as shown in 
            // https://stackoverflow.com/questions/857705/get-all-derived-types-of-a-type
            var derivedTypesList = new Dictionary<Type,  Func<IEnumerable<Type>>>
            {
                { typeof(A), () => new [] { typeof(B), typeof(C) } },
            };
            instance = new XmlArrayItemTypeOverrideSerializerFactory(declaringTypeList, derivedTypesList);
        }

        public static IXmlSerializerFactory Instance { get { return instance; } }
    }

    public class XmlArrayItemTypeOverrideSerializerFactory : IXmlSerializerFactory
    {
        // To avoid a memory & resource leak, the serializers must be cached as explained in
        // https://stackoverflow.com/questions/23897145/memory-leak-using-streamreader-and-xmlserializer

        readonly object padlock = new object();
        readonly Dictionary<Type, XmlSerializer> serializers = new Dictionary<Type, XmlSerializer>();
        readonly XmlAttributeOverrides overrides;

        public XmlArrayItemTypeOverrideSerializerFactory(IEnumerable<Type> declaringTypeList, IEnumerable<KeyValuePair<Type, Func<IEnumerable<Type>>>> derivedTypesList)
        {
            var completed = new HashSet<Type>();
            overrides = declaringTypeList
                .SelectMany(d => derivedTypesList.Select(p => new { declaringType = d, itemType = p.Key, derivedTypes = p.Value() }))
                .Aggregate(new XmlAttributeOverrides(), (a, d) => a.AddXmlArrayItemTypes(d.declaringType, d.itemType, d.derivedTypes, completed));
        }

        public XmlSerializer CreateSerializer(Type rootType)
        {
            lock (padlock)
            {
                XmlSerializer serializer;
                if (!serializers.TryGetValue(rootType, out serializer))
                    serializers[rootType] = serializer = new XmlSerializer(rootType, overrides);
                return serializer;
            }
        }
    }

    public static partial class XmlAttributeOverridesExtensions
    {
        public static XmlAttributeOverrides AddXmlArrayItemTypes(this XmlAttributeOverrides overrides, Type declaringType, Type itemType, IEnumerable<Type> derivedTypes)
        {
            return overrides.AddXmlArrayItemTypes(declaringType, itemType, derivedTypes, new HashSet<Type>());
        }

        public static XmlAttributeOverrides AddXmlArrayItemTypes(this XmlAttributeOverrides overrides, Type declaringType, Type itemType, IEnumerable<Type> derivedTypes, HashSet<Type> completedTypes)
        {
            if (overrides == null || declaringType == null || itemType == null || derivedTypes == null || completedTypes == null)
                throw new ArgumentNullException();
            XmlAttributes attributes = null;
            for (; declaringType != null && declaringType != typeof(object); declaringType = declaringType.BaseType)
            {
                // Avoid duplicate overrides.
                if (!completedTypes.Add(declaringType))
                    break;
                foreach (var property in declaringType.GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance))
                {
                    // Skip the property if already ignored
                    if (property.IsDefined(typeof(XmlIgnoreAttribute), false))
                        continue;
                    
                    // See if it is a list property, and if so, get its type.
                    var propertyItemType = property.PropertyType.GetListType();
                    if (propertyItemType == null)
                        continue;

                    // OK, its a List<itemType>.  Add all the necessary XmlElementAttribute declarations.
                    if (propertyItemType == itemType)
                    {
                        if (attributes == null)
                        {
                            attributes = new XmlAttributes();
                            foreach (var derivedType in derivedTypes)
                                // Here we are assuming all the derived types have unique XML type names.
                                attributes.XmlArrayItems.Add(new XmlArrayItemAttribute { Type = derivedType });
                            if (itemType.IsConcreteType())
                                attributes.XmlArrayItems.Add(new XmlArrayItemAttribute { Type = itemType });
                        }
                        overrides.Add(declaringType, property.Name, attributes);
                    }
                }
            }
            return overrides;
        }
    }

    public static class TypeExtensions
    {
        public static bool IsConcreteType(this Type type)
        {
            return !type.IsAbstract && !type.IsInterface;
        }

        public static Type GetListType(this Type type)
        {
            while (type != null)
            {
                if (type.IsGenericType)
                {
                    var genType = type.GetGenericTypeDefinition();
                    if (genType == typeof(List<>))
                        return type.GetGenericArguments()[0];
                }
                type = type.BaseType;
            }
            return null;
        }
    }

    class TestClass
    {
        public static void Test()
        {
            TestRoot();
            TestComplexRoot();
        }

        static void TestRoot()
        {
            var root = new RootObject
            {
                AList = new AListObject
                {
                    SerializedListObjects = new List<A> { new B(), new C() },
                },
            };

            var serializer = AListSerializerFactory.Instance.CreateSerializer(root.GetType());

            var xml = root.GetXml(serializer);
            var root2 = xml.LoadFromXml<RootObject>(serializer);

            var xml2 = root2.GetXml(serializer);

            Console.WriteLine(xml);
            Console.WriteLine(xml2);

            Assert.IsTrue(root2.AList.SerializedListObjects.Select(a => a.GetType()).SequenceEqual(root.AList.SerializedListObjects.Select(a => a.GetType())));

            Assert.IsTrue(XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2)));
        }

        static void TestComplexRoot()
        {
            var root = new ComplexRootObject
            {
                MidObject = new MidObjectDerived
                {
                    DerivedSerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },
                    AnotherSerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },
                    SerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },  
                },
            };

            var serializer = ComplexAListSerializerFactory.Instance.CreateSerializer(root.GetType());

            var xml = root.GetXml(serializer);
            Console.WriteLine(xml);

            var root2 = xml.LoadFromXml<ComplexRootObject>(serializer);
            var xml2 = root2.GetXml(serializer);
            Console.WriteLine(xml2);

            Assert.IsTrue(XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2)));
        }
    }

    public static class ComplexAListSerializerFactory
    {
        static readonly XmlArrayItemTypeOverrideSerializerFactory instance;

        static ComplexAListSerializerFactory()
        {
            // Include here a list of all types that have a List<A> property.
            // You could use reflection to find all public types with a List<A>
            var declaringTypeList = new[]
            {
                typeof(AListObject),
                typeof(MidObject),
                typeof(ComplexRootObject),
                typeof(MidObjectDerived),
            };
            // Include here a list of all base types with a corresponding mapping 
            // to find all derived types in runtime.   Here you could use reflection
            // to find all such types in your assemblies.
            var derivedTypesList = new Dictionary<Type, Func<IEnumerable<Type>>>
            {
                { typeof(A), () => new [] { typeof(B), typeof(C), typeof(D) } },
            };
            instance = new XmlArrayItemTypeOverrideSerializerFactory(declaringTypeList, derivedTypesList);
        }

        public static IXmlSerializerFactory Instance { get { return instance; } }
    }

    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)
        {
            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);
                return textWriter.ToString();
            }
        }
    }
				
    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }

        public AssertionFailedException(string s) : base(s) { }
    }

    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }

        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }
						
	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Roslyn 2.0 Compiler; Environment version: " + Environment.Version);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Uncaught exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.IO;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Reflection;
​
// https://stackoverflow.com/questions/50471935/serialize-a-list-of-objects-inheriting-from-class-a-to-xml-so-the-names-of-the
​
    public class RootObject
    {
        public AListObject AList { get; set; }
    }
​
    public class AListObject
    {
        public List<A> SerializedListObjects { get; set; }
    }
​
    public class A
    {
    }
​
    public class B : A
    {
    }
​
    public class C : A
    {
    }
​
    public class D : C
    {
    }
​
    public class ComplexRootObject
    {
        public MidObjectDerived MidObject { get; set; }
    }
​
    public class MidObject
    {
        public List<A> SerializedListObjects { get; set; }
​
        public List<A> AnotherSerializedListObjects { get; set; }
    }
​
    public class MidObjectDerived : MidObject
    {
        public List<A> DerivedSerializedListObjects { get; set; }
    }
​
    public interface IXmlSerializerFactory
    {
        XmlSerializer CreateSerializer(Type rootType);
    }
​
    public static class AListSerializerFactory
    {
        static readonly XmlArrayItemTypeOverrideSerializerFactory instance;
​
        static AListSerializerFactory()
        {
            // Include here a list of all types that have a List<A> property.
            // You could use reflection to find all such public types in your assemblies.
            var declaringTypeList = new []
            {
                typeof(AListObject),
            };
​
            // Include here a list of all base types with a corresponding mapping 
            // to find all derived types in runtime.   Here you could use reflection
            // to find all such types in your assemblies, as shown in 
            // https://stackoverflow.com/questions/857705/get-all-derived-types-of-a-type
            var derivedTypesList = new Dictionary<Type,  Func<IEnumerable<Type>>>
            {
                { typeof(A), () => new [] { typeof(B), typeof(C) } },
            };
            instance = new XmlArrayItemTypeOverrideSerializerFactory(declaringTypeList, derivedTypesList);
        }
​
        public static IXmlSerializerFactory Instance { get { return instance; } }
    }
​
    public class XmlArrayItemTypeOverrideSerializerFactory : IXmlSerializerFactory
    {
        // To avoid a memory & resource leak, the serializers must be cached as explained in
        // https://stackoverflow.com/questions/23897145/memory-leak-using-streamreader-and-xmlserializer
​
        readonly object padlock = new object();
        readonly Dictionary<Type, XmlSerializer> serializers = new Dictionary<Type, XmlSerializer>();
        readonly XmlAttributeOverrides overrides;
​
        public XmlArrayItemTypeOverrideSerializerFactory(IEnumerable<Type> declaringTypeList, IEnumerable<KeyValuePair<Type, Func<IEnumerable<Type>>>> derivedTypesList)
        {
            var completed = new HashSet<Type>();
            overrides = declaringTypeList
                .SelectMany(d => derivedTypesList.Select(p => new { declaringType = d, itemType = p.Key, derivedTypes = p.Value() }))
                .Aggregate(new XmlAttributeOverrides(), (a, d) => a.AddXmlArrayItemTypes(d.declaringType, d.itemType, d.derivedTypes, completed));
        }
​
        public XmlSerializer CreateSerializer(Type rootType)
        {
            lock (padlock)
            {
                XmlSerializer serializer;
                if (!serializers.TryGetValue(rootType, out serializer))
                    serializers[rootType] = serializer = new XmlSerializer(rootType, overrides);
                return serializer;
            }
        }
    }
​
    public static partial class XmlAttributeOverridesExtensions
    {
        public static XmlAttributeOverrides AddXmlArrayItemTypes(this XmlAttributeOverrides overrides, Type declaringType, Type itemType, IEnumerable<Type> derivedTypes)
        {
            return overrides.AddXmlArrayItemTypes(declaringType, itemType, derivedTypes, new HashSet<Type>());
        }
​
        public static XmlAttributeOverrides AddXmlArrayItemTypes(this XmlAttributeOverrides overrides, Type declaringType, Type itemType, IEnumerable<Type> derivedTypes, HashSet<Type> completedTypes)
        {
            if (overrides == null || declaringType == null || itemType == null || derivedTypes == null || completedTypes == null)
                throw new ArgumentNullException();
            XmlAttributes attributes = null;
            for (; declaringType != null && declaringType != typeof(object); declaringType = declaringType.BaseType)
            {
                // Avoid duplicate overrides.
                if (!completedTypes.Add(declaringType))
                    break;
                foreach (var property in declaringType.GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance))
                {
                    // Skip the property if already ignored
                    if (property.IsDefined(typeof(XmlIgnoreAttribute), false))
                        continue;
                    
                    // See if it is a list property, and if so, get its type.
                    var propertyItemType = property.PropertyType.GetListType();
                    if (propertyItemType == null)
                        continue;
​
                    // OK, its a List<itemType>.  Add all the necessary XmlElementAttribute declarations.
                    if (propertyItemType == itemType)
                    {
                        if (attributes == null)
                        {
                            attributes = new XmlAttributes();
                            foreach (var derivedType in derivedTypes)
                                // Here we are assuming all the derived types have unique XML type names.
                                attributes.XmlArrayItems.Add(new XmlArrayItemAttribute { Type = derivedType });
                            if (itemType.IsConcreteType())
                                attributes.XmlArrayItems.Add(new XmlArrayItemAttribute { Type = itemType });
                        }
                        overrides.Add(declaringType, property.Name, attributes);
                    }
                }
            }
            return overrides;
        }
    }
​
    public static class TypeExtensions
    {
        public static bool IsConcreteType(this Type type)
        {
            return !type.IsAbstract && !type.IsInterface;
        }
​
        public static Type GetListType(this Type type)
        {
            while (type != null)
            {
                if (type.IsGenericType)
                {
                    var genType = type.GetGenericTypeDefinition();
                    if (genType == typeof(List<>))
                        return type.GetGenericArguments()[0];
                }
                type = type.BaseType;
            }
            return null;
        }
    }
​
    class TestClass
    {
        public static void Test()
        {
            TestRoot();
            TestComplexRoot();
        }
​
        static void TestRoot()
        {
            var root = new RootObject
            {
                AList = new AListObject
                {
                    SerializedListObjects = new List<A> { new B(), new C() },
                },
            };
​
            var serializer = AListSerializerFactory.Instance.CreateSerializer(root.GetType());
​
            var xml = root.GetXml(serializer);
            var root2 = xml.LoadFromXml<RootObject>(serializer);
​
            var xml2 = root2.GetXml(serializer);
​
            Console.WriteLine(xml);
            Console.WriteLine(xml2);
​
            Assert.IsTrue(root2.AList.SerializedListObjects.Select(a => a.GetType()).SequenceEqual(root.AList.SerializedListObjects.Select(a => a.GetType())));
​
            Assert.IsTrue(XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2)));
        }
​
        static void TestComplexRoot()
        {
            var root = new ComplexRootObject
            {
                MidObject = new MidObjectDerived
                {
                    DerivedSerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },
                    AnotherSerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },
                    SerializedListObjects = new List<A> { new A(), new B(), new C(), new D() },  
                },
            };
​
            var serializer = ComplexAListSerializerFactory.Instance.CreateSerializer(root.GetType());
​
            var xml = root.GetXml(serializer);
            Console.WriteLine(xml);
​
            var root2 = xml.LoadFromXml<ComplexRootObject>(serializer);
            var xml2 = root2.GetXml(serializer);
            Console.WriteLine(xml2);
​
            Assert.IsTrue(XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2)));
        }
    }
​
    public static class ComplexAListSerializerFactory
    {
        static readonly XmlArrayItemTypeOverrideSerializerFactory instance;
​
        static ComplexAListSerializerFactory()
        {
            // Include here a list of all types that have a List<A> property.
            // You could use reflection to find all public types with a List<A>
            var declaringTypeList = new[]
            {
                typeof(AListObject),
                typeof(MidObject),
                typeof(ComplexRootObject),
                typeof(MidObjectDerived),
            };
            // Include here a list of all base types with a corresponding mapping 
            // to find all derived types in runtime.   Here you could use reflection
            // to find all such types in your assemblies.
            var derivedTypesList = new Dictionary<Type, Func<IEnumerable<Type>>>
            {
                { typeof(A), () => new [] { typeof(B), typeof(C), typeof(D) } },
            };
            instance = new XmlArrayItemTypeOverrideSerializerFactory(declaringTypeList, derivedTypesList);
        }
​
        public static IXmlSerializerFactory Instance { get { return instance; } }
    }
​
    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)
        {
            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);
                return textWriter.ToString();
            }
        }
    }
                
    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }
​
        public AssertionFailedException(string s) : base(s) { }
    }
​
    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }
​
        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }
                        
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Roslyn 2.0 Compiler; Environment version: " + Environment.Version);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Uncaught exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​

View IL Code