Comment utiliser XPath avec un namespace par défaut sans préfixe?

vous devez utiliser un XmlNamespaceManager comme suit:

   XDocument doc = XDocument.Load(@"..\..\XMLFile1.xml");
   XmlNamespaceManager mgr = new XmlNamespaceManager(new NameTable());
   mgr.AddNamespace("df", "lcmp");
   foreach (XElement myNode in doc.XPathSelectElements("configuration/df:MyNode", mgr))
   {
       Console.WriteLine(myNode.Attribute("attr").Value);
   }

XPath n'est (délibérément) pas conçu pour le cas où vous souhaitez utiliser la même expression XPath pour certains espaces de noms inconnus qui ne vivent que dans le document XML. Vous devez connaître l'espace de noms à l'avance, déclarer l'espace de noms pour le processeur XPath, et utiliser le nom de votre expression. Les réponses de Martin et Dan montrent comment faire cela dans C#.

la raison de cette difficulté est mieux exprimée dans les espaces de noms XML 151990920" spec:

il devrait être possible de faire ce que vous voulez, mais je ne pense pas que cela puisse être fait dans une seule expression XPath. Tout d'abord, vous devez fouiller dans le document et extraire tous les namespaceURIs, puis les ajouter au gestionnaire de namespace et ensuite exécuter l'expression XPath réelle que vous voulez (et vous devez savoir quelque chose sur la distribution de les espaces de noms dans le document à ce point, ou vous avez beaucoup d'expressions à exécuter). Je pense que vous êtes probablement mieux en utilisant quelque chose d'autre que XPath (par exemple un DOM ou une API de type SAX) pour trouver l'espaceur de noms, mais vous pouvez aussi explorer L'axe de l'espace de noms XPath (dans XPath 1.0), utiliser la fonction namespace-uri-from-QName (dans XPath 2.0) ou utiliser des expressions comme "configuration/*[local-name() = 'MyNode']" D'Oleg . Quoi qu'il en soit, je pense que votre meilleur pari est d'essayer d'éviter d'écrire agnostic XPath espace de noms! Pourquoi ne savez-vous pas votre espace de noms à l'avance? Comment allez-vous éviter une correspondance choses que vous n'avez pas l'intention de match?

Edit - vous connaissez le namespaceURI?

il s'avère que votre question nous a tous confondus. Apparemment, vous connaissez L'URI de l'espace de noms, mais vous ne connaissez pas le préfixe d'espace de noms utilisé dans le document XML. En effet, dans ce cas, aucun préfixe d'espace de noms n'est utilisé et L'URI devient l'espace de noms par défaut où il est défini. Clé ce qu'il faut savoir, c'est que le préfixe choisi (ou l'absence de préfixe) n'est pas pertinent pour votre expression XPath (et l'analyse XML en général). L'attribut prefix / xmlns n'est qu'une façon d'associer un noeud à un URI d'espace de noms lorsque le document est exprimé sous forme de texte. Vous pouvez jeter un oeil à cette réponse , où j'essaie de clarifier les préfixes d'espace de noms.

vous devriez essayer de penser au document XML de la même manière que l'analyseur le pense - chaque noeud a un URI d'espace de nom et un nom local. Le préfixe de l'espace de noms / les règles de l'héritage ne font que sauver en tapant l'URI de nombreuses fois. Une façon d'écrire ceci est en notation Clark: c'est-à-dire, vous écrivez { http://www.example.com/namespace/example } LocalNodeName, mais cette notation n'est généralement utilisée que pour la documentation - XPath ne sait rien de cette notation.

à la place, XPath utilise ses propres préfixes d'espace de noms.Quelque chose comme /ns1:root/ns2:node . Mais ce sont complètement séparé des préfixes qui peuvent être utilisés dans le document XML original et rien à voir avec eux. Toute implémentation de XPath aura un moyen de cartographier ses propres préfixes avec URIs d'espace de noms. Pour l'implémentation de C# vous utilisez un XmlNamespaceManager , dans Perl vous fournissez un hachage, xmllint prend les arguments en ligne de commande... Donc tout ce que vous avez à faire est de créer un préfixe arbitraire pour L'URI de l'espace de noms que vous connaissez, et d'utiliser ce préfixe dans L'expression XPath. Peu importe le préfixe que vous utilisez, dans XML vous il suffit de se soucier de la combinaison de L'URI et le nom local.

l'autre chose à se rappeler (c'est souvent une surprise) est que XPath ne fait pas d'héritage namespace. Vous avez besoin d'ajouter un préfixe pour chaque qui a un espace de noms, indépendamment du fait que l'espace de noms vient de l'héritage, un attribut xmlns, ou un préfixe d'espace de noms. En outre, bien que vous devez toujours penser en termes D'URIs et de noms locaux, il existe également des moyens d'accéder au préfixe à partir d'un document XML. C'est rare d'avoir à les utiliser.

voici un exemple de comment rendre l'espace de noms disponible pour L'expression XPath XPathSelectElements extension de la méthode:

using System;
using System.Xml.Linq;
using System.Xml.XPath;
using System.Xml;
namespace XPathExpt
{
 class Program
 {
   static void Main(string[] args)
   {
     XElement cfg = XElement.Parse(
       @"<configuration>
          <MyNode xmlns=""lcmp"" attr=""true"">
            <subnode />
          </MyNode>
         </configuration>");
     XmlNameTable nameTable = new NameTable();
     var nsMgr = new XmlNamespaceManager(nameTable);
     // Tell the namespace manager about the namespace
     // of interest (lcmp), and give it a prefix (pfx) that we'll
     // use to refer to it in XPath expressions. 
     // Note that the prefix choice is pretty arbitrary at 
     // this point.
     nsMgr.AddNamespace("pfx", "lcmp");
     foreach (var el in cfg.XPathSelectElements("//pfx:MyNode", nsMgr))
     {
         Console.WriteLine("Found element named {0}", el.Name);
     }
   }
 }
}

exemple avec Xpath 2.0 + une bibliothèque:

using Wmhelp.XPath2;

doc.XPath2SelectElements("/*:configuration/*:MyNode");

voir:

XPath et XSLT 2.0 pour .NET?

j'aime bien @mads-hansen, sa réponse, si bien que j'ai écrit à ces membres de la classe utilitaire polyvalente:

    /// <summary>
    /// Gets the <see cref="XNode" /> into a <c>local-name()</c>, XPath-predicate query.
    /// </summary>
    /// <param name="childElementName">Name of the child element.</param>
    /// <returns></returns>
    public static string GetLocalNameXPathQuery(string childElementName)
    {
        return GetLocalNameXPathQuery(namespacePrefixOrUri: null, childElementName: childElementName, childAttributeName: null);
    }

    /// <summary>
    /// Gets the <see cref="XNode" /> into a <c>local-name()</c>, XPath-predicate query.
    /// </summary>
    /// <param name="namespacePrefixOrUri">The namespace prefix or URI.</param>
    /// <param name="childElementName">Name of the child element.</param>
    /// <returns></returns>
    public static string GetLocalNameXPathQuery(string namespacePrefixOrUri, string childElementName)
    {
        return GetLocalNameXPathQuery(namespacePrefixOrUri, childElementName, childAttributeName: null);
    }

    /// <summary>
    /// Gets the <see cref="XNode" /> into a <c>local-name()</c>, XPath-predicate query.
    /// </summary>
    /// <param name="namespacePrefixOrUri">The namespace prefix or URI.</param>
    /// <param name="childElementName">Name of the child element.</param>
    /// <param name="childAttributeName">Name of the child attribute.</param>
    /// <returns></returns>
    /// <remarks>
    /// This routine is useful when namespace-resolving is not desirable or available.
    /// </remarks>
    public static string GetLocalNameXPathQuery(string namespacePrefixOrUri, string childElementName, string childAttributeName)
    {
        if (string.IsNullOrEmpty(childElementName)) return null;

        if (string.IsNullOrEmpty(childAttributeName))
        {
            return string.IsNullOrEmpty(namespacePrefixOrUri) ?
                string.Format("./*[local-name()='{0}']", childElementName)
                :
                string.Format("./*[namespace-uri()='{0}' and local-name()='{1}']", namespacePrefixOrUri, childElementName);
        }
        else
        {
            return string.IsNullOrEmpty(namespacePrefixOrUri) ?
                string.Format("./*[local-name()='{0}']/@{1}", childElementName, childAttributeName)
                :
                string.Format("./*[namespace-uri()='{0}' and local-name()='{1}']/@{2}", namespacePrefixOrUri, childElementName, childAttributeName);
        }
    }