[Fork] https://stackoverflow.com/questions/63782208/remove-defaultvalue-attribute-for-xml-serialization-in-c-sharp | C# Online Compiler

[Fork] https://stackoverflow.com/questions/63782208/remove-defaultvalue-attribute-for-xml-serialization-in-c-sharp 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.Schema;
using System.Xml.Linq;
using System.IO;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO.Compression;
using System.Reflection;
using System.ComponentModel;

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

//https://stackoverflow.com/questions/63782208/remove-defaultvalue-attribute-for-xml-serialization-in-c-sharp

	[Serializable]
	[XmlType(TypeName = "MyType", Namespace = "https://DefaultNamespace")]
	public class MyType
	{
		public MyType()
		{
			MyValue = false;
		}

		[XmlElement(ElementName = "myValue", Form = XmlSchemaForm.Unqualified)]
		[DefaultValue(false)]
		public bool MyValue { get; set; }

		public bool SomeOtherValue { get; set; }
	}

	// Modified from this answer https://stackoverflow.com/a/28107096/3744182
	// To https://stackoverflow.com/questions/28054335/force-xml-serialization-of-xmldefaultvalue-values
	// By https://stackoverflow.com/users/3744182/dbc
	// Added support for XmlElementAttribute, XmlArrayAttribute and XmlArrayItemAttribute attributes applied to properties with default values.

	public abstract class XmlSerializerKey
	{
		static class XmlSerializerHashTable
		{
			static Dictionary<object, XmlSerializer> dict;

			static XmlSerializerHashTable()
			{
				dict = new Dictionary<object, XmlSerializer>();
			}

			public static XmlSerializer GetSerializer(XmlSerializerKey key)
			{
				lock (dict)
				{
					XmlSerializer value;
					if (!dict.TryGetValue(key, out value))
						dict[key] = value = key.CreateSerializer();
					return value;
				}
			}
		}

		readonly Type serializedType;

		protected XmlSerializerKey(Type serializedType)
		{
			this.serializedType = serializedType;
		}

		public Type SerializedType { get { return serializedType; } }

		public override bool Equals(object obj)
		{
			if (ReferenceEquals(this, obj))
				return true;
			else if (ReferenceEquals(null, obj))
				return false;
			if (GetType() != obj.GetType())
				return false;
			XmlSerializerKey other = (XmlSerializerKey)obj;
			if (other.serializedType != serializedType)
				return false;
			return true;
		}

		public override int GetHashCode()
		{
			int code = 0;
			if (serializedType != null)
				code ^= serializedType.GetHashCode();
			return code;
		}

		public override string ToString()
		{
			return string.Format(base.ToString() + ": for type: " + serializedType.ToString());
		}

		public XmlSerializer GetSerializer()
		{
			return XmlSerializerHashTable.GetSerializer(this);
		}

		protected abstract XmlSerializer CreateSerializer();
	}

	public abstract class XmlSerializerWithExtraTypesKey : XmlSerializerKey
	{
		static IEqualityComparer<HashSet<Type>> comparer;

		readonly HashSet<Type> extraTypes = new HashSet<Type>();

		static XmlSerializerWithExtraTypesKey()
		{
			comparer = HashSet<Type>.CreateSetComparer();
		}

		protected XmlSerializerWithExtraTypesKey(Type serializedType, IEnumerable<Type> extraTypes)
			: base(serializedType)
		{
			if (extraTypes != null)
				foreach (var type in extraTypes)
					this.extraTypes.Add(type);
		}

		public Type[] ExtraTypes { get { return extraTypes.ToArray(); } }

		public override bool Equals(object obj)
		{
			if (!base.Equals(obj))
				return false;
			XmlSerializerWithExtraTypesKey other = (XmlSerializerWithExtraTypesKey)obj;
			return comparer.Equals(this.extraTypes, other.extraTypes);
		}

		public override int GetHashCode()
		{
			int code = base.GetHashCode();
			if (extraTypes != null)
				code ^= comparer.GetHashCode(extraTypes);
			return code;
		}
	}

	public sealed class XmlSerializerIgnoringDefaultValuesKey : XmlSerializerWithExtraTypesKey
	{
		readonly XmlAttributeOverrides overrides;

		private XmlSerializerIgnoringDefaultValuesKey(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, XmlAttributeOverrides overrides)
			: base(serializerType, ignoreDefaultTypes)
		{
			this.overrides = overrides;
		}

		public static XmlSerializerIgnoringDefaultValuesKey Create(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, bool recurse)
		{
			XmlAttributeOverrides overrides;
			Type [] typesWithOverrides;

			CreateOverrideAttributes(ignoreDefaultTypes, recurse, out overrides, out typesWithOverrides);
			return new XmlSerializerIgnoringDefaultValuesKey(serializerType, typesWithOverrides, overrides);
		}

		protected override XmlSerializer CreateSerializer()
		{
			var types = ExtraTypes;
			if (types == null || types.Length < 1)
				return new XmlSerializer(SerializedType);
			return new XmlSerializer(SerializedType, overrides);
		}

		static void CreateOverrideAttributes(IEnumerable<Type> types, bool recurse, out XmlAttributeOverrides overrides, out Type[] typesWithOverrides)
		{
			HashSet<Type> visited = new HashSet<Type>();
			HashSet<Type> withOverrides = new HashSet<Type>();
			overrides = new XmlAttributeOverrides();

			foreach (var type in types)
			{
				CreateOverrideAttributes(type, recurse, overrides, visited, withOverrides);
			}

			typesWithOverrides = withOverrides.ToArray();
		}

		static void AddOverride(XmlAttributeOverrides overrides, Type type, MemberInfo memberInfo)
		{
			var xmlElementAttr = memberInfo.GetCustomAttributes<XmlElementAttribute>();
			var xmlArrayAttr = memberInfo.GetCustomAttribute<XmlArrayAttribute>();
			var xmlArrayItemAttr = memberInfo.GetCustomAttributes<XmlArrayItemAttribute>();
			var attrs = new XmlAttributes 
			{ 
				XmlDefaultValue = null,
				XmlArray = xmlArrayAttr,
			};
			foreach (var a in xmlElementAttr)
				attrs.XmlElements.Add(a);
			foreach (var a in xmlArrayItemAttr)
				attrs.XmlArrayItems.Add(a);
			overrides.Add(type, memberInfo.Name, attrs);
		}

		static void CreateOverrideAttributes(Type type, bool recurse, XmlAttributeOverrides overrides, HashSet<Type> visited, HashSet<Type> withOverrides)
		{
			if (type == null || type == typeof(object) || type.IsPrimitive || type == typeof(string) || visited.Contains(type))
				return;
			foreach (var property in type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
				if (overrides[type, property.Name] == null) // Check to see if overrides for this base type were already set.
					if (Attribute.IsDefined(property, typeof(DefaultValueAttribute), true))
					{
						withOverrides.Add(type);
						AddOverride(overrides, type, property);
					}
			foreach (var field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
				if (overrides[type, field.Name] == null) // Check to see if overrides for this base type were already set.
					if (Attribute.IsDefined(field, typeof(DefaultValueAttribute), true))
					{
						withOverrides.Add(type);
						AddOverride(overrides, type, field);
					}
			visited.Add(type);
			if (recurse)
			{
				var baseType = type.BaseType;
				if (baseType != type)
					CreateOverrideAttributes(baseType, recurse, overrides, visited, withOverrides);
			}
		}
	}
	
	// End modified code

    public class TestClass
    {
        public static void Test()
        {
			using var stream = new MemoryStream();			

			var serializer = XmlSerializerIgnoringDefaultValuesKey.Create(typeof(MyType), new[] { typeof(MyType) }, true).GetSerializer();			
			
			using (TextWriter writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))
			{
				serializer.Serialize(writer, new MyType());
			}			
			
			var xml = Encoding.UTF8.GetString(stream.ToArray());
			
			Console.WriteLine(xml);
			
			Assert.IsTrue(xml.Contains("<myValue>false</myValue>"));
        }
    }

    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 static class XmlAssert
    {
        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality
        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects
        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson
        public static void AreEqual(
            XElement expected,
            XElement actual)
        {
            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));
        }

        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()),
                    element.Elements()
                           .OrderBy(a => a.Name.ToString())
                           .Select(e => Normalize(e)));

            }

            if (element.IsEmpty)
            {
                return new XElement(
                    element.Name,
					"",
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()));
            }

            return new XElement(element.Name, element.Attributes()
                .OrderBy(a => a.Name.ToString()), element.Value);
        }
    }
						
	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());
			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;
		}
	}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Linq;
