[Fork] [Fork] https://stackoverflow.com/questions/68938488/write-a-huge-string-in-xdocument-setattributevalue | C# Online Compiler

[Fork] [Fork] https://stackoverflow.com/questions/68938488/write-a-huge-string-in-xdocument-setattributevalue 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.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/68938488/write-a-huge-string-in-xdocument-setattributevalue

	public static partial class XmlExtensions
	{
		public static void WriteAttribute(this XmlWriter writer, string localName, IEnumerable<(char [] Buffer, int Length)> valueSegments) =>
			WriteAttribute(writer, null, localName, null, valueSegments);
			
		public static void WriteAttribute(this XmlWriter writer, string localName, string namespaceUri, IEnumerable<(char [] Buffer, int Length)> valueSegments) =>
			WriteAttribute(writer, null, localName, namespaceUri, valueSegments);
		
		public static void WriteAttribute(this XmlWriter writer, string prefix, string localName, string namespaceUri, IEnumerable<(char [] Buffer, int Length)> valueSegments)
		{
			writer.WriteStartAttribute(prefix, localName, namespaceUri);
			char [] surrogateBuffer = null;

			// According to the docs, surrogate pairs cannot be split across calls to WriteChars():
			// https://docs.microsoft.com/en-us/dotnet/api/system.xml.xmlwriter.writechars?view=net-5.0#remarks
			// So if the last character of a segment is a high surrogate, buffer it and write it with the first character of the next buffer.
			foreach (var segment in valueSegments)
			{
				if (segment.Length < 1)
					continue;
				int start = 0;
				if (surrogateBuffer != null && surrogateBuffer[0] != '\0')
				{
					surrogateBuffer[1] = segment.Buffer[start++];
					writer.WriteChars(surrogateBuffer, 0, 2);
					surrogateBuffer[0] = surrogateBuffer[1] = '\0';
				}
				int count = segment.Length - start;
				if (count > 0 && char.IsHighSurrogate(segment.Buffer[segment.Length-1]))
				{
					(surrogateBuffer = surrogateBuffer ?? new char[2])[0] = segment.Buffer[segment.Length-1];
					count--;
				}
				writer.WriteChars(segment.Buffer, start, count);
			}
			writer.WriteEndAttribute();
			if (surrogateBuffer != null && surrogateBuffer[0] != '\0')
				throw new XmlException(string.Format("Unterminated surrogate pair {0}", surrogateBuffer[0]));
		}
	}

	public static class ByteExtensions
	{
		// Copied from this answer https://stackoverflow.com/a/14333437
		// By https://stackoverflow.com/users/445517/codesinchaos
		// To https://stackoverflow.com/questions/311165/how-do-you-convert-a-byte-array-to-a-hexadecimal-string-and-vice-versa
		// And modified to populate a char span rather than return a string.
		public static void ByteToHexBitFiddle(ReadOnlySpan<byte> bytes, Span<char> c)
		{
			if (c.Length < 2* bytes.Length)
				throw new ArgumentException("c.Length < 2* bytes.Length");
			int b;
			for (int i = 0; i < bytes.Length; i++) {
				b = bytes[i] >> 4;
				c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7));
				b = bytes[i] & 0xF;
				c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7));
			}
		}
		
		public static IEnumerable<(char [] segment, int length)> GetHexCharSegments(ReadOnlyMemory<byte> bytes, int chunkSize = 1000)
		{
			var buffer = new char[2*chunkSize];
			var length = bytes.Length;
			int pos = 0;
			while (pos < length - chunkSize)
			{
				ByteExtensions.ByteToHexBitFiddle(bytes.Span.Slice(pos, chunkSize), buffer);
				yield return (buffer, buffer.Length);
				pos += chunkSize;
			}
			ByteExtensions.ByteToHexBitFiddle(bytes.Span.Slice(pos), buffer);
			yield return (buffer, 2*(length - pos));
		}
	}

	public class ElementEventArgs : EventArgs
	{
		public XName Element { get; init; }
		public Stack<XName> ElementStack { get; init; }
	}

	public class NotifyingXmlWriter : XmlWriterProxy
	{
		readonly Stack<XName> elements = new Stack<XName>();

		public NotifyingXmlWriter(XmlWriter baseWriter) : base(baseWriter) { }

		public event EventHandler<ElementEventArgs> OnElementStarted;
		public event EventHandler<ElementEventArgs> OnElementEnded;

		public override void WriteStartElement(string prefix, string localName, string ns)
		{
			base.WriteStartElement(prefix, localName, ns);
			var name = XName.Get(localName, ns);
			elements.Push(name);
			OnElementStarted?.Invoke(this, new ElementEventArgs { Element = name, ElementStack = elements });
		}

		public override void WriteEndElement()
		{
			base.WriteEndElement();
			var name = elements.Pop(); // Pop after base.WriteEndElement() lets the base class throw an exception on a stack error.
			OnElementEnded?.Invoke(this, new ElementEventArgs { Element = name, ElementStack = elements });
		}
	}

	public class XmlWriterProxy : XmlWriter
	{
		// Taken from this answer https://stackoverflow.com/a/32150990/3744182
		// by https://stackoverflow.com/users/3744182/dbc
		// To https://stackoverflow.com/questions/32149676/custom-xmlwriter-to-skip-a-certain-element
		// NOTE: async methods not implemented
		readonly XmlWriter baseWriter;

		public XmlWriterProxy(XmlWriter baseWriter) => this.baseWriter = baseWriter ?? throw new ArgumentNullException();

		protected virtual bool IsSuspended { get { return false; } }

		public override void Close() => baseWriter.Close();

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

		public override string LookupPrefix(string ns) => baseWriter.LookupPrefix(ns);

		public override void WriteBase64(byte[] buffer, int index, int count)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteBase64(buffer, index, count);
		}

		public override void WriteCData(string text)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteCData(text);
		}

		public override void WriteCharEntity(char ch)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteCharEntity(ch);
		}

		public override void WriteChars(char[] buffer, int index, int count)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteChars(buffer, index, count);
		}

		public override void WriteComment(string text)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteComment(text);
		}

		public override void WriteDocType(string name, string pubid, string sysid, string subset)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteDocType(name, pubid, sysid, subset);
		}

		public override void WriteEndAttribute()
		{
			if (IsSuspended)
				return;
			baseWriter.WriteEndAttribute();
		}

		public override void WriteEndDocument()
		{
			if (IsSuspended)
				return;
			baseWriter.WriteEndDocument();
		}

		public override void WriteEndElement()
		{
			if (IsSuspended)
				return;
			baseWriter.WriteEndElement();
		}

		public override void WriteEntityRef(string name)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteEntityRef(name);
		}

		public override void WriteFullEndElement()
		{
			if (IsSuspended)
				return;
			baseWriter.WriteFullEndElement();
		}

		public override void WriteProcessingInstruction(string name, string text)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteProcessingInstruction(name, text);
		}

		public override void WriteRaw(string data)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteRaw(data);
		}

		public override void WriteRaw(char[] buffer, int index, int count)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteRaw(buffer, index, count);
		}

		public override void WriteStartAttribute(string prefix, string localName, string ns)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteStartAttribute(prefix, localName, ns);
		}

		public override void WriteStartDocument(bool standalone) => baseWriter.WriteStartDocument(standalone);

		public override void WriteStartDocument() => baseWriter.WriteStartDocument();

		public override void WriteStartElement(string prefix, string localName, string ns)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteStartElement(prefix, localName, ns);
		}

		public override WriteState WriteState => baseWriter.WriteState;

		public override void WriteString(string text)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteString(text);
		}

		public override void WriteSurrogateCharEntity(char lowChar, char highChar)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteSurrogateCharEntity(lowChar, highChar);
		}

		public override void WriteWhitespace(string ws)
		{
			if (IsSuspended)
				return;
			baseWriter.WriteWhitespace(ws);
		}
	}	

    public class TestClass
    {
        public static void Test()
        {
			TestXDocument(0);
			TestXDocument(1);
			TestXDocument(2);
			TestXDocument(300);
			TestXDocument(999);
			TestXDocument(9999);
			
			Test("", 0);
			Test("", 3333);
			Test(0);
			Test(1);
			Test(2);
			Test(3);
			Test(333);
			Test(3333);
		}
		
        public static void Test(int n)
        {
			Test("a", n);
		}
		
        public static void Test(string prefix, int n)
        {
			var doc = XDocument.Parse(GetXml());
			
			var stringBuilder = new StringBuilder();
			stringBuilder.Append(prefix);
			for (int i = 0; i < n; i++)
				stringBuilder.Append("𩸽");
			using var textWriter = new StringWriter();
			using (var xmlWriter = XmlWriter.Create(textWriter))
			{
				xmlWriter.WriteStartElement("Test");
				xmlWriter.WriteAttribute("AttrbuteName", stringBuilder.GetSegments());
				xmlWriter.WriteEndElement();
			}
			
			var xml = textWriter.ToString();
			Console.WriteLine(xml);
			Assert.IsFalse(xml.Contains("�"));
			Assert.IsTrue(xml.Contains("AttrbuteName=\"" + stringBuilder.ToString() + "\""));
        }
		
		static void TestXDocument(int n)
		{
			var value = new
			{
				RawArtifact = new
				{
					Content = Enumerable.Range(0, n).Select(i => unchecked((byte)i)).ToArray(),
				},
			};
			
			var xdocument = XDocument.Parse(GetXml());
			string fileName = @"Question68941254.xml"; // or whatever

			XNamespace targetNamespace = "";
			XName targetName = targetNamespace + "TheNode";

			using (var textWriter = new StreamWriter(fileName))
			using (var innerXmlWriter = XmlWriter.Create(textWriter, new XmlWriterSettings { Indent = true }))
			using (var xmlWriter = new NotifyingXmlWriter(innerXmlWriter))
			{
				xmlWriter.OnElementStarted += (o, e) =>
				{
					if (e.Element == targetName)
					{
						// Add the attribute with the byte hex value to the target element.
						((XmlWriter)o).WriteAttribute("TheAttribute", ByteExtensions.GetHexCharSegments(value.RawArtifact.Content.AsMemory(), 1024));
					}
				};
				xdocument.WriteTo(xmlWriter);
			}
			
			Console.WriteLine(File.ReadAllText(fileName));
			
			File.Delete(fileName);
		}
		
		static string GetXml() =>
			@"<Root>
<SomeOtherNode>some value</SomeOtherNode>
<TheNode someOtherAttribute=""101""><foo></foo>the node value</TheNode>
<AnotherNode>another value</AnotherNode>
</Root>";
    }
	
	public static partial class StringBuilderExtensions
	{
		public static IEnumerable<(char [] segment, int length)> GetSegments(this StringBuilder sb, int bufferSize = 1024)
		{
			var buffer = new char[bufferSize];
			for (int i = 0; i < sb.Length; i += buffer.Length)
			{
				int length = Math.Min(buffer.Length, sb.Length - i);
				sb.CopyTo(i, buffer, length);
				yield return (buffer, length);
			}
		}
	}

	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.Location.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;
		}
	}

