Cómo obtener xpath desde una instancia de XmlNode

Jon tiene razón en que hay cualquier número de expresiones XPath que producirán el mismo nodo en un documento de instancia. La forma más sencilla de construir una expresión que produce un nodo específico sin ambigüedades es una cadena de pruebas de nodos que utilizan la posición del nodo en el predicado, por ejemplo:

/node()[0]/node()[2]/node()[6]/node()[1]/node()[2]

Obviamente, esta expresión no está usando nombres de elemento, pero entonces si todo lo que está tratando de hacer es localizar un nodo dentro de un documento, no necesita su nombre. Tampoco se puede usar para encontrar atributos (porque los atributos no son nodos y no tienen posición; solo puede encontrarlos por nombre), pero encontrará todos los demás tipos de nodos.

Para construir esta expresión, necesita escribir un método que devuelva la posición de un nodo en los nodos secundarios de su padre, porque XmlNode no lo expone como una propiedad:

static int GetNodePosition(XmlNode child)
{
   for (int i=0; i<child.ParentNode.ChildNodes.Count; i++)
   {
       if (child.ParentNode.ChildNodes[i] == child)
       {
          // tricksy XPath, not starting its positions at 0 like a normal language
          return i + 1;
       }
   }
   throw new InvalidOperationException("Child node somehow not found in its parent's ChildNodes property.");
}

(Probablemente hay una forma más elegante de hacerlo usando LINQ, ya que XmlNodeList implementa IEnumerable, pero voy con lo que sé aquí.)

Entonces puede escribir un método recursivo así:

static string GetXPathToNode(XmlNode node)
{
    if (node.NodeType == XmlNodeType.Attribute)
    {
        // attributes have an OwnerElement, not a ParentNode; also they have
        // to be matched by name, not found by position
        return String.Format(
            "{0}/@{1}",
            GetXPathToNode(((XmlAttribute)node).OwnerElement),
            node.Name
            );            
    }
    if (node.ParentNode == null)
    {
        // the only node with no parent is the root node, which has no path
        return "";
    }
    // the path to a node is the path to its parent, plus "/node()[n]", where 
    // n is its position among its siblings.
    return String.Format(
        "{0}/node()[{1}]",
        GetXPathToNode(node.ParentNode),
        GetNodePosition(node)
        );
}

Como puedes ver, hackeé de alguna manera para que encuentre atributos también.