using System.IO;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO.Compression;
using System.Reflection;
using System.ComponentModel;
​
using NUnit.Framework; //NUnit.Framework.AssertionException
​
//https://stackoverflow.com/questions/63782208/remove-defaultvalue-attribute-for-xml-serialization-in-c-sharp
​
    [Serializable]
    [XmlType(TypeName = "MyType", Namespace = "https://DefaultNamespace")]
    public class MyType
    {
        public MyType()
        {
            MyValue = false;
        }
​
        [XmlElement(ElementName = "myValue", Form = XmlSchemaForm.Unqualified)]
        [DefaultValue(false)]
        public bool MyValue { get; set; }
​
        public bool SomeOtherValue { get; set; }
    }
​
    // Modified from this answer https://stackoverflow.com/a/28107096/3744182
    // To https://stackoverflow.com/questions/28054335/force-xml-serialization-of-xmldefaultvalue-values
    // By https://stackoverflow.com/users/3744182/dbc
    // Added support for XmlElementAttribute, XmlArrayAttribute and XmlArrayItemAttribute attributes applied to properties with default values.
​
    public abstract class XmlSerializerKey
    {
        static class XmlSerializerHashTable
        {
            static Dictionary<object, XmlSerializer> dict;
​
            static XmlSerializerHashTable()
            {
                dict = new Dictionary<object, XmlSerializer>();
            }
​
            public static XmlSerializer GetSerializer(XmlSerializerKey key)
            {
                lock (dict)
                {
                    XmlSerializer value;
                    if (!dict.TryGetValue(key, out value))
                        dict[key] = value = key.CreateSerializer();
                    return value;
                }
            }
        }
​
        readonly Type serializedType;
​
        protected XmlSerializerKey(Type serializedType)
        {
            this.serializedType = serializedType;
        }
​
        public Type SerializedType { get { return serializedType; } }
​
        public override bool Equals(object obj)
        {
            if (ReferenceEquals(this, obj))
                return true;
            else if (ReferenceEquals(null, obj))
                return false;
            if (GetType() != obj.GetType())
                return false;
            XmlSerializerKey other = (XmlSerializerKey)obj;
            if (other.serializedType != serializedType)
                return false;
            return true;
        }
​
        public override int GetHashCode()
        {
            int code = 0;
            if (serializedType != null)
                code ^= serializedType.GetHashCode();
            return code;
        }
​
        public override string ToString()
        {
            return string.Format(base.ToString() + ": for type: " + serializedType.ToString());
        }
​
        public XmlSerializer GetSerializer()
        {
            return XmlSerializerHashTable.GetSerializer(this);
        }
​
        protected abstract XmlSerializer CreateSerializer();
    }