#if false
If you check the [reference source for `XAttribute`](https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XAttribute.cs#L36) you will see that `XAttribute` has `internal string value;` so there is no way to use a `StringBuilder` or `StreamReader` as a value.

This doesn't precisely answer your question, but if you were to write your XML with `XmlWriter` you could write the attribute value in chunks using `XmlWriter.WriteChars()`.  See https://dotnetfiddle.net/InBShg for a demo.

If you are modifying an existing XML file, you might consider a streaming transformation along the lines of [Combining the XmlReader and XmlWriter classes for simple streaming transformations](https://web.archive.org/web/20160214201608/https://blogs.msdn.com/b/mfussell/archive/2005/02/12/371546.aspx) and answers that use it including [File size restriction or limitation in C#](https://stackoverflow.com/a/12500278/3744182), [Edit a large XML file](https://stackoverflow.com/a/48575462/3744182) and [Automating replacing tables from external files](https://stackoverflow.com/a/28903486/3744182).

#if false
		public static void ByteToHexBitFiddle(byte [] bytes, int byteStart, int count, char [] array, int charStart)
		{
			for (int i = byteStart, byteEnd = byteStart + count; i < byteEnd; i++, charStart += 2)
			{
				ByteToHexBitFiddle(bytes[i], array, charStart);
			}
		}
		
		public static void ByteToHexBitFiddle(byte theByte, char [] array, int start)
		{
			var c = array.AsSpan().Slice(start, 2);
			int b;

			b = theByte >> 4;
			c[0] = (char)(55 + b + (((b-10)>>31)&-7));
			b = theByte & 0xF;
			c[1] = (char)(55 + b + (((b-10)>>31)&-7));
		}
#endif

#endif

​x
 
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.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/68938488/write-a-huge-string-in-xdocument-setattributevalue
​
    public static partial class XmlExtensions
    {
        public static void WriteAttribute(this XmlWriter writer, string localName, IEnumerable<(char [] Buffer, int Length)> valueSegments) =>
            WriteAttribute(writer, null, localName, null, valueSegments);
            
        public static void WriteAttribute(this XmlWriter writer, string localName, string namespaceUri, IEnumerable<(char [] Buffer, int Length)> valueSegments) =>
            WriteAttribute(writer, null, localName, namespaceUri, valueSegments);
        
        public static void WriteAttribute(this XmlWriter writer, string prefix, string localName, string namespaceUri, IEnumerable<(char [] Buffer, int Length)> valueSegments)
        {
            writer.WriteStartAttribute(prefix, localName, namespaceUri);
            char [] surrogateBuffer = null;
​
            // According to the docs, surrogate pairs cannot be split across calls to WriteChars():
            // https://docs.microsoft.com/en-us/dotnet/api/system.xml.xmlwriter.writechars?view=net-5.0#remarks
            // So if the last character of a segment is a high surrogate, buffer it and write it with the first character of the next buffer.
            foreach (var segment in valueSegments)
            {
                if (segment.Length < 1)
                    continue;
                int start = 0;
                if (surrogateBuffer != null && surrogateBuffer[0] != '\0')
                {
                    surrogateBuffer[1] = segment.Buffer[start++];
                    writer.WriteChars(surrogateBuffer, 0, 2);
                    surrogateBuffer[0] = surrogateBuffer[1] = '\0';
                }
                int count = segment.Length - start;
                if (count > 0 && char.IsHighSurrogate(segment.Buffer[segment.Length-1]))
                {
                    (surrogateBuffer = surrogateBuffer ?? new char[2])[0] = segment.Buffer[segment.Length-1];
                    count--;
                }
                writer.WriteChars(segment.Buffer, start, count);
            }
            writer.WriteEndAttribute();
            if (surrogateBuffer != null && surrogateBuffer[0] != '\0')
                throw new XmlException(string.Format("Unterminated surrogate pair {0}", surrogateBuffer[0]));
        }
    }
​
    public static class ByteExtensions
    {
        // Copied from this answer https://stackoverflow.com/a/14333437
        // By https://stackoverflow.com/users/445517/codesinchaos
        // To https://stackoverflow.com/questions/311165/how-do-you-convert-a-byte-array-to-a-hexadecimal-string-and-vice-versa
        // And modified to populate a char span rather than return a string.
        public static void ByteToHexBitFiddle(ReadOnlySpan<byte> bytes, Span<char> c)
        {
            if (c.Length < 2* bytes.Length)
                throw new ArgumentException("c.Length < 2* bytes.Length");
            int b;
            for (int i = 0; i < bytes.Length; i++) {
                b = bytes[i] >> 4;
                c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7));
                b = bytes[i] & 0xF;
                c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7));
            }
        }
        
        public static IEnumerable<(char [] segment, int length)> GetHexCharSegments(ReadOnlyMemory<byte> bytes, int chunkSize = 1000)
        {
            var buffer = new char[2*chunkSize];
            var length = bytes.Length;
            int pos = 0;
            while (pos < length - chunkSize)
            {
                ByteExtensions.ByteToHexBitFiddle(bytes.Span.Slice(pos, chunkSize), buffer);
                yield return (buffer, buffer.Length);
                pos += chunkSize;
            }
            ByteExtensions.ByteToHexBitFiddle(bytes.Span.Slice(pos), buffer);
            yield return (buffer, 2*(length - pos));
        }
    }