Jon se deslizó en la que su versión mientras yo estaba escribiendo la mía. Hay algo en su código que me va a hacer despotricar un poco ahora, y me disculpo de antemano si suena como que estoy molestando a Jon. (No lo soy. Estoy bastante seguro de que la lista de cosas que Jon tiene que aprender de mí es extremadamente corta. Pero creo que el punto que voy a hacer es muy importante para cualquiera que trabaje con XML para pensar.

Sospecho que la solución de Jon surgió de algo que veo que muchos desarrolladores hacen: pensar en los documentos XML como árboles de elementos y atributos. Creo que esto proviene en gran medida de los desarrolladores cuyo uso principal de XML es como un formato de serialización, porque todo el XML que están acostumbrados a usar está estructurado de esta manera. Puedes detectar a estos desarrolladores porque están usando los términos "nodo" y "elemento" indistintamente. Esto los lleva a encontrar soluciones que trate todos los demás tipos de nodos como casos especiales. (Yo fui uno de estos chicos durante mucho tiempo.)

Esto parece una suposición simplificadora mientras lo haces. Pero no lo es. Hace que los problemas sean más difíciles y el código más complejo. Esto le lleva a omitir las piezas de la tecnología XML (como la función node() en XPath) que están específicamente diseñadas para tratar todos los tipos de nodos de forma genérica.

Hay una bandera roja en el código de Jon que me haría consultarlo en una revisión de código, incluso si No sabía cuáles eran los requisitos, y eso es GetElementsByTagName. Cada vez que veo ese método en uso, la pregunta que salta a la mente es siempre " ¿por qué tiene que ser un elemento?"Y la respuesta es muy a menudo" oh, ¿este código necesita manejar nodos de texto también?"

Lo sé, viejo post, pero la versión que más me gustó (la que tiene nombres) era defectuosa: Cuando un nodo padre tiene nodos con nombres diferentes, deja de contar el índice después de encontrar el primer nombre de nodo no coincidente.

Aquí está mi versión fija de la misma:

/// <summary>
/// Gets the X-Path to a given Node
/// </summary>
/// <param name="node">The Node to get the X-Path from</param>
/// <returns>The X-Path of the Node</returns>
public string GetXPathToNode(XmlNode node)
{
    if (node.NodeType == XmlNodeType.Attribute)
    {
        // attributes have an OwnerElement, not a ParentNode; also they have             
        // to be matched by name, not found by position             
        return String.Format("{0}/@{1}", GetXPathToNode(((XmlAttribute)node).OwnerElement), node.Name);
    }
    if (node.ParentNode == null)
    {
        // the only node with no parent is the root node, which has no path
        return "";
    }

    // Get the Index
    int indexInParent = 1;
    XmlNode siblingNode = node.PreviousSibling;
    // Loop thru all Siblings
    while (siblingNode != null)
    {
        // Increase the Index if the Sibling has the same Name
        if (siblingNode.Name == node.Name)
        {
            indexInParent++;
        }
        siblingNode = siblingNode.PreviousSibling;
    }

    // the path to a node is the path to its parent, plus "/node()[n]", where n is its position among its siblings.         
    return String.Format("{0}/{1}[{2}]", GetXPathToNode(node.ParentNode), node.Name, indexInParent);
}

Mi valor de 10 peniques es un híbrido de las respuestas de Robert y Corey. Solo puedo reclamar el crédito por la escritura real de las líneas adicionales de código.

    private static string GetXPathToNode(XmlNode node)
    {
        if (node.NodeType == XmlNodeType.Attribute)
        {
            // attributes have an OwnerElement, not a ParentNode; also they have
            // to be matched by name, not found by position
            return String.Format(
                "{0}/@{1}",
                GetXPathToNode(((XmlAttribute)node).OwnerElement),
                node.Name
                );
        }
        if (node.ParentNode == null)
        {
            // the only node with no parent is the root node, which has no path
            return "";
        }
        //get the index
        int iIndex = 1;
        XmlNode xnIndex = node;
        while (xnIndex.PreviousSibling != null) { iIndex++; xnIndex = xnIndex.PreviousSibling; }
        // the path to a node is the path to its parent, plus "/node()[n]", where 
        // n is its position among its siblings.
        return String.Format(
            "{0}/node()[{1}]",
            GetXPathToNode(node.ParentNode),
            iIndex
            );
    }

Aquí hay un método simple que he utilizado, funcionó para mí.

    static string GetXpath(XmlNode node)
    {
        if (node.Name == "#document")
            return String.Empty;
        return GetXpath(node.SelectSingleNode("..")) + "/" +  (node.NodeType == XmlNodeType.Attribute ? "@":String.Empty) + node.Name;
    }

No existe tal cosa como "el" xpath de un nodo. Para cualquier nodo dado puede haber muchas expresiones xpath que coincidan con él.

Probablemente puede trabajar en el árbol para construir una expresión que coincida con ella, teniendo en cuenta el índice de elementos particulares, etc., pero no va a ser un código terriblemente agradable.

¿Por qué necesitas esto? Puede haber una mejor solución.

Si haces esto, obtendrás una Ruta con los Nombres de los Nodos der Y la Posición, si tienes Nodos con el mismo nombre como este: "/Service[1]/System[1]/Group[1]/Folder[2] / File[2] "

public string GetXPathToNode(XmlNode node)
{         
    if (node.NodeType == XmlNodeType.Attribute)
    {             
        // attributes have an OwnerElement, not a ParentNode; also they have             
        // to be matched by name, not found by position             
        return String.Format("{0}/@{1}", GetXPathToNode(((XmlAttribute)node).OwnerElement), node.Name);
    }
    if (node.ParentNode == null)
    {             
        // the only node with no parent is the root node, which has no path
        return "";
    }

    //get the index
    int iIndex = 1;
    XmlNode xnIndex = node;
    while (xnIndex.PreviousSibling != null && xnIndex.PreviousSibling.Name == xnIndex.Name)
    {
         iIndex++;
         xnIndex = xnIndex.PreviousSibling; 
    }

    // the path to a node is the path to its parent, plus "/node()[n]", where
    // n is its position among its siblings.         
    return String.Format("{0}/{1}[{2}]", GetXPathToNode(node.ParentNode), node.Name, iIndex);
}

Encontré que ninguno de los anteriores funcionaba con XDocument, así que escribí mi propio código para soportar XDocument y usé la recursión. Creo que este código maneja múltiples nodos idénticos mejor que algunos de los otros códigos aquí porque primero intenta profundizar en la ruta XML como puede y luego hace copias de seguridad para construir solo lo que se necesita. Así que si tienes /home/white/bob y /home/white/mike y quieres crear /home/white/bob/garage el código sabrá cómo crear eso. Sin embargo, no quería meterme con predicados o comodines, así que explícitamente no los permitió; pero sería fácil agregar apoyo para ellos.

Private Sub NodeItterate(XDoc As XElement, XPath As String)
    'get the deepest path
    Dim nodes As IEnumerable(Of XElement)

    nodes = XDoc.XPathSelectElements(XPath)

    'if it doesn't exist, try the next shallow path
    If nodes.Count = 0 Then
        NodeItterate(XDoc, XPath.Substring(0, XPath.LastIndexOf("/")))
        'by this time all the required parent elements will have been constructed
        Dim ParentPath As String = XPath.Substring(0, XPath.LastIndexOf("/"))
        Dim ParentNode As XElement = XDoc.XPathSelectElement(ParentPath)
        Dim NewElementName As String = XPath.Substring(XPath.LastIndexOf("/") + 1, XPath.Length - XPath.LastIndexOf("/") - 1)
        ParentNode.Add(New XElement(NewElementName))
    End If

    'if we find there are more than 1 elements at the deepest path we have access to, we can't proceed
    If nodes.Count > 1 Then
        Throw New ArgumentOutOfRangeException("There are too many paths that match your expression.")
    End If

    'if there is just one element, we can proceed
    If nodes.Count = 1 Then
        'just proceed
    End If

End Sub

Public Sub CreateXPath(ByVal XDoc As XElement, ByVal XPath As String)

    If XPath.Contains("//") Or XPath.Contains("*") Or XPath.Contains(".") Then
        Throw New ArgumentException("Can't create a path based on searches, wildcards, or relative paths.")
    End If

    If Regex.IsMatch(XPath, "\[\]()@='<>\|") Then
        Throw New ArgumentException("Can't create a path based on predicates.")
    End If

    'we will process this recursively.
    NodeItterate(XDoc, XPath)

End Sub

¿Qué hay de usar la extensión de clase ? ;) Mi versión (basada en el trabajo de otros) usa el nombre de sintaxis [index]... con el índice omitido es elemento no tiene "hermanos". El bucle para obtener el índice del elemento está fuera en una rutina independiente (también una extensión de clase).

