How can I get the XPath to the XmlNode my XPathNavigator is on?

dom4j (a really good Java XML library) has a very useful call. On the equivalent of t开发者_如何转开发heir XPathNavigator object you can request a unique Xpath statement that will give you that specific node. How can I get this using the .NET XML library?

---

I just worked this through.

Note: This requires that there is an XmlDocument underlying the XPathNavigator object. You can have an XPathNavigator object that is not wrapping an XmlDocument and for those cases, this will not work.

To call this, you pass in the XmlNode that the XPathNavigator object is presently on. That is contained in XPathNavigator.UnderlyingObject.

Also, if you explicitly set any namespaces you need to pass in a Dictionary where the key is the namespace uri and the value is the prefix. The underlying XmlDocument will use the namespaces as defined in the original XML, not the namespaces assigned to it after loading it (no idea why). You can pass null if you did not explicitly set any namespaces.

Full code is in a zip at XML Get Unique XPath

using System.Collections.Generic; 
using System.Text; 
using System.Xml; 

/// <summary> 

/// For an XmlNode in an XmlDocument, can determine the XPath 
///to return that specific node. Can also then determine the non-specific 

/// XPath to a subsequent child node (the XPath that will return that node AND ALSO any peer nodes of the same name(s)). 

/// </summary> 

public class NodeLocator 

{ 

    private NodeLocator next; 

    private readonly XmlNode node; 

    private readonly Dictionary<string, string> namespaceMap; 



    private NodeLocator(Dictionary<string, string> namespaceMap, XmlNode node) 

    { 

        this.node = node; 

        this.namespaceMap = namespaceMap ?? new Dictionary<string, string>(); 

    } 



    /// <summary> 

    /// Get the unique XPath for the passed in node. 

    /// </summary> 

    /// <param name="namespaceMap">If namespace prefixes are different from the raw XmlDocument, this dictionaru is key=uri, value=prefix.</param> 

    /// <param name="node">The node to get the unique XPath to.</param> 

    /// <returns>The unique XPath to node.</returns> 

    public static string GetUniqueLocation(Dictionary<string, string> namespaceMap, XmlNode node) 

    { 

        NodeLocator loc = new NodeLocator(namespaceMap, node); 

        while (node.ParentNode != null) 

        { 

            node = node.ParentNode; 

            if (node is XmlDocument) 

                break; 

            NodeLocator parentloc = new NodeLocator(namespaceMap, node); 

            parentloc.next = loc; 

            loc = parentloc; 

        } 

        return loc.Xpath(true); 

    } 



    /// <summary> 

    /// Get the unique XPath for the passed in node. It uses the unique XPath from the root to the parent and then non-unique XPath from the parent to the node. 

    /// </summary> 

    /// <param name="namespaceMap">If namespace prefixes are different from the raw XmlDocument, this dictionaru is key=uri, value=prefix.</param> 

    /// <param name="parent">The node to get the unique XPath to.</param> 

    /// <param name="node">The node to get the NON-unique XPath to.</param> 

    /// <returns>The unique XPath to node.</returns> 

    public static string GetLocation(Dictionary<string, string> namespaceMap, XmlNode parent, XmlNode node) 

    { 

        NodeLocator loc = new NodeLocator(namespaceMap, node); 

        while ((node.ParentNode != null) && (node.ParentNode != parent)) 

        { 

            node = node.ParentNode; 

            if (node is XmlDocument) 

                break; 

            NodeLocator parentloc = new NodeLocator(namespaceMap, node); 

            parentloc.next = loc; 

            loc = parentloc; 

        } 

        return loc.Xpath(false); 

    } 



    private string Xpath(bool unique) 

    { 

        StringBuilder sb = new StringBuilder(); 

        NodeLocator loc = this; 

        do 

        { 

            if (loc.node.Name.StartsWith("#")) 

            { 

                if (loc.node.Name == "#document") 

                    sb.Append('/'); 

            } 

            else 

            { 

                sb.Append('/'); 

                if (loc.node is XmlAttribute) 

                    sb.Append('@'); 

                sb.Append(FullName(loc.node)); 

                if (unique) 

                { 

                    sb.Append('['); 

                    sb.Append(loc.IndexInParent); 

                    sb.Append(']'); 

                } 

            } 

            loc = loc.next; 

        } while (loc != null); 



        // no leading / for non-unique 

        if ((!unique) && (sb.Length > 0)) 

            sb.Remove(0, 1); 

        return sb.ToString(); 

    } 



    private string FullName(XmlNode _node) 

    { 

        if (string.IsNullOrEmpty(_node.NamespaceURI) || (!namespaceMap.ContainsKey(_node.NamespaceURI))) 

            return _node.Name; 

        return namespaceMap[_node.NamespaceURI] + ':' + _node.LocalName; 

    } 



    private int IndexInParent 

    { 

        get 

        { 

            int indexInParent = 1; 

            XmlNode parent = node.ParentNode; 

            string nodeName = FullName(node); 

            if (parent != null) 

            { 

                foreach (XmlNode child in parent.ChildNodes) 

                { 

                    if (child == node) 

                        break; 

                    if (FullName(child) == nodeName) 

                    { 

                        indexInParent++; 

                    } 

                } 

            } 

            return indexInParent; 

        } 

    } 

}