​
    public class ElementEventArgs : EventArgs
    {
        public XName Element { get; init; }
        public Stack<XName> ElementStack { get; init; }
    }
​
    public class NotifyingXmlWriter : XmlWriterProxy
    {
        readonly Stack<XName> elements = new Stack<XName>();
​
        public NotifyingXmlWriter(XmlWriter baseWriter) : base(baseWriter) { }
​
        public event EventHandler<ElementEventArgs> OnElementStarted;
        public event EventHandler<ElementEventArgs> OnElementEnded;
​
        public override void WriteStartElement(string prefix, string localName, string ns)
        {
            base.WriteStartElement(prefix, localName, ns);
            var name = XName.Get(localName, ns);
            elements.Push(name);
            OnElementStarted?.Invoke(this, new ElementEventArgs { Element = name, ElementStack = elements });
        }
​
        public override void WriteEndElement()
        {
            base.WriteEndElement();
            var name = elements.Pop(); // Pop after base.WriteEndElement() lets the base class throw an exception on a stack error.
            OnElementEnded?.Invoke(this, new ElementEventArgs { Element = name, ElementStack = elements });
        }
    }
​
    public class XmlWriterProxy : XmlWriter
    {
        // Taken from this answer https://stackoverflow.com/a/32150990/3744182
        // by https://stackoverflow.com/users/3744182/dbc
        // To https://stackoverflow.com/questions/32149676/custom-xmlwriter-to-skip-a-certain-element
        // NOTE: async methods not implemented
        readonly XmlWriter baseWriter;
​
        public XmlWriterProxy(XmlWriter baseWriter) => this.baseWriter = baseWriter ?? throw new ArgumentNullException();
​
        protected virtual bool IsSuspended { get { return false; } }
​
        public override void Close() => baseWriter.Close();
​
        public override void Flush() => baseWriter.Flush();
​
        public override string LookupPrefix(string ns) => baseWriter.LookupPrefix(ns);
​
        public override void WriteBase64(byte[] buffer, int index, int count)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteBase64(buffer, index, count);
        }
