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;

        }

    }

​