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.Threading;

using System.Threading.Tasks;

using System.Diagnostics.CodeAnalysis;

​

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

​

//https://stackoverflow.com/questions/78090825/c-sharp-xmlserializer-output-multiple-xml-fragments-controlling-new-lines

​

#nullable enable

​

    public static partial class XmlExtensions

    {

        const string FirstCommentText = "first";

        const string FirstComment = $"<!--{FirstCommentText}-->";

        const string SubsequentCommentText = "subsequent";

        const string SubsequentComment = $"<!--{SubsequentCommentText}-->";

        static Encoding Utf8EncodingNoBom { get; } = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

        public static void SerializeFragmentsToXml<T>(this IEnumerable<T> enumerable, Stream stream, XmlSerializer? serializer = null, XmlSerializerNamespaces? ns = null)

        {

            string newLine = "\n";

            var settings = new XmlWriterSettings()

            {

                ConformanceLevel = ConformanceLevel.Fragment,

                NamespaceHandling = NamespaceHandling.Default,

                NewLineChars = newLine,

                Encoding = Utf8EncodingNoBom, // supress BOM

                Indent = true,

                NewLineHandling = NewLineHandling.Replace,

                OmitXmlDeclaration = true,

                WriteEndDocumentOnClose = false,

                CloseOutput = false, 

                CheckCharacters = false,

                NewLineOnAttributes = false,

            };

            serializer ??= new XmlSerializer(typeof(T));

            ns ??= new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });

​

            using var innerTextWriter = new StreamWriter(stream, encoding : Utf8EncodingNoBom, leaveOpen  : true) { NewLine = newLine };

            using var textWriter = new FakeCommentRemovingTextWriter(innerTextWriter, new(FirstComment, ""), new(SubsequentComment, newLine)) { NewLine = newLine };

            using var xmlWriter = XmlWriter.Create(textWriter, settings);

​

            bool first = true;

            foreach (var item in enumerable)

            {

                xmlWriter.WriteComment(first ? FirstCommentText : SubsequentCommentText);

                serializer.Serialize(xmlWriter, item, ns);

                // XmlWriter buffers its output, so Flush() is required  to ensure that the fake comments are not split across calls to Write().

                xmlWriter.Flush(); 

                first = false;

            }

        }

        private class FakeCommentRemovingTextWriter : TextWriterDecorator

        {

            readonly KeyValuePair<string, string> [] replacements;

            public FakeCommentRemovingTextWriter(TextWriter baseWriter, params KeyValuePair<string, string> [] replacements) : base(baseWriter, true) => this.replacements = replacements;

            public override void Write(ReadOnlySpan<char> buffer)

            {

                foreach (var replacement in replacements)

                {

                    int index;

                    if ((index = StartsWithIgnoringWhitespace(buffer, replacement.Key)) >= 0)

                    {

                        if (index > 0)

                            base.Write(buffer.Slice(0, index));

                        buffer = buffer.Slice(index).Slice(replacement.Key.Length);

                        if (buffer.StartsWith(NewLine))

                            buffer = buffer.Slice(NewLine.Length);

                        if (!string.IsNullOrEmpty(replacement.Value))

                            base.Write(replacement.Value);

                    }

                }

                base.Write(buffer);

            }

            static int StartsWithIgnoringWhitespace(ReadOnlySpan<char> buffer, ReadOnlySpan<char> value)

            {

                for (int index = 0; index < buffer.Length; index++)

                {

                    if (buffer.Slice(index).StartsWith(value))

                        return index;

                    if (!XmlConvert.IsWhitespaceChar(buffer[index]) || index >= buffer.Length - value.Length)

                        break;

                }

                return -1;

            }

        }

    }

