using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Xml;

using System.Xml.Linq;

using System.IO;

​

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

​

//https://stackoverflow.com/questions/79421216/c-sharp-xmldocument-vs-xdocument-behaviour-on-invalid-hexadecimal-character

// MCVE here: https://dotnetfiddle.net/KEPEFA

​

#nullable enable

​

    public static class XDocumentExtensions

    {

        static readonly XmlReaderSettings noCheckedCharacterParseSettings = new() { CheckCharacters = false, };

        public static XDocument ParseAndRemoveInvalidXmlCharacters(string xml, char? fallback = null)

        {

            ArgumentNullException.ThrowIfNull(xml);

​

            // From testing it seems that CheckCharacters=false only allows invalid character entities whose value falls outside the range from the standard

            // https://www.w3.org/TR/2006/REC-xml-20060816/#NT-Char

            //    [2]       Char       ::=      #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]  /* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */

            // Invalid characters directly embedded in the character stream must be stripped out manually.

            using var reader = new StringReader(xml.RemoveInvalidXmlCharacters(fallback));

            using var xmlReader = XmlReader.Create(reader, noCheckedCharacterParseSettings);

            return XDocument.Load(xmlReader).RemoveInvalidXmlCharacters(fallback);

        }

        public static TXObject RemoveInvalidXmlCharacters<TXObject>(this TXObject node, char? fallback = null) where TXObject : XObject

        {

            switch (node)

            {

                case XText text:

                    text.Value = text.Value.RemoveInvalidXmlCharacters(fallback);   

                    break;

                case XAttribute attribute:

                    attribute.Value = attribute.Value.RemoveInvalidXmlCharacters(fallback);

                    break;

                case XComment comment:

                    comment.Value = comment.Value.RemoveInvalidXmlCharacters();

                    break;

                case XDocument doc:

                    doc.Root?.RemoveInvalidXmlCharacters();

                    break;

                case XElement element:

                    foreach (var attr in element.Attributes())

                        attr.RemoveInvalidXmlCharacters();

                    foreach (var child in element.Nodes())

                        child.RemoveInvalidXmlCharacters();

                    break;

                case XContainer container: // XDocument

                    foreach (var child in container.Nodes())

                        child.RemoveInvalidXmlCharacters();

                    break;

                // Not done: XDocumentType, XProcessingInstruction

            }

            return node;

        }

        public static string RemoveInvalidXmlCharacters(this string xmlText, char? fallback = null)

        {

            ArgumentNullException.ThrowIfNull(xmlText);

​

            StringBuilder? sb = null;

​

            for (int i = 0; i < xmlText.Length; i++)

            {

                if (XmlConvert.IsXmlChar(xmlText[i]))

                {

                    if (sb != null)

                        sb.Append(xmlText[i]);

                }

                else if (i < xmlText.Length - 1 && XmlConvert.IsXmlSurrogatePair(xmlText[i+1], xmlText[i])) // Yes this order is correct.

                {

                    if (sb != null)

                        sb.Append(xmlText, i, 2);

                    i++;

                }

                else

                {

                    if (sb == null)

                    {

                        sb = new();

                        sb.Append(xmlText, 0, i);

                    }

                    if (fallback != null)

                        sb.Append(fallback.Value);

                }

            }

            return sb?.ToString() ?? xmlText;

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            string message = "\x01Hello, \x01\x1EWorld! H\u0302\U00029E3D"; // string with control code 1E encoded.

​

            TestXmlDocument(message);

​

            string xmlWithInvalidCharacters = "<greeting attribute=\"Attrbute with escapes: \x01\x1E&#x1;&#x1E; H\u0302\U00029E3D\">Hello, \x01\x1E&#x1;&#x1E;World! H\u0302\U00029E3D</greeting>";

            TestXDocument(message, xmlWithInvalidCharacters);

        }

​

        static void TestXmlDocument(string message)

        {

            Console.WriteLine("Testing XmlDocument:");

            // This block completes - create an xml document incorporating the message string

            XmlDocument xmlDoc = new XmlDocument();

            XmlElement root = xmlDoc.CreateElement("greeting");

            xmlDoc.AppendChild(root);

            root.InnerText = message;

            Console.WriteLine(xmlDoc.OuterXml);

            var xmlDoc2 = new XmlDocument();

            xmlDoc2.LoadXml(xmlDoc.OuterXml);

            Console.WriteLine(xmlDoc2.OuterXml);

            // This block completes - XmlDocument load document containing an  entity expression

            string xmlWithEscapedHexEntity = xmlDoc.OuterXml; // <greeting>Hello, &x1E;World!</greeting>";

            xmlDoc = new XmlDocument();

            xmlDoc.LoadXml(xmlWithEscapedHexEntity);

            Console.WriteLine(xmlDoc.OuterXml);

​

​

            // Outputs: <greeting>Hello, &#x1E;World!</greeting>

        }

        static void TestXDocument(string message, string xmlWithInvalidCharacters)

        {

            Console.WriteLine("\nTesting XDocument: with {0} and\n{1}\n", message, xmlWithInvalidCharacters);

            // This block fails - XDocument creation of document containing control-code character x1E

            try

            {

                var xdoc = new XDocument(

                    new XElement("greeting", message)

                ).RemoveInvalidXmlCharacters();

                Console.WriteLine(xdoc.ToString());

                Assert.DoesNotThrow(() => XDocument.Parse(xdoc.ToString()));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"XDocument creation error: {ex}");

            }

​

            // This block fails - XDocument parse document containing an  entity expression

            try

            {

                var xDoc = XDocumentExtensions.ParseAndRemoveInvalidXmlCharacters(xmlWithInvalidCharacters);

                Console.WriteLine(xDoc.ToString());

                Assert.DoesNotThrow(() => XDocument.Parse(xDoc.ToString()));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"XDocument parse failure: {ex}");

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1}, {2}, NewLine: {3}).", 

                              System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion,

                              System.Text.Json.JsonSerializer.Serialize(Environment.NewLine));

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​