Justo después de lo siguiente en cualquier clase de utilidad (o en la clase principal del programa)

static public int GetRank( this XmlNode node )
{
    // return 0 if unique, else return position 1...n in siblings with same name
    try
    {
        if( node is XmlElement ) 
        {
            int rank = 1;
            bool alone = true, found = false;

            foreach( XmlNode n in node.ParentNode.ChildNodes )
                if( n.Name == node.Name ) // sibling with same name
                {
                    if( n.Equals(node) )
                    {
                        if( ! alone ) return rank; // no need to continue
                        found = true;
                    }
                    else
                    {
                        if( found ) return rank; // no need to continue
                        alone = false;
                        rank++;
                    }
                }

        }
    }
    catch{}
    return 0;
}

static public string GetXPath( this XmlNode node )
{
    try
    {
        if( node is XmlAttribute )
            return String.Format( "{0}/@{1}", (node as XmlAttribute).OwnerElement.GetXPath(), node.Name );

        if( node is XmlText || node is XmlCDataSection )
            return node.ParentNode.GetXPath();

        if( node.ParentNode == null )   // the only node with no parent is the root node, which has no path
            return "";

        int rank = node.GetRank();
        if( rank == 0 ) return String.Format( "{0}/{1}",        node.ParentNode.GetXPath(), node.Name );
        else            return String.Format( "{0}/{1}[{2}]",   node.ParentNode.GetXPath(), node.Name, rank );
    }
    catch{}
    return "";
}   

