{"id":187,"date":"2011-02-07T20:38:29","date_gmt":"2011-02-07T20:38:29","guid":{"rendered":"http:\/\/www.ericwhite.com\/home2\/bm8qcmjy\/public_html\/blog\/?p=187"},"modified":"2011-02-24T22:58:16","modified_gmt":"2011-02-24T22:58:16","slug":"generating-c-code-from-an-xml-tree-using-virtual-extension-methods","status":"publish","type":"post","link":"https:\/\/www.ericwhite.com\/blog\/2011\/02\/07\/generating-c-code-from-an-xml-tree-using-virtual-extension-methods\/","title":{"rendered":"Generating C# code from an XML Tree using Virtual Extension Methods"},"content":{"rendered":"

One integral part of my scheme for building a document generation system is to write some code that generates C# code to create an arbitrary XML tree. I want to transform the markup for the main document part into C# code that will produce that main document part, with the exception that at various points where I find content controls, I want to alter the transformation as appropriate. The first task is to write code that produces C# code that will create any arbitrary XML tree.<\/p>\n

This post is the fifth in a series of blog posts. Here is the complete list: Generating Open XML WordprocessingML Documents Blog Post Series<\/a><\/p>\n

To demonstrate what I mean by code that generates code, here is a small snippet that parses a string, creates an XML tree, and then prints the code that the XElementToCode method produces:
\n
\nXElement e = XElement.Parse(
\n@\"<Root xmlns='http:\/\/www.ericwhite.com'>
\n  <Child>This is a text node.<\/Child>
\n  <!--Here is a comment.-->
\n<\/Root>\");
\nConsole.WriteLine(\"var z = {0};\", LtxToCode.XElementToCode(e));
\n<\/code><\/p>\n

This produces the following automatically written code:
\n
\nvar z = new XElement(\"{http:\/\/www.ericwhite.com}Root\",
\n  new XAttribute(\"xmlns\", @\"http:\/\/www.ericwhite.com\"),
\n  new XElement(\"{http:\/\/www.ericwhite.com}Child\",
\n    new XText(@\"This is a text node.\")
\n  ),
\n  new XComment(@\"Here is a comment.\")
\n);
\n<\/code><\/p>\n

The code that I present in this post uses expanded XML names, which deserve a bit of an explanation.<\/p>\n

Expanded XML Names<\/h1>\n

In LINQ to XML, an expanded name is an approach that enables specification of a namespace and local name in a single string. The gist of it (which you can see in the example above) is that the namespace is enclosed in curly braces, followed by the local name.<\/p>\n

The normal idiom when working with names and namespaces in LINQ to XML is to declare and initialize an XNamespace object, and then use the overload of the \u2018+\u2019 operator to combine the namespace with a local name to create a fully qualified name:
\n
\nXNamespace ew = \"http:\/\/www.ericwhite.com\";
\nXElement root = new XElement(ew + \"Root\");
\nConsole.WriteLine(root);
\n<\/code><\/p>\n

This snippet is identical in functionality to the following example, which uses an expanded name:
\n
\nXElement root = new XElement(\"{http:\/\/www.ericwhite.com}Root\");
\nConsole.WriteLine(root);
\n<\/code><\/p>\n

While the second approach is perhaps marginally slower than the first approach, it is far easier to generate code that uses the second approach. If I used the first approach, I would need to setup a dictionary that maps namespace names to XNamespace object names, and then appropriately generate code that uses the correct XNamespace objects. It is a fair amount of housekeeping. So instead of using that approach, the generated code specifies fully qualified names using expanded names.<\/p>\n

One note about the LINQ to XML programming interface: When you call the ToString method on an XName object, the returned string is an expanded name. For instance, the following code prints the fully qualified name of an element:
\n
\nXElement root = XElement.Parse(\"<Root xmlns='http:\/\/www.ericwhite.com'\/>\");
\nConsole.WriteLine(root.Name);
\n<\/code><\/p>\n

This outputs the expanded name:
\n
\n{http:\/\/www.ericwhite.com}Root
\n<\/code><\/p>\n

About the Example<\/h1>\n

The code in the following example uses extension methods to implement a recursive transform from the XML tree to code that will create the XML tree.\u00a0 The example contains a few sample XML documents that it converts to code.\u00a0 It produces a C# that you can compile and run \u2013 the C# code instantiates two XML trees \u2013 one using the XElement.Parse method, and another using the C# code that is generated by the example.\u00a0 The example then uses DeepEquals to validate that the two trees are identical.<\/p>\n

To run the example:<\/p>\n

Create a new C# console application<\/p>\n

Copy and paste the following code into Program.cs.<\/p>\n

Run the example.\u00a0 This produces a new file, GeneratedTestProgram.cs.\u00a0 You can examine the generated code for each XML tree in the generated program.<\/p>\n

Next, we want to validate that the generated code actually generates the XML tree that it should.\u00a0 Create a new C# console application, replace Program.cs in the new program with the generated program, and then run it to validate that the generated code produced the correct XML tree.<\/p>\n

This example simulates the use of virtual extension methods, which made the example very easy to write.\u00a0 In the next post, I\u2019ll explain virtual extension methods.
\n
\nusing System;
\nusing System.Collections.Generic;
\nusing System.IO;
\nusing System.Linq;
\nusing System.Text;
\nusing System.Xml.Linq;<\/p>\n

public static class LocalExtensions
\n{
\n    public static string StringConcatenate(this IEnumerable<string> source)
\n    {
\n        StringBuilder sb = new StringBuilder();
\n        foreach (string item in source)
\n            sb.Append(item);
\n        return sb.ToString();
\n    }
\n}<\/p>\n

public static class LtxToCode
\n{
\n    public static XNamespace w = \"http:\/\/schemas.openxmlformats.org\/wordprocessingml\/2006\/main\";
\n    public static XNamespace ew = \"http:\/\/www.ericwhite.com\/xmlcodegeneration\";<\/p>\n

    private static string Indentation(XObject xObject)
\n    {
\n        XAttribute attribute = xObject as XAttribute;
\n        if (attribute != null)
\n            return \"\".PadRight((attribute.Parent.Ancestors().Count() + 1 +
\n                (attribute.Parent.Document != null ? 1 : 0)) * 2, ' ');
\n        XElement element = xObject as XElement;
\n        if (element != null)
\n            return \"\".PadRight((element.Ancestors().Count() +
\n                (element.Document != null ? 1 : 0)) * 2, ' ');
\n        XDocument document = xObject as XDocument;
\n        if (document != null)
\n            return \"\";
\n        XProcessingInstruction pi = xObject as XProcessingInstruction;
\n        if (pi != null)
\n            return \"\".PadRight((pi.Ancestors().Count() +
\n                (pi.Document != null ? 1 : 0)) * 2, ' ');
\n        XNode node = xObject as XNode;
\n        if (node != null)
\n            if (node.Parent != null)
\n                return \"\".PadRight((node.Parent.Ancestors().Count() +
\n                    1 + (node.Document != null ? 1 : 0)) * 2, ' ');
\n            else
\n                return \"\";
\n        throw new CodeGenerationException(\"Internal error\");
\n    }<\/p>\n

    public static string ToCode(this XObject xObject)
\n    {
\n        XAttribute a = xObject as XAttribute;
\n        if (a != null)
\n            return a.ToCode();
\n        XElement element = xObject as XElement;
\n        if (element != null)
\n            return element.ToCode();
\n        XCData cdata = xObject as XCData;
\n        if (cdata != null)
\n            return cdata.ToCode();
\n        XText text = xObject as XText;
\n        if (text != null)
\n            return text.ToCode();
\n        XComment comment = xObject as XComment;
\n        if (comment != null)
\n            return comment.ToCode();
\n        XProcessingInstruction pi = xObject as XProcessingInstruction;
\n        if (pi != null)
\n            return pi.ToCode();
\n        throw new CodeGenerationException(\"Internal error\");
\n    }<\/p>\n

    public static string ToCode(this XDocument document)
\n    {
\n        var s = \"new XDocument(\" + Environment.NewLine +
\n            (document.Declaration != null ?
\n                String.Format(\"  new XDeclaration(\\\"{0}\\\", \\\"{1}\\\", \\\"{2}\\\"),\" +
\n                Environment.NewLine,
\n                document.Declaration.Version, document.Declaration.Encoding,
\n                document.Declaration.Standalone) :
\n                \"\") +
\n            TrimFinalComma(document
\n                .Nodes().Select(n => n.ToCode()).StringConcatenate()) +
\n            \")\";
\n        return s;
\n    }<\/p>\n

    public static string ToCode(this XElement element)
\n    {
\n        var c = element
\n            .Attributes()
\n            .Cast<XObject>()
\n            .Concat(element.Nodes().Cast<XObject>());
\n        if (element.Name == ew + \"Literal\")
\n            return element.Value;
\n        if (c.Count() == 0)
\n            return Indentation(element) +
\n                String.Format(\"new XElement(\\\"{0}\\\"),\" + Environment.NewLine,
\n                element.Name);
\n        else
\n            return Indentation(element) +
\n                String.Format(\"new XElement(\\\"{0}\\\",\" + Environment.NewLine,
\n                    element.Name) +
\n                TrimFinalComma(c.Select(n => n.ToCode()).StringConcatenate()) +
\n                Indentation(element) + \"),\" + Environment.NewLine;
\n    }<\/p>\n

    public static string ToCode(this XAttribute attribute)
\n    {
\n        return Indentation(attribute) +
\n            String.Format(\"new XAttribute(\\\"{0}\\\", @\\\"{1}\\\"),\" + Environment.NewLine,
\n            attribute.Name, attribute.Value.Replace(\"\\\"\", \"\\\"\\\"\"));
\n    }<\/p>\n

    public static string ToCode(this XText text)
\n    {
\n        return Indentation(text) +
\n            String.Format(\"new XText(@\\\"{0}\\\"),\" + Environment.NewLine, text.Value.Replace(\"\\\"\", \"\\\"\\\"\"));
\n    }<\/p>\n

    public static string ToCode(this XComment comment)
\n    {
\n        return Indentation(comment) +
\n            String.Format(\"new XComment(@\\\"{0}\\\"),\" + Environment.NewLine, comment.Value.Replace(\"\\\"\", \"\\\"\\\"\"));
\n    }<\/p>\n

    public static string ToCode(this XProcessingInstruction pi)
\n    {
\n        return Indentation(pi) +
\n            String.Format(\"new XProcessingInstruction(@\\\"{0}\\\", @\\\"{1}\\\"),\" +
\n                Environment.NewLine, pi.Target.Replace(\"\\\"\", \"\\\"\\\"\"), pi.Data.Replace(\"\\\"\", \"\\\"\\\"\"));
\n    }<\/p>\n

    public static string ToCode(this XCData cdata)
\n    {
\n        return Indentation(cdata) +
\n            String.Format(\"new XCData(@\\\"{0}\\\"),\" + Environment.NewLine, cdata.Value.Replace(\"\\\"\", \"\\\"\\\"\"));
\n    }<\/p>\n

    private static string TrimFinalComma(string code)
\n    {
\n        if (code.EndsWith(\",\" + Environment.NewLine))
\n            return code.Substring(0, code.Length - (\",\" + Environment.NewLine).Length) +
\n                Environment.NewLine;
\n        return code;
\n    }<\/p>\n

    public static string XElementToCode(XElement element)
\n    {
\n        string code = element.ToCode();
\n        if (code.EndsWith(\",\" + Environment.NewLine))
\n            return code.Substring(0, code.Length - (\",\" + Environment.NewLine).Length);
\n        return code;
\n    }<\/p>\n

    public static string XDocumentToCode(XDocument document)
\n    {
\n        string code = document.ToCode();
\n        if (code.EndsWith(\",\" + Environment.NewLine))
\n            return code.Substring(0, code.Length - (\",\" + Environment.NewLine).Length);
\n        return code;
\n    }<\/p>\n

    public class CodeGenerationException : Exception
\n    {
\n        public CodeGenerationException(string message)
\n            : base(message)
\n        {
\n        }
\n    }
\n}<\/p>\n

public class GenerateDocumentException : Exception
\n{
\n    public GenerateDocumentException(string message)
\n        : base(message)
\n    {
\n    }
\n}<\/p>\n

class Program
\n{
\n    static string[] testXml = new[] {
\n@\"<Root a=\"\"1\"\" b=\"\"2\"\"\/>\",<\/p>\n

@\"<?xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\" standalone=\"\"yes\"\"?>
\n<Root>
\n  <Child> abc <\/Child>
\n  <Child xmlns:space=\"\"preserve\"\"> abc <\/Child>
\n<\/Root>\",<\/p>\n

@\"<?xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\" standalone=\"\"yes\"\"?>
\n<Root><![CDATA[foo]]><\/Root>\",<\/p>\n

@\"<?xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\" standalone=\"\"yes\"\"?>
\n<Root><Child\/><\/Root>\",<\/p>\n

@\"<?xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\" standalone=\"\"yes\"\"?>
\n<Root\/>\",<\/p>\n

@\"<Root xmlns=\"\"http:\/\/www.ericwhite.com\/aaaaa\"\">
\n  <Child xmlns=\"\"http:\/\/www.ericwhite.com\/child\"\">
\n    <Element att=\"\"1\"\"
\n             b:att2=\"\"2\"\"
\n             xmlns:b=\"\"http:\/\/www.ericwhite.com\/bbbbb\"\">abc<\/Element>
\n  <\/Child>
\n<\/Root>\",<\/p>\n

@\"<a:Root xmlns:a=\"\"http:\/\/www.ericwhite.com\"\">abc<\/a:Root>\",<\/p>\n

@\"<a:Root xmlns:a=\"\"http:\/\/www.ericwhite.com\"\">abc<!--a comment -->def<\/a:Root>\",<\/p>\n

@\"<Root>abc<\/Root>\",<\/p>\n

@\"<Root att1=\"\"1\"\" att2=\"\"2\"\"\/>\",<\/p>\n

@\"<Root\/>\",<\/p>\n

@\"<Root att1=\"\"1\"\">
\n  <Child>
\n    <Gc1>abc<b\/>def<\/Gc1>
\n  <\/Child>
\n  <Child>
\n    <Gc2>abc<\/Gc2>
\n  <\/Child>
\n<\/Root>\",<\/p>\n

@\"<?xml version=\"\"1.0\"\" encoding=\"\"UTF-8\"\" standalone=\"\"yes\"\"?><\/p>\n

<?mso-application progid=\"\"Word.Document\"\"?><\/p>\n

<!--This is a comment at the root level.  There are also white space nodes at the root level.--><\/p>\n

<pkg:package xmlns:pkg=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/xmlPackage\"\">
\n  <pkg:part pkg:name=\"\"\/_rels\/.rels\"\"
\n            pkg:contentType=\"\"application\/vnd.openxmlformats-package.relationships+xml\"\"
\n            pkg:padding=\"\"512\"\">
\n    <pkg:xmlData>
\n      <Relationships
\n          xmlns=\"\"http:\/\/schemas.openxmlformats.org\/package\/2006\/relationships\"\">
\n        <Relationship Id=\"\"rId3\"\"
\n                      Type=\"\"http:\/\/schemas.openxmlformats.org\"\"
\n                      Target=\"\"docProps\/app.xml\"\"\/>
\n        <Relationship Id=\"\"rId2\"\"
\n                      Type=\"\"http:\/\/schemas.openxmlformats.org\"\"
\n                      Target=\"\"docProps\/core.xml\"\"\/>
\n        <Relationship Id=\"\"rId1\"\"
\n                      Type=\"\"http:\/\/schemas.openxmlformats.org\"\"
\n                      Target=\"\"word\/document.xml\"\"\/>
\n      <\/Relationships>
\n    <\/pkg:xmlData>
\n  <\/pkg:part>
\n<\/pkg:package>\",
\n};<\/p>\n

    static void Main(string[] args)
\n    {
\n        string st1 = (@\"using System;
\nusing System.Collections.Generic;
\nusing System.Linq;
\nusing System.Text;
\nusing System.Xml.Linq;<\/p>\n

namespace ConsoleApplication1
\n{
\n    class Program
\n    {
\n        static void Main(string[] args)
\n        {
\n\");
\n        StringBuilder sb = new StringBuilder();
\n        \/\/ test as XElement
\n        for (int i = 0; i < testXml.Length; i++)
\n        {
\n            sb.Append(
\n                String.Format(\"var xElementSourceTree{0} = XElement.Parse(@\\\"{1}\\\");\",
\n                i, testXml[i].Replace(\"\\\"\", \"\\\"\\\"\")));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(\"var xElementCodeTree{0} = {1};\",
\n                i, LtxToCode.XElementToCode(XElement.Parse(testXml[i]))));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n                \"if (XNode.DeepEquals(xElementSourceTree{0}, xElementCodeTree{0}))\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n                \"    Console.WriteLine(\\\"XElement Test {0} Passed\\\");\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(\"else\");
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n                \"    Console.WriteLine(\\\"XElement Test {0} Failed\\\");\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(Environment.NewLine);
\n        }
\n        \/\/ test as XDocument
\n        for (int i = 0; i < testXml.Length; i++)
\n        {
\n            sb.Append(String.Format(
\n                \"var xDocumentSourceTree{0} = XDocument.Parse(@\\\"{1}\\\");\",
\n                i, testXml[i].Replace(\"\\\"\", \"\\\"\\\"\")));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(\"var xDocumentCodeTree{0} = {1};\",
\n                i, LtxToCode.XDocumentToCode(XDocument.Parse(testXml[i]))));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n              \"if (XNode.DeepEquals(xDocumentSourceTree{0}, xDocumentCodeTree{0}))\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n                \"    Console.WriteLine(\\\"XDocument Test {0} Passed\\\");\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(\"else\");
\n            sb.Append(Environment.NewLine);
\n            sb.Append(String.Format(
\n                \"    Console.WriteLine(\\\"XDocument Test {0} Failed\\\");\", i));
\n            sb.Append(Environment.NewLine);
\n            sb.Append(Environment.NewLine);
\n        }
\n        string st2 = @\"        }
\n    }
\n}\";
\n        string fullProgram = st1 + sb.ToString() + st2;
\n        File.WriteAllText(\"GeneratedTestProgram.cs\", fullProgram);
\n    }
\n}
\n<\/code><\/p>\n","protected":false},"excerpt":{"rendered":"

Presents code that generates C# code to create an arbitrary XML document.<\/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":[7,3,5],"tags":[],"class_list":["post-187","post","type-post","status-publish","format-standard","hentry","category-document-generation-series","category-open-xml","category-wordprocessingml"],"_links":{"self":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/187","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=187"}],"version-history":[{"count":26,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/187\/revisions"}],"predecessor-version":[{"id":256,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/posts\/187\/revisions\/256"}],"wp:attachment":[{"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/media?parent=187"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/categories?post=187"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ericwhite.com\/blog\/wp-json\/wp\/v2\/tags?post=187"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}