​
    public abstract class XmlSerializerWithExtraTypesKey : XmlSerializerKey
    {
        static IEqualityComparer<HashSet<Type>> comparer;
​
        readonly HashSet<Type> extraTypes = new HashSet<Type>();
​
        static XmlSerializerWithExtraTypesKey()
        {
            comparer = HashSet<Type>.CreateSetComparer();
        }
​
        protected XmlSerializerWithExtraTypesKey(Type serializedType, IEnumerable<Type> extraTypes)
            : base(serializedType)
        {
            if (extraTypes != null)
                foreach (var type in extraTypes)
                    this.extraTypes.Add(type);
        }
​
        public Type[] ExtraTypes { get { return extraTypes.ToArray(); } }
​
        public override bool Equals(object obj)
        {
            if (!base.Equals(obj))
                return false;
            XmlSerializerWithExtraTypesKey other = (XmlSerializerWithExtraTypesKey)obj;
            return comparer.Equals(this.extraTypes, other.extraTypes);
        }
​
        public override int GetHashCode()
        {
            int code = base.GetHashCode();
            if (extraTypes != null)
                code ^= comparer.GetHashCode(extraTypes);
            return code;
        }
    }
​
    public sealed class XmlSerializerIgnoringDefaultValuesKey : XmlSerializerWithExtraTypesKey
    {
        readonly XmlAttributeOverrides overrides;
​
        private XmlSerializerIgnoringDefaultValuesKey(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, XmlAttributeOverrides overrides)
            : base(serializerType, ignoreDefaultTypes)
        {
            this.overrides = overrides;
        }
​
        public static XmlSerializerIgnoringDefaultValuesKey Create(Type serializerType, IEnumerable<Type> ignoreDefaultTypes, bool recurse)
        {
            XmlAttributeOverrides overrides;
            Type [] typesWithOverrides;
​
            CreateOverrideAttributes(ignoreDefaultTypes, recurse, out overrides, out typesWithOverrides);
            return new XmlSerializerIgnoringDefaultValuesKey(serializerType, typesWithOverrides, overrides);
        }
​
        protected override XmlSerializer CreateSerializer()
        {
            var types = ExtraTypes;
            if (types == null || types.Length < 1)
                return new XmlSerializer(SerializedType);
            return new XmlSerializer(SerializedType, overrides);
        }
​
        static void CreateOverrideAttributes(IEnumerable<Type> types, bool recurse, out XmlAttributeOverrides overrides, out Type[] typesWithOverrides)
        {
            HashSet<Type> visited = new HashSet<Type>();
            HashSet<Type> withOverrides = new HashSet<Type>();
            overrides = new XmlAttributeOverrides();
​
            foreach (var type in types)
            {
                CreateOverrideAttributes(type, recurse, overrides, visited, withOverrides);
            }
​
            typesWithOverrides = withOverrides.ToArray();
        }
​
        static void AddOverride(XmlAttributeOverrides overrides, Type type, MemberInfo memberInfo)
        {
            var xmlElementAttr = memberInfo.GetCustomAttributes<XmlElementAttribute>();
            var xmlArrayAttr = memberInfo.GetCustomAttribute<XmlArrayAttribute>();
            var xmlArrayItemAttr = memberInfo.GetCustomAttributes<XmlArrayItemAttribute>();
            var attrs = new XmlAttributes 
            { 
                XmlDefaultValue = null,
                XmlArray = xmlArrayAttr,
            };
            foreach (var a in xmlElementAttr)
                attrs.XmlElements.Add(a);
            foreach (var a in xmlArrayItemAttr)
                attrs.XmlArrayItems.Add(a);
            overrides.Add(type, memberInfo.Name, attrs);
        }
​
        static void CreateOverrideAttributes(Type type, bool recurse, XmlAttributeOverrides overrides, HashSet<Type> visited, HashSet<Type> withOverrides)
        {
            if (type == null || type == typeof(object) || type.IsPrimitive || type == typeof(string) || visited.Contains(type))
                return;
            foreach (var property in type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
                if (overrides[type, property.Name] == null) // Check to see if overrides for this base type were already set.
                    if (Attribute.IsDefined(property, typeof(DefaultValueAttribute), true))
                    {
                        withOverrides.Add(type);
                        AddOverride(overrides, type, property);
                    }
            foreach (var field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public))
                if (overrides[type, field.Name] == null) // Check to see if overrides for this base type were already set.
                    if (Attribute.IsDefined(field, typeof(DefaultValueAttribute), true))
                    {
                        withOverrides.Add(type);
                        AddOverride(overrides, type, field);
                    }
            visited.Add(type);
            if (recurse)
            {
                var baseType = type.BaseType;
                if (baseType != type)
                    CreateOverrideAttributes(baseType, recurse, overrides, visited, withOverrides);
            }
        }
    }
    
    // End modified code
​
    public class TestClass
    {
        public static void Test()
        {
            using var stream = new MemoryStream();          
​
            var serializer = XmlSerializerIgnoringDefaultValuesKey.Create(typeof(MyType), new[] { typeof(MyType) }, true).GetSerializer();          
            
            using (TextWriter writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))
            {
                serializer.Serialize(writer, new MyType());
            }           
            
            var xml = Encoding.UTF8.GetString(stream.ToArray());
            
            Console.WriteLine(xml);
            
            Assert.IsTrue(xml.Contains("<myValue>false</myValue>"));
        }
    }
​
    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 static class XmlAssert
    {
        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality
        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects
        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson
        public static void AreEqual(
            XElement expected,
            XElement actual)
        {
            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));
        }
​
        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()),
                    element.Elements()
                           .OrderBy(a => a.Name.ToString())
                           .Select(e => Normalize(e)));
​
            }
​
            if (element.IsEmpty)
            {
                return new XElement(
                    element.Name,
                    "",
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()));
            }
​
            return new XElement(element.Name, element.Attributes()
                .OrderBy(a => a.Name.ToString()), element.Value);
        }
    }
                        
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());
            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;
        }
    }
​

View IL Code