Produje VBA para Excel para hacer esto para un proyecto de trabajo. Muestra tuplas de un Xpath y el texto asociado desde un elemento o atributo. El propósito era permitir a los analistas de negocios identificar y mapear algo de xml. Apreciamos que este es un foro de C#, pero pensamos que esto puede ser de interés.

Sub Parse2(oSh As Long, inode As IXMLDOMNode, Optional iXstring As String = "", Optional indexes)


Dim chnode As IXMLDOMNode
Dim attr As IXMLDOMAttribute
Dim oXString As String
Dim chld As Long
Dim idx As Variant
Dim addindex As Boolean
chld = 0
idx = 0
addindex = False


'determine the node type:
Select Case inode.NodeType

    Case NODE_ELEMENT
        If inode.ParentNode.NodeType = NODE_DOCUMENT Then 'This gets the root node name but ignores all the namespace attributes
            oXString = iXstring & "//" & fp(inode.nodename)
        Else

            'Need to deal with indexing. Where an element has siblings with the same nodeName,it needs to be indexed using [index], e.g swapstreams or schedules

            For Each chnode In inode.ParentNode.ChildNodes
                If chnode.NodeType = NODE_ELEMENT And chnode.nodename = inode.nodename Then chld = chld + 1
            Next chnode

            If chld > 1 Then '//inode has siblings of the same nodeName, so needs to be indexed
                'Lookup the index from the indexes array
                idx = getIndex(inode.nodename, indexes)
                addindex = True
            Else
            End If

            'build the XString
            oXString = iXstring & "/" & fp(inode.nodename)
            If addindex Then oXString = oXString & "[" & idx & "]"

            'If type is element then check for attributes
            For Each attr In inode.Attributes
                'If the element has attributes then extract the data pair XString + Element.Name, @Attribute.Name=Attribute.Value
                Call oSheet(oSh, oXString & "/@" & attr.Name, attr.Value)
            Next attr

        End If

    Case NODE_TEXT
        'build the XString
        oXString = iXstring
        Call oSheet(oSh, oXString, inode.NodeValue)

    Case NODE_ATTRIBUTE
    'Do nothing
    Case NODE_CDATA_SECTION
    'Do nothing
    Case NODE_COMMENT
    'Do nothing
    Case NODE_DOCUMENT
    'Do nothing
    Case NODE_DOCUMENT_FRAGMENT
    'Do nothing
    Case NODE_DOCUMENT_TYPE
    'Do nothing
    Case NODE_ENTITY
    'Do nothing
    Case NODE_ENTITY_REFERENCE
    'Do nothing
    Case NODE_INVALID
    'do nothing
    Case NODE_NOTATION
    'do nothing
    Case NODE_PROCESSING_INSTRUCTION
    'do nothing
End Select

'Now call Parser2 on each of inode's children.
If inode.HasChildNodes Then
    For Each chnode In inode.ChildNodes
        Call Parse2(oSh, chnode, oXString, indexes)
    Next chnode
Set chnode = Nothing
Else
End If

