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 NUnit.Framework; //NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/59532391/how-to-manage-no-break-space-used-for-formatting-of-xdocument

​

    public class XmlNoBreakSpaceTextReader : XmlTextReader

    {

        public XmlNoBreakSpaceTextReader(TextReader reader) : base(reader) { }

​

        string overrideValue = null;

        XmlNodeType? overrideType = null;

        public override string Value { get { return overrideValue ?? base.Value; } }

        public override XmlNodeType NodeType { get { return overrideType ?? base.NodeType; } }

​

        public override bool Read()

        {

            overrideValue = null;

            overrideType = null;

            while (base.Read())

            {

                var nodeType = base.NodeType;

                if (nodeType == XmlNodeType.Text)

                {

                    var value = base.Value;

                    // Maybe check here that string.IsNullOrWhiteSpace(value) and only replace nonbreaking spaces in whitespace strings?

                    var newValue = value.Replace('\u00A0', ' ');

                    if ((object)newValue != (object)value)

                    {

                        var newNodeType = newValue.All(c => XmlConvert.IsWhitespaceChar(c)) ? XmlNodeType.Whitespace : nodeType;

                        if (newNodeType == XmlNodeType.Whitespace && WhitespaceHandling != WhitespaceHandling.All)

                            continue;

                        overrideValue = newValue;

                        overrideType = newNodeType;

                        return true;

                    }

                }

                return true;

            }

            return false;

        }

    }

    public class TestClass

    {

        public static void Test()

        {

            TestFix();

            TestOriginal();

            TestXmlNoBreakSpaceTextReader();

        }

​

        public static void TestFix()

        {

            Console.WriteLine("\nTesting validation with XmlNoBreakSpaceTextReader:");

            var xmlFromUser = GetXml();

            var xsdSchemaText = GetXsd();

            XDocument d;

            using (var reader = new XmlNoBreakSpaceTextReader(new StringReader(xmlFromUser)))

            {

                d = XDocument.Load(reader);

            }

​

            Assert.IsTrue(TestValidation(d, xsdSchemaText) == 0);

        }

​

        static void TestOriginal()

        {

            Console.WriteLine("\nTesting validation without using XmlNoBreakSpaceTextReader:");

​

            var xmlFromUser = GetXml();

            var xsdSchemaText = GetXsd();

​

            XDocument d = XDocument.Parse(xmlFromUser);

​

            Assert.IsTrue(TestValidation(d, xsdSchemaText) > 0);

        }

​

        static int TestValidation(XDocument d, string xsdSchemaText)

        {

            XmlTextReader xmlReader = new XmlTextReader(xsdSchemaText, XmlNodeType.Document, null);

            XmlSchema xmlSchema = XmlSchema.Read(xmlReader, null);

            XmlSchemaSet schemas = new XmlSchemaSet();

            schemas.Add(xmlSchema);

​

            int count = 0;

​

            d.Validate(schemas, (sender, eventArgs) =>

            {

                // process errors here

                Console.WriteLine("[{0} {1}", eventArgs.Severity, eventArgs.Message);

                count++;

            });

​

            Console.WriteLine("{0} errors found total.", count);

            return count;

        }

​

        static void TestXmlNoBreakSpaceTextReader()

        {

            char noBreakSpace = '\u00A0';

​

            var xmlFromUser = GetXml();

​

            Console.WriteLine();

            Console.WriteLine("XmlConvert.IsWhitespaceChar(noBreakSpace) = {0}", XmlConvert.IsWhitespaceChar(noBreakSpace));

            Console.WriteLine("char.IsWhiteSpace(noBreakSpace) = {0}", char.IsWhiteSpace(noBreakSpace));

            Console.WriteLine("xmlFromUser.IndexOf(noBreakSpace) = {0}", xmlFromUser.IndexOf(noBreakSpace));

​

            Console.WriteLine("\nTesting WhitespaceHandling.{0}:", WhitespaceHandling.None);

​

            using (var reader = new XmlNoBreakSpaceTextReader(new StringReader(xmlFromUser)) { WhitespaceHandling = WhitespaceHandling.None })

            {

                while (reader.Read())

                {

                    Console.WriteLine("NodeType = {0}, Value = {1}", reader.NodeType, System.Text.RegularExpressions.Regex.Escape(reader.Value));

                }

            }

​

            Console.WriteLine("\nTesting WhitespaceHandling.{0}:", WhitespaceHandling.All);

​

            using (var reader = new XmlNoBreakSpaceTextReader(new StringReader(xmlFromUser)) { WhitespaceHandling = WhitespaceHandling.All })

            {

                while (reader.Read())

                {

                    Console.WriteLine("NodeType = {0}, Value = {1}", reader.NodeType, System.Text.RegularExpressions.Regex.Escape(reader.Value));

                }

            }

        }

​

        static string GetXml()

        {

            return @"<myConfig>

" + "\u00A0\u00A0" + @"<defaultConfig>

    <defaultTitle>Hello!</defaultTitle>

  </defaultConfig>

</myConfig>";

        }

        static string GetXsd()

        {

            return @"<xs:schema attributeFormDefault=""unqualified"" elementFormDefault=""qualified"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">

  <xs:element name=""myConfig"" type=""myConfigType""/>

  <xs:complexType name=""defaultConfigType"">

    <xs:sequence>

      <xs:element type=""xs:string"" name=""defaultTitle""/>

    </xs:sequence>

  </xs:complexType>

  <xs:complexType name=""myConfigType"">

    <xs:sequence>

      <xs:element type=""defaultConfigType"" name=""defaultConfig""/>

    </xs:sequence>

  </xs:complexType>

</xs:schema>";

        }

    }

​

    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;

        }

    }

​