{"id":405,"date":"2011-05-09T17:44:00","date_gmt":"2011-05-09T17:44:00","guid":{"rendered":"http:\/\/www.ericwhite.com\/home2\/bm8qcmjy\/public_html\/blog\/?p=405"},"modified":"2011-05-09T17:52:01","modified_gmt":"2011-05-09T17:52:01","slug":"custom-formatting-of-xml-using-linq-to-xml-2","status":"publish","type":"post","link":"https:\/\/www.ericwhite.com\/blog\/2011\/05\/09\/custom-formatting-of-xml-using-linq-to-xml-2\/","title":{"rendered":"Custom Formatting of XML using LINQ to XML"},"content":{"rendered":"

On StackOverflow, there is a question (posted by Otaku, an online friend of mine for some time) about how to serialize multiple XML elements on the same line<\/a>.\u00a0 It is a very interesting question.\u00a0 After going down a couple of dead-ends, I realized that it is pretty easy to iterate through an XML tree and do all of the writing to an XmlWriter explicitly, bypassing all of LINQ to XML’s logic for serializing through an XmlWriter.\u00a0 This lets us do just about anything we want to do to the indentation of the XML, while still letting the XmlWriter class do all of the serializing of the XML itself.\u00a0 Some folks at StackOverflow suggested post-processing the XML, but I know from hard experience that it is very difficult to post-process XML and really get it right, including handling CData elements, and etc.\u00a0 By letting the XmlWriter class do all of the output of XML, while injecting just a bit of white space in the right places, we can be confident of the validity of the XML.<\/p>\n

His question: he has XML that looks like this:<\/p>\n


\n<Canvas>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text=\"r\"\/>
\n      <Run Text=\"u\"\/>
\n      <Run Text=\"n\"\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <Run Text=\"far a\"\/>
\n      <Run Text=\"way\"\/>
\n      <Run Text=\" from me\"\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text=\"I\"\/>
\n      <Run Text=\" \"\/>
\n      <Run Text=\"want\"\/>
\n      <LineBreak\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <LineBreak\/>
\n      <Run Text=\"...thi\"\/>
\n      <Run Text=\"s to\"\/>
\n      <LineBreak\/>
\n      <Run Text=\" work\"\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n<\/Canvas>
\n<\/code><\/p>\n

He wants to format it so that it looks like this:<\/p>\n


\n<Canvas>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text=\"r\"\/><Run Text=\"u\"\/><Run Text=\"n\"\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <Run Text=\"far a\"\/><Run Text=\"way\"\/><Run Text=\" from me\"\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text=\"I\"\/><Run Text=\" \"\/><Run Text=\"want\"\/>
\n      <LineBreak\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <LineBreak\/>
\n      <Run Text=\"...thi\"\/><Run Text=\"s to\"\/>
\n      <LineBreak\/>
\n      <Run Text=\" work\"\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n<\/Canvas>
\n<\/code><\/p>\n

The reason he wants to do this is because of some fairly obscure semantics of XAML for Silverlight 3.\u00a0 Read his question on StackOverflow for more detail<\/a>.<\/p>\n

I posted code on StackOverflow that shows how to do that specialized serialization using VB.NET.\u00a0 Of course, actually I wrote the code first in C#, and then after getting it all working, I translated to VB.NET.\u00a0 This post presents the C# code.<\/p>\n

The key to solving this problem is to write a recursive function that iterates through the XML tree, writing the various elements and attributes to specially created XmlWriter objects.\u00a0 There is an ‘outer’ XmlWriter object that writes indented XML, and an ‘inner’ XmlWriter object that writes non-indented XML.<\/p>\n

The recursive function initially uses the ‘outer’ XmlWriter, writing indented XML, until it sees the TextBlock element (an element that triggers a desired change in the indenting behavior).\u00a0 When it encounters the TextBlock element, it creates the ‘inner’ XmlWriter object, writing the child elements of the TextBlock element to it.\u00a0 It also writes custom white space to the ‘inner’ XmlWriter.<\/p>\n

When the ‘inner’ XmlWriter object is finished with writing the TextBlock element, the text that the \u2018inner\u2019 writer wrote is written to the ‘outer’ XmlWriter using the WriteRaw method.<\/p>\n

As I mentioned, the advantages of this approach is that there is no post-processing of the XML.\u00a0 It is extremely difficult to post-process XML and be certain that you have properly handled all cases, including arbitrary text in CData nodes, etc.\u00a0 All of the XML is written using only the XmlWriter class, thereby ensuring that this will always write valid XML.\u00a0 The only exception to this is the specially crafted white-space that is written using the WriteRaw method, which achieves the desired indenting behavior.<\/p>\n

One key point is that the ‘inner’ XmlWriter object’s conformance level is set to ConformanceLevel.Fragment, because the ‘inner’ XmlWriter needs to write XML that does not have a root element.<\/p>\n

To achieve the desired formatting of Run elements (i.e. Run elements that are adjacent have no insignificant white space between them), the code uses the GroupAdjacent extension method.\u00a0 Some time ago, I write a blog post on the GroupAdjacent extension method<\/a>.<\/p>\n

Here is the C# code to do the specialized formatting:<\/p>\n


\nusing System;
\nusing System.Collections.Generic;
\nusing System.Linq;
\nusing System.Text;
\nusing System.Xml;
\nusing System.Xml.Linq;<\/p>\n

public static class Extensions
\n{
\n    public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
\n        this IEnumerable<TSource> source,
\n        Func<TSource, TKey> keySelector)
\n    {
\n        TKey last = default(TKey);
\n        bool haveLast = false;
\n        List<TSource> list = new List<TSource>();<\/p>\n

        foreach (TSource s in source)
\n        {
\n            TKey k = keySelector(s);
\n            if (haveLast)
\n            {
\n                if (!k.Equals(last))
\n                {
\n                    yield return new GroupOfAdjacent<TSource, TKey>(list, last);
\n                    list = new List<TSource>();
\n                    list.Add(s);
\n                    last = k;
\n                }
\n                else
\n                {
\n                    list.Add(s);
\n                    last = k;
\n                }
\n            }
\n            else
\n            {
\n                list.Add(s);
\n                last = k;
\n                haveLast = true;
\n            }
\n        }
\n        if (haveLast)
\n            yield return new GroupOfAdjacent<TSource, TKey>(list, last);
\n    }
\n}<\/p>\n

public class GroupOfAdjacent<TSource, TKey> : IEnumerable<TSource>, IGrouping<TKey, TSource>
\n{
\n    public TKey Key { get; set; }
\n    private List<TSource> GroupList { get; set; }<\/p>\n

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
\n    {
\n        return ((System.Collections.Generic.IEnumerable<TSource>)this).GetEnumerator();
\n    }<\/p>\n

    System.Collections.Generic.IEnumerator<TSource>
\n        System.Collections.Generic.IEnumerable<TSource>.GetEnumerator()
\n    {
\n        foreach (var s in GroupList)
\n            yield return s;
\n    }<\/p>\n

    public GroupOfAdjacent(List<TSource> source, TKey key)
\n    {
\n        GroupList = source;
\n        Key = key;
\n    }
\n}<\/p>\n

class Program
\n{
\n    static void WriteStartElement(XmlWriter writer, XElement e)
\n    {
\n        XNamespace ns = e.Name.Namespace;
\n        writer.WriteStartElement(e.GetPrefixOfNamespace(ns),
\n            e.Name.LocalName, ns.NamespaceName);
\n        foreach (var a in e.Attributes())
\n        {
\n            ns = a.Name.Namespace;
\n            string localName = a.Name.LocalName;
\n            string namespaceName = ns.NamespaceName;
\n            writer.WriteAttributeString(
\n                e.GetPrefixOfNamespace(ns),
\n                localName,
\n                namespaceName.Length == 0 && localName == \"xmlns\" ?
\n                    XNamespace.Xmlns.NamespaceName :
\n                    namespaceName,
\n                a.Value);
\n        }
\n    }<\/p>\n

    public static void WriteElement(XmlWriter writer, XElement e)
\n    {
\n        if (e.Name == \"TextBlock\")
\n        {
\n            WriteStartElement(writer, e);
\n            writer.WriteRaw(Environment.NewLine);<\/p>\n

            \/\/ Create an XML writer that outputs no insignificant white space so that we can
\n            \/\/ write to it and explicitly control white space.
\n            XmlWriterSettings settings = new XmlWriterSettings();
\n            settings.Indent = false;
\n            settings.OmitXmlDeclaration = true;
\n            settings.ConformanceLevel = ConformanceLevel.Fragment;
\n            StringBuilder sb = new StringBuilder();
\n            using (XmlWriter newXmlWriter = XmlWriter.Create(sb, settings))
\n            {
\n                \/\/ Group adjacent runs so that they can be output with no whitespace between them
\n                var groupedRuns = e.Nodes().GroupAdjacent(n =>
\n                {
\n                    XElement element = n as XElement;
\n                    if (element != null && element.Name == \"Run\")
\n                        return true;
\n                    return false;
\n                });
\n                foreach (var g in groupedRuns)
\n                {
\n                    if (g.Key == true)
\n                    {
\n                        \/\/ Write white space so that the line of Run elements is properly indented.
\n                        newXmlWriter.WriteRaw(\"\".PadRight((e.Ancestors().Count() + 1) * 2));
\n                        foreach (var run in g)
\n                            run.WriteTo(newXmlWriter);
\n                        newXmlWriter.WriteRaw(Environment.NewLine);
\n                    }
\n                    else
\n                    {
\n                        foreach (var g2 in g)
\n                        {
\n                            \/\/ Write some white space so that each child element is properly indented.
\n                            newXmlWriter.WriteRaw(\"\".PadRight((e.Ancestors().Count() + 1) * 2));
\n                            g2.WriteTo(newXmlWriter);
\n                            newXmlWriter.WriteRaw(Environment.NewLine);
\n                        }
\n                    }
\n                }
\n            }
\n            writer.WriteRaw(sb.ToString());
\n            writer.WriteRaw(\"\".PadRight(e.Ancestors().Count() * 2));
\n            writer.WriteEndElement();
\n        }
\n        else
\n        {
\n            WriteStartElement(writer, e);
\n            foreach (var n in e.Nodes())
\n            {
\n                XElement element = n as XElement;
\n                if (element != null)
\n                {
\n                    WriteElement(writer, element);
\n                    continue;
\n                }
\n                n.WriteTo(writer);
\n            }
\n            writer.WriteEndElement();
\n        }
\n    }<\/p>\n

    static string ToStringWithCustomWhiteSpace(XElement element)
\n    {
\n        \/\/ Create XmlWriter that indents.
\n        XmlWriterSettings settings = new XmlWriterSettings();
\n        settings.Indent = true;
\n        settings.OmitXmlDeclaration = true;
\n        StringBuilder sb = new StringBuilder();
\n        using (XmlWriter xmlWriter = XmlWriter.Create(sb, settings))
\n            WriteElement(xmlWriter, element);
\n        return sb.ToString();
\n    }<\/p>\n

    static void Main(string[] args)
\n    {
\n        XElement root = XElement.Parse(
\n@\"<Canvas a='1'>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text='r'\/>
\n      <Run Text='u'\/>
\n      <Run Text='n'\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <Run Text='far a'\/>
\n      <Run Text='way'\/>
\n      <Run Text=' from me'\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n  <Grid>
\n    <TextBlock>
\n      <Run Text='I'\/>
\n      <Run Text=' '\/>
\n      <Run Text='want'\/>
\n      <LineBreak\/>
\n    <\/TextBlock>
\n    <TextBlock>
\n      <LineBreak\/>
\n      <Run Text='...thi'\/>
\n      <Run Text='s to'\/>
\n      <LineBreak\/>
\n      <Run Text=' work'\/>
\n    <\/TextBlock>
\n  <\/Grid>
\n<\/Canvas>\");
\n        Console.WriteLine(ToStringWithCustomWhiteSpace(root));
\n    }
\n}
\n<\/code><\/p>\n

And for completeness, here is the VB code:<\/p>\n


\nImports System.Text
\nImports System.Xml<\/p>\n

Public Class GroupOfAdjacent(Of TElement, TKey)
\n    Implements IEnumerable(Of TElement)<\/p>\n

    Private _key As TKey
\n    Private _groupList As List(Of TElement)<\/p>\n

    Public Property GroupList() As List(Of TElement)
\n        Get
\n            Return _groupList
\n        End Get
\n        Set(ByVal value As List(Of TElement))
\n            _groupList = value
\n        End Set
\n    End Property<\/p>\n

    Public ReadOnly Property Key() As TKey
\n        Get
\n            Return _key
\n        End Get
\n    End Property<\/p>\n

    Public Function GetEnumerator() As System.Collections.Generic.IEnumerator(Of TElement) _
\n            Implements System.Collections.Generic.IEnumerable(Of TElement).GetEnumerator
\n        Return _groupList.GetEnumerator
\n    End Function<\/p>\n

    Public Function GetEnumerator1() As System.Collections.IEnumerator _
\n            Implements System.Collections.IEnumerable.GetEnumerator
\n        Return _groupList.GetEnumerator
\n    End Function<\/p>\n

    Public Sub New(ByVal key As TKey)
\n        _key = key
\n        _groupList = New List(Of TElement)
\n    End Sub
\nEnd Class<\/p>\n

Module Module1
\n    <System.Runtime.CompilerServices.Extension()> _
\n    Public Function GroupAdjacent(Of TElement, TKey)(ByVal source As IEnumerable(Of TElement), _
\n                ByVal keySelector As Func(Of TElement, TKey)) As List(Of GroupOfAdjacent(Of TElement, TKey))
\n        Dim lastKey As TKey = Nothing
\n        Dim currentGroup As GroupOfAdjacent(Of TElement, TKey) = Nothing
\n        Dim allGroups As List(Of GroupOfAdjacent(Of TElement, TKey)) = New List(Of GroupOfAdjacent(Of TElement, TKey))()
\n        For Each item In source
\n            Dim thisKey As TKey = keySelector(item)
\n            If lastKey IsNot Nothing And Not thisKey.Equals(lastKey) Then
\n                allGroups.Add(currentGroup)
\n            End If
\n            If Not thisKey.Equals(lastKey) Then
\n                currentGroup = New GroupOfAdjacent(Of TElement, TKey)(keySelector(item))
\n            End If
\n            currentGroup.GroupList.Add(item)
\n            lastKey = thisKey
\n        Next
\n        If lastKey IsNot Nothing Then
\n            allGroups.Add(currentGroup)
\n        End If
\n        Return allGroups
\n    End Function<\/p>\n

    Public Sub WriteStartElement(ByVal writer As XmlWriter, ByVal e As XElement)
\n        Dim ns As XNamespace = e.Name.Namespace
\n        writer.WriteStartElement(e.GetPrefixOfNamespace(ns), _
\n            e.Name.LocalName, ns.NamespaceName)
\n        For Each a In e.Attributes
\n            ns = a.Name.Namespace
\n            Dim localName As String = a.Name.LocalName
\n            Dim namespaceName As String = ns.NamespaceName
\n            writer.WriteAttributeString( _
\n                e.GetPrefixOfNamespace(ns), _
\n                localName, _
\n                IIf(namespaceName.Length = 0 And localName = \"xmlns\", _
\n                    XNamespace.Xmlns.NamespaceName, namespaceName),
\n                a.Value)
\n        Next
\n    End Sub<\/p>\n

    Public Sub WriteElement(ByVal writer As XmlWriter, ByVal e As XElement)
\n        If (e.Name = \"TextBlock\") Then
\n            WriteStartElement(writer, e)
\n            writer.WriteRaw(Environment.NewLine)<\/p>\n

            ' Create an XML writer that outputs no insignificant white space so that we can
\n            ' write to it and explicitly control white space.
\n            Dim settings As XmlWriterSettings = New XmlWriterSettings()
\n            settings.Indent = False
\n            settings.OmitXmlDeclaration = True
\n            settings.ConformanceLevel = ConformanceLevel.Fragment
\n            Dim sb As StringBuilder = New StringBuilder()
\n            Using newXmlWriter As XmlWriter = XmlWriter.Create(sb, settings)
\n                ' Group adjacent runs so that they can be output with no whitespace between them
\n                Dim groupedRuns = e.Nodes().GroupAdjacent( _
\n                    Function(n) As Boolean?
\n                        If TypeOf n Is XElement Then
\n                            Dim element As XElement = n
\n                            If element.Name = \"Run\" Then
\n                                Return True
\n                            End If
\n                            Return False
\n                        End If
\n                        Return False
\n                    End Function)
\n                For Each g In groupedRuns
\n                    If g.Key = True Then
\n                        ' Write white space so that the line of Run elements is properly indented.
\n                        newXmlWriter.WriteRaw(\"\".PadRight((e.Ancestors().Count() + 1) * 2))
\n                        For Each run In g
\n                            run.WriteTo(newXmlWriter)
\n                        Next
\n                        newXmlWriter.WriteRaw(Environment.NewLine)
\n                    Else
\n                        For Each g2 In g
\n                            ' Write some white space so that each child element is properly indented.
\n                            newXmlWriter.WriteRaw(\"\".PadRight((e.Ancestors().Count() + 1) * 2))
\n                            g2.WriteTo(newXmlWriter)
\n                            newXmlWriter.WriteRaw(Environment.NewLine)
\n                        Next
\n                    End If
\n                Next
\n            End Using
\n            writer.WriteRaw(sb.ToString())
\n            writer.WriteRaw(\"\".PadRight(e.Ancestors().Count() * 2))
\n            writer.WriteEndElement()
\n        Else
\n            WriteStartElement(writer, e)
\n            For Each n In e.Nodes
\n                If TypeOf n Is XElement Then
\n                    Dim element = n
\n                    WriteElement(writer, element)
\n                    Continue For
\n                End If
\n                n.WriteTo(writer)
\n            Next
\n            writer.WriteEndElement()
\n        End If
\n    End Sub<\/p>\n

    Function ToStringWithCustomWhiteSpace(ByVal element As XElement) As String
\n        ' Create XmlWriter that indents.
\n        Dim settings As XmlWriterSettings = New XmlWriterSettings()
\n        settings.Indent = True
\n        settings.OmitXmlDeclaration = True
\n        Dim sb As StringBuilder = New StringBuilder()
\n        Using xmlWriter As XmlWriter = xmlWriter.Create(sb, settings)
\n            WriteElement(xmlWriter, element)
\n        End Using
\n        Return sb.ToString()
\n    End Function<\/p>\n

    Sub Main()
\n        Dim myXML As XElement = _
\n            <Canvas>
\n                <Grid>
\n                    <TextBlock>
\n                        <Run Text='r'\/>
\n                        <Run Text='u'\/>
\n                        <Run Text='n'\/>
\n                    <\/TextBlock>
\n                    <TextBlock>
\n                        <Run Text='far a'\/>
\n                        <Run Text='way'\/>
\n                        <Run Text=' from me'\/>
\n                    <\/TextBlock>
\n                <\/Grid>
\n                <Grid>
\n                    <TextBlock>
\n                        <Run Text='I'\/>
\n                        <Run Text=' '\/>
\n                        <Run Text='want'\/>
\n                        <LineBreak\/>
\n                    <\/TextBlock>
\n                    <TextBlock>
\n                        <LineBreak\/>
\n                        <Run Text='...thi'\/>
\n                        <Run Text='s to'\/>
\n                        <LineBreak\/>
\n                        <Run Text=' work'\/>
\n                    <\/TextBlock>
\n                <\/Grid>
\n            <\/Canvas>
\n        Console.Write(ToStringWithCustomWhiteSpace(myXML))
\n        Console.ReadLine()
\n    End Sub<\/p>\n

End Module
\n<\/code><\/p>\n","protected":false},"excerpt":{"rendered":"

Presents some code to iterate through a LINQ to XML tree, manually serializing to an XmlWriter, which allows you to write code to control formatting at a very precise level.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"_s2mail":"","footnotes":""},"categories":[14],"tags":[],"class_list":["post-405","post","type-post","status-publish","format-standard","hentry","category-linq-to-xml"],"_links":{"self":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/405","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/comments?post=405"}],"version-history":[{"count":2,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/405\/revisions"}],"predecessor-version":[{"id":408,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/405\/revisions\/408"}],"wp:attachment":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/media?parent=405"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/categories?post=405"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/tags?post=405"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}