End Sub

Gestiona el conteo de elementos usando:

Function getIndex(tag As Variant, indexes) As Variant
'Function to get the latest index for an xml tag from the indexes array
'indexes array is passed from one parser function to the next up and down the tree

Dim i As Integer
Dim n As Integer

If IsArrayEmpty(indexes) Then
    ReDim indexes(1, 0)
    indexes(0, 0) = "Tag"
    indexes(1, 0) = "Index"
Else
End If
For i = 0 To UBound(indexes, 2)
    If indexes(0, i) = tag Then
        'tag found, increment and return the index then exit
        'also destroy all recorded tag names BELOW that level
        indexes(1, i) = indexes(1, i) + 1
        getIndex = indexes(1, i)
        ReDim Preserve indexes(1, i) 'should keep all tags up to i but remove all below it
        Exit Function
    Else
    End If
Next i

'tag not found so add the tag with index 1 at the end of the array
n = UBound(indexes, 2)
ReDim Preserve indexes(1, n + 1)
indexes(0, n + 1) = tag
indexes(1, n + 1) = 1
getIndex = 1

End Function

Esto es aún más fácil

 ''' <summary>
    ''' Gets the full XPath of a single node.
    ''' </summary>
    ''' <param name="node"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Private Function GetXPath(ByVal node As Xml.XmlNode) As String
        Dim temp As String
        Dim sibling As Xml.XmlNode
        Dim previousSiblings As Integer = 1

        'I dont want to know that it was a generic document
        If node.Name = "#document" Then Return ""

        'Prime it
        sibling = node.PreviousSibling
        'Perculate up getting the count of all of this node's sibling before it.
        While sibling IsNot Nothing
            'Only count if the sibling has the same name as this node
            If sibling.Name = node.Name Then
                previousSiblings += 1
            End If
            sibling = sibling.PreviousSibling
        End While

        'Mark this node's index, if it has one
        ' Also mark the index to 1 or the default if it does have a sibling just no previous.
        temp = node.Name + IIf(previousSiblings > 0 OrElse node.NextSibling IsNot Nothing, "[" + previousSiblings.ToString() + "]", "").ToString()

        If node.ParentNode IsNot Nothing Then
            Return GetXPath(node.ParentNode) + "/" + temp
        End If

        Return temp
    End Function

Otra solución a su problema podría ser 'marcar' los xmlnodes que querrá identificar más tarde con un atributo personalizado:

var id = _currentNode.OwnerDocument.CreateAttribute("some_id");
id.Value = Guid.NewGuid().ToString();
_currentNode.Attributes.Append(id);

Que puede almacenar en un Diccionario, por ejemplo. Y luego puede identificar el nodo con una consulta xpath:

newOrOldDocument.SelectSingleNode(string.Format("//*[contains(@some_id,'{0}')]", id));

Sé que esto no es una respuesta directa a su pregunta, pero puede ayudar si la razón por la que desea conocer el xpath de un nodo es tener una forma de' llegar ' al nodo más tarde después de haber perdido la referencia a él en codificar.

Esto también supera los problemas cuando el documento obtiene elementos añadidos/movidos, lo que puede estropear el xpath (o los índices, como se sugiere en otras respuestas).

 public static string GetFullPath(this XmlNode node)
        {
            if (node.ParentNode == null)
            {
                return "";
            }
            else
            {
                return $"{GetFullPath(node.ParentNode)}\\{node.ParentNode.Name}";
            }
        }

Tuve que hacer esto recientemente. Sólo había que tener en cuenta los elementos. Esto es lo que se me ocurrió:

    private string GetPath(XmlElement el)
    {
        List<string> pathList = new List<string>();
        XmlNode node = el;
        while (node is XmlElement)
        {
            pathList.Add(node.Name);
            node = node.ParentNode;
        }
        pathList.Reverse();
        string[] nodeNames = pathList.ToArray();
        return String.Join("/", nodeNames);
    }