​
        public override void WriteCData(string text)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteCData(text);
        }
​
        public override void WriteCharEntity(char ch)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteCharEntity(ch);
        }
​
        public override void WriteChars(char[] buffer, int index, int count)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteChars(buffer, index, count);
        }
​
        public override void WriteComment(string text)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteComment(text);
        }
​
        public override void WriteDocType(string name, string pubid, string sysid, string subset)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteDocType(name, pubid, sysid, subset);
        }
​
        public override void WriteEndAttribute()
        {
            if (IsSuspended)
                return;
            baseWriter.WriteEndAttribute();
        }
​
        public override void WriteEndDocument()
        {
            if (IsSuspended)
                return;
            baseWriter.WriteEndDocument();
        }
​
        public override void WriteEndElement()
        {
            if (IsSuspended)
                return;
            baseWriter.WriteEndElement();
        }
​
        public override void WriteEntityRef(string name)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteEntityRef(name);
        }
​
        public override void WriteFullEndElement()
        {
            if (IsSuspended)
                return;
            baseWriter.WriteFullEndElement();
        }
​
        public override void WriteProcessingInstruction(string name, string text)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteProcessingInstruction(name, text);
        }
​
        public override void WriteRaw(string data)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteRaw(data);
        }
​
        public override void WriteRaw(char[] buffer, int index, int count)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteRaw(buffer, index, count);
        }