​

    public class TextWriterDecorator : TextWriter

    {

        // Override the same methods that are overridden in https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/IO/StringWriter.cs.

        TextWriter? baseWriter; // null when disposed

        readonly bool disposeBase;

        readonly Encoding baseEncoding;

​

        public TextWriterDecorator(TextWriter baseWriter, bool disposeBase = true) => 

            (this.baseWriter, this.disposeBase, this.baseEncoding) = (baseWriter ?? throw new ArgumentNullException(nameof(baseWriter)), disposeBase, baseWriter.Encoding);

​

        protected TextWriter BaseWriter => baseWriter == null ? throw new ObjectDisposedException(GetType().Name) : baseWriter;

        public override Encoding Encoding => baseEncoding;

        public override IFormatProvider FormatProvider => baseWriter?.FormatProvider ?? base.FormatProvider;

        [AllowNull] public override string NewLine 

        { 

            get => baseWriter?.NewLine ?? base.NewLine; 

            set

            {   

                if (baseWriter != null)

                    baseWriter.NewLine = value;

                base.NewLine = value;

            }

        }

​

        public override void Flush() => BaseWriter.Flush();

        public sealed override void Close() => Dispose(true);

        public override void Write(char value) => BaseWriter.Write(value);

        public sealed override void Write(char[] buffer, int index, int count) => this.Write(buffer.AsSpan(index, count));

        public override void Write(ReadOnlySpan<char> buffer) => BaseWriter.Write(buffer);

        public sealed override void Write(string? value) => Write(value.AsSpan());

​

        public override Task WriteAsync(char value) => BaseWriter.WriteAsync(value);

        public sealed override Task WriteAsync(string? value) => WriteAsync(value.AsMemory());

        public sealed override Task WriteAsync(char[] buffer, int index, int count) => WriteAsync(buffer.AsMemory(index, count));

        public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) => BaseWriter.WriteAsync(buffer, cancellationToken);

        //public virtual Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default) - no need to override

​

        public override Task WriteLineAsync(char value) => BaseWriter.WriteLineAsync(value);

        public sealed override Task WriteLineAsync(string? value) => WriteLineAsync(value.AsMemory());

        public override Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default) => BaseWriter.WriteLineAsync(value, cancellationToken);

        public sealed override Task WriteLineAsync(char[] buffer, int index, int count) => WriteLineAsync(buffer.AsMemory(index, count));

        public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) => BaseWriter.WriteLineAsync(buffer, cancellationToken);

        public override Task FlushAsync() => BaseWriter.FlushAsync();

        public override Task FlushAsync(CancellationToken cancellationToken) => BaseWriter.FlushAsync(cancellationToken);

​

        protected override void Dispose(bool disposing)

        {

            try

            {

                if (disposing)

                {

                    if (Interlocked.Exchange(ref this.baseWriter, null) is {} writer)

                        if (disposeBase)

                            writer.Dispose();

                        else

                            writer.Flush();

                }

            }

            finally

            {

                base.Dispose(disposing);

            }

        }

​

        public override async ValueTask DisposeAsync()

        {

            try

            {

                if (Interlocked.Exchange(ref this.baseWriter, null) is {} writer)

                    if (disposeBase)

                        await writer.DisposeAsync().ConfigureAwait(false);

                    else

                        await writer.FlushAsync().ConfigureAwait(false);

            }

            finally

            {

                await base.DisposeAsync().ConfigureAwait(false);

            }

        }

        public override string ToString() => string.Format("{0}: {1}", GetType().Name, baseWriter?.ToString() ?? "disposed");

    }

    // -----

​

    [System.Xml.Serialization.XmlTypeAttribute(TypeName = "flyingMonkey", Namespace=null)]

    public class FlyingMonkey

    {

        [System.Xml.Serialization.XmlAttributeAttribute()]

        public string name;

​

        public Limb[] limbs;

​

        public static FlyingMonkey Create(string? name = null) =>

            new FlyingMonkey()

            {

                name = name ?? "Koko",

                limbs = new Limb[]

                {

                    new Limb() { name = "leg" }, new Limb() { name = "arm" },

                    new Limb() { name = "tail" }, new Limb() { name = "wing" },

                }

            };

    }

​

    [System.Xml.Serialization.XmlTypeAttribute(TypeName = "limb", Namespace=null)]

    public class Limb

    {

        [System.Xml.Serialization.XmlAttributeAttribute()]

        public string name;

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var items = new [] { "Koko", "POCO", "Loco" }.Select(n => FlyingMonkey.Create(n));

            using var stream = new MemoryStream(); // Replace with some FileStream when serializing to disk

            var serializer = new XmlSerializer(typeof(FlyingMonkey), defaultNamespace: null);

            items.SerializeFragmentsToXml(stream, serializer : serializer);

            var xml = Encoding.UTF8.GetString(stream.GetBuffer().AsSpan(0, (int)stream.Length));

​

            Console.WriteLine(xml);

        }

    }

​

    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;

            }

        }

    }

​