June 6th, 2006

HOWTO: Dynamic XPath Expressions w/ C#

C#, by jay.

In this HOWTO I will explain how to generate XPath expressions using a simple XML Document, a custom object collection and a few foreach loops. The end result is a list of XPath expressions that map to each node of the specified XML Document. This can be very useful for XML that is large or XML you are not familiar with but is does begin to fall apart when you get into very complext XML.


Custom Collection Object

Create 2 new Classes:
XNode.cs will hold the XML Node Name, the XPath exp and a collection of ChildNodes (XNodes)
XNodes.cs is the collection of XNode's

XNode.cs

PLAIN TEXT
C#:
  1. using System;
  2.  
  3. public class XNode
  4. {
  5.     public string name;
  6.     public string xpath;
  7.     public XNodes xnodes = new XNodes();
  8.  
  9.     public XNode(string name, string xpath)
  10.     {
  11.         this.name = name;
  12.         this.xpath = xpath;
  13.     }
  14.  
  15.     public XNode(string name, string xpath,XNodes xnodes)
  16.     {
  17.         this.name = name;
  18.         this.xpath = xpath;
  19.         this.xnodes = xnodes;
  20.     }

XNodes.cs
This is the short version of this class which is missing the find and remove methods.

PLAIN TEXT
C#:
  1. using System;
  2.     using System.Collections;
  3.    
  4.     public class XNodes: System.Collections.CollectionBase
  5.     {
  6.        
  7.         public XNode Add(string name,string xpath)
  8.         {
  9.             XNode xnode = new XNode(name,xpath);
  10.            
  11.             this.InnerList.Add(xnode);
  12.             return xnode;
  13.         }
  14.    
  15.         public XNode Add(string name,string xpath,XNodes xnodes)
  16.         {
  17.             XNode xnode = new XNode(name,xpath,xnodes);  
  18.             this.InnerList.Add(xnode);
  19.             return xnode;
  20.         }
  21.     }

WebForm and Code-behind
the web form is where the action will take place. To get started create 2 text boxes and a button.

  • TextBox1 will hold the XML
  • TextBox2 will hole the XPath results
  • Button1

In the code-behind of the default.aspx.cs page you will add 3 methods:
BuildXPath which will generate the XPath exp's and add them to the XNode collection.
ReadXNode which will place the XPath exp's from the XNode collection in a textbox.
button_click which does the following:

  • get the XML from TextBox1 and bind it to an XMLDocument
  • create the first (Parent) XNode object
  • loop over each XmlNode in the XmlDocument
  • loop over each XNode in the Parent XNode

BuildXPath takes 3 parameters:
XNode xParent - The Parent XNode that we will be adding XNodes to
XmlNode xnode - the current XML Node we are getting information about
string xpath - the current value of the XPath exp

We will invoke this method from the button click event.

PLAIN TEXT
C#:
  1. foreach(XmlNode xnode in xDoc.DocumentElement)
  2.     {
  3.         BuildXPath(objXNode,xnode,"//");
  4.     }

PLAIN TEXT
C#:
  1. private void BuildXPath(XNode xParent, XmlNode xnode,string xpath)
  2.     {

This methods works by getting the Name value from the xnode and adds that to the xpath string. Then it creates a NEW XNode using the xnode.Name and the xpath value and then trims off any trailing "/'s".

PLAIN TEXT
C#:
  1. xpath +=xnode.Name+"/";
  2.         XNode newnode = new XNode(xnode.Name,xpath);
  3.         newnode.xpath = xpath.Remove(xpath.Length-1,1);

At this point we have our first child node defined so we'll add it to the XNode collection.

PLAIN TEXT
C#:
  1. xParent.xnodes.Add(newnode);

Now we need to check to see if the current XmlNode has any attributes, check to see the count of attributes and finnally process accordingly.

PLAIN TEXT
C#:
  1. if(xnode.Attributes!=null)
  2.             {
  3.                 if(xnode.Attributes.Count != 0)
  4.                 {

If there are any attributes then we'll loop over them and extract the XPath exp using the attribute name and value. We start by first creating a new XNode using the current XmlNode name but an empty Xpath exp, and tempXpath strinag and a foreach xnode attributes.

PLAIN TEXT
C#:
  1. XNode anode = new XNode(xnode.Name,"");
  2.     string tempXpath = string.Empty;
  3.     foreach(XmlAttribute att in xnode.Attributes)
  4.     {

When we step into the foreach we are getting the attribute Name and Value and placing them in a string with the extra charcters need for Xpath.

PLAIN TEXT
C#:
  1. foreach(XmlAttribute att in xnode.Attributes)
  2.     {                  
  3.         tempXpath += "@"+att.Name+"='"+att.Value+"' and ";           
  4.     }

As you can see we are uings the "+=" oprator to append the tempXpath string to its' self and we are adding the "@" decleration to indicate to XPath that this is an attribute as well as adding the string " and " to the end.

Once we reach the end of the loop we will add out XPath exp to the current XNodes' xpath property. You'll notice that we are first removing the last charter from the parent XPath, adding our newly created XPath and then removing the trailing " and " string.
The we add this XNode to its' currnt parent XNode.xnode collection.

PLAIN TEXT
C#:
  1. anode.xpath = xpath.Remove(xpath.Length-1,1)+"["+tempXpath.Remove(tempXpath.Length-4,4).TrimEnd()+"]";
  2.     newnode.xnodes.Add(anode);

Once this processess is complete we need to check to see if the current XML Node has any child nodes. We do this by doing another foreach loop over the current XmlNode and then use the conditional HasChildren. If it does have any child nodes we step into the BuildXPath method and start processing nodes.

PLAIN TEXT
C#:
  1. foreach(XmlNode newxnode in xnode)
  2.     {
  3.         if(newxnode.HasChildNodes)
  4.         {
  5.             BuildXPath(xParent,newxnode,xpath);
  6.         }            
  7.     }

Once the BuildXPath method has completed we will have a collection XNode objects in single XNode object. To extract the XPath exp's and display them in a text box we'll use a second method ReadXNode.

ReadXNode functions similar to the BuildXPath method but it takes a single XNode parameter. Thie method is also invoked from the button click event but not until after the BuildXPath method has completed. It works by looping over each XNode in the Parent XNode XNodes collection.

PLAIN TEXT
C#:
  1. foreach(XNode xobjNode in objXNode.xnodes)
  2.     {            
  3.         ReadXNode(xobjNode);               
  4.     }

As you can see below this method is very short.

PLAIN TEXT
C#:
  1. private void ReadXNode(XNode xParent)
  2.     {            
  3.         foreach(XNode xobjNode in xParent.xnodes)
  4.         {                  
  5.             this.TextBox2.Text += xobjNode.xpath + System.Environment.NewLine;
  6.             if(xobjNode.xnodes.Count> 0)
  7.             {               
  8.                 ReadXNode(xobjNode);
  9.             }            
  10.         }
  11.     }

Once inside the ReadXNode it starts off by doing a foreach loop over the current XNodes xNode collection.
Then foreach XNode it gets the xpath property value and adds it into the textbox. It then checks to see if the child node has a a populated XNode collection and if it does it steps back into the ReadXNode method using the current child node as the new Parent to inspect.

The end result is the XPath TextBox will have an XPath expression for each node that was added to the XNode collection.

Download the Source Code Here

kick it on dotnetkicks.com

Back Top

STX LINUX TIP: Opening Windows: _new or _blank?

Responses to “HOWTO: Dynamic XPath Expressions w/ C#”

  		1.

    How can i write above code in Java
    Supriya at 2009/01/27 2:49 am Reply

  2. Thanks for your howto.
    I just write function, inspired by howto, doing similar work:
    private IEnumerable BuildLazyXPath(string parentXpath, XmlNode parentNode)
    {
    foreach (XmlNode childXmlNode in parentNode)
    {
    string childXpath = parentXpath + "/" + childXmlNode.Name;
    yield return childXpath;

    if (childXmlNode.Attributes != null && childXmlNode.Attributes.Count > 0)
    {
    foreach (XmlAttribute attr in childXmlNode.Attributes)
    {
    yield return parentXpath + "/" + childXmlNode.Name + "[@" + attr.Name + "]";
    }
    }

    foreach (string childXpaths in BuildLazyXPath(childXpath, childXmlNode))
    {
    yield return childXpaths;
    }
    }
    }
    call:
    using (Stream xmlStream = File.OpenRead(@"c:\my.xml"))
    {
    XmlReader reader = XmlReader.Create(xmlStream);
    XmlDocument xDoc = new XmlDocument();
    xDoc.Load(reader);
    foreach (string xpath in BuildLazyXPath("/" + xDoc.DocumentElement.Name, xDoc.DocumentElement))
    {
    // ...
    }
    }
    alx3 at 2009/02/04 1:26 pm Reply

  3. I have no clue. I don't know Java.
    jay at 2009/02/05 1:57 am Reply