​
        public override void WriteStartAttribute(string prefix, string localName, string ns)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteStartAttribute(prefix, localName, ns);
        }
​
        public override void WriteStartDocument(bool standalone) => baseWriter.WriteStartDocument(standalone);
​
        public override void WriteStartDocument() => baseWriter.WriteStartDocument();
​
        public override void WriteStartElement(string prefix, string localName, string ns)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteStartElement(prefix, localName, ns);
        }
​
        public override WriteState WriteState => baseWriter.WriteState;
​
        public override void WriteString(string text)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteString(text);
        }
​
        public override void WriteSurrogateCharEntity(char lowChar, char highChar)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteSurrogateCharEntity(lowChar, highChar);
        }
​
        public override void WriteWhitespace(string ws)
        {
            if (IsSuspended)
                return;
            baseWriter.WriteWhitespace(ws);
        }
    }   
​
    public class TestClass
    {
        public static void Test()
        {
            TestXDocument(0);
            TestXDocument(1);
            TestXDocument(2);
            TestXDocument(300);
            TestXDocument(999);
            TestXDocument(9999);
            
            Test("", 0);
            Test("", 3333);
            Test(0);
            Test(1);
            Test(2);
            Test(3);
            Test(333);
            Test(3333);
        }
        
        public static void Test(int n)
        {
            Test("a", n);
        }
        
        public static void Test(string prefix, int n)
        {
            var doc = XDocument.Parse(GetXml());
            
            var stringBuilder = new StringBuilder();
            stringBuilder.Append(prefix);
            for (int i = 0; i < n; i++)
                stringBuilder.Append("𩸽");
            using var textWriter = new StringWriter();
            using (var xmlWriter = XmlWriter.Create(textWriter))
            {
                xmlWriter.WriteStartElement("Test");
                xmlWriter.WriteAttribute("AttrbuteName", stringBuilder.GetSegments());
                xmlWriter.WriteEndElement();
            }
            
            var xml = textWriter.ToString();
            Console.WriteLine(xml);
            Assert.IsFalse(xml.Contains("�"));
            Assert.IsTrue(xml.Contains("AttrbuteName=\"" + stringBuilder.ToString() + "\""));
        }
        
        static void TestXDocument(int n)
        {
            var value = new
            {
                RawArtifact = new
                {
                    Content = Enumerable.Range(0, n).Select(i => unchecked((byte)i)).ToArray(),
                },
            };
            
            var xdocument = XDocument.Parse(GetXml());
            string fileName = @"Question68941254.xml"; // or whatever
​
            XNamespace targetNamespace = "";
            XName targetName = targetNamespace + "TheNode";
​
            using (var textWriter = new StreamWriter(fileName))
            using (var innerXmlWriter = XmlWriter.Create(textWriter, new XmlWriterSettings { Indent = true }))
            using (var xmlWriter = new NotifyingXmlWriter(innerXmlWriter))
            {
                xmlWriter.OnElementStarted += (o, e) =>
                {
                    if (e.Element == targetName)
                    {
                        // Add the attribute with the byte hex value to the target element.
                        ((XmlWriter)o).WriteAttribute("TheAttribute", ByteExtensions.GetHexCharSegments(value.RawArtifact.Content.AsMemory(), 1024));
                    }
                };
                xdocument.WriteTo(xmlWriter);
            }
            
            Console.WriteLine(File.ReadAllText(fileName));
            
            File.Delete(fileName);
        }
        
        static string GetXml() =>
            @"<Root>
<SomeOtherNode>some value</SomeOtherNode>
<TheNode someOtherAttribute=""101""><foo></foo>the node value</TheNode>
<AnotherNode>another value</AnotherNode>
</Root>";
    }
    
    public static partial class StringBuilderExtensions
    {
        public static IEnumerable<(char [] segment, int length)> GetSegments(this StringBuilder sb, int bufferSize = 1024)
        {
            var buffer = new char[bufferSize];
            for (int i = 0; i < sb.Length; i += buffer.Length)
            {
                int length = Math.Min(buffer.Length, sb.Length - i);
                sb.CopyTo(i, buffer, length);
                yield return (buffer, length);
            }
        }
    }
​
    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.Location.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;
        }
    }
​
#if false
If you check the [reference source for `XAttribute`](https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.Xml.Linq/src/System/Xml/Linq/XAttribute.cs#L36) you will see that `XAttribute` has `internal string value;` so there is no way to use a `StringBuilder` or `StreamReader` as a value.
​
This doesn't precisely answer your question, but if you were to write your XML with `XmlWriter` you could write the attribute value in chunks using `XmlWriter.WriteChars()`.  See https://dotnetfiddle.net/InBShg for a demo.
​
If you are modifying an existing XML file, you might consider a streaming transformation along the lines of [Combining the XmlReader and XmlWriter classes for simple streaming transformations](https://web.archive.org/web/20160214201608/https://blogs.msdn.com/b/mfussell/archive/2005/02/12/371546.aspx) and answers that use it including [File size restriction or limitation in C#](https://stackoverflow.com/a/12500278/3744182), [Edit a large XML file](https://stackoverflow.com/a/48575462/3744182) and [Automating replacing tables from external files](https://stackoverflow.com/a/28903486/3744182).
​
#if false
        public static void ByteToHexBitFiddle(byte [] bytes, int byteStart, int count, char [] array, int charStart)
        {
            for (int i = byteStart, byteEnd = byteStart + count; i < byteEnd; i++, charStart += 2)
            {
                ByteToHexBitFiddle(bytes[i], array, charStart);
            }
        }
        
        public static void ByteToHexBitFiddle(byte theByte, char [] array, int start)
        {
            var c = array.AsSpan().Slice(start, 2);
            int b;
​
            b = theByte >> 4;
            c[0] = (char)(55 + b + (((b-10)>>31)&-7));
            b = theByte & 0xF;
            c[1] = (char)(55 + b + (((b-10)>>31)&-7));
        }
#endif
​
#endif
​
​

View IL Code