Créer des Nœuds XML basé sur XPath?

Dans l'exemple, vous présente la seule chose créée est l'attribut ...

XmlElement element = (XmlElement)doc.SelectSingleNode("/feed/entry/content");
if (element != null)
    element.SetAttribute("source", "");

Si ce que vous voulez vraiment est d'être capable de créer une hiérarchie où il n'existe pas alors vous pouvez de votre propre simple analyseur xpath. Je ne sais pas à propos de maintien de l'attribut dans le xpath bien. Je préfère lancer le nœud d'un élément et le point d'amure sur un .SetAttribute comme je l'ai fait ici:

static private XmlNode makeXPath(XmlDocument doc, string xpath)
{
    return makeXPath(doc, doc as XmlNode, xpath);
}

static private XmlNode makeXPath(XmlDocument doc, XmlNode parent, string xpath)
{
    //grab the next node name in the xpath; or return parent if empty
    string[] partsOfXPath = xpath.Trim('/').Split('/');
    string nextNodeInXPath = partsOfXPath.First();
    if (string.IsNullOrEmpty(nextNodeInXPath))
        return parent;

    //get or create the node from the name
    XmlNode node = parent.SelectSingleNode(nextNodeInXPath);
    if (node == null)
        node = parent.AppendChild(doc.CreateElement(nextNodeInXPath));

    //rejoin the remainder of the array as an xpath expression and recurse
    string rest = String.Join("/", partsOfXPath.Skip(1).ToArray());
    return makeXPath(doc, node, rest);
}

static void Main(string[] args)
{
    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<feed />");

    makeXPath(doc, "/feed/entry/data");
    XmlElement contentElement = (XmlElement)makeXPath(doc, "/feed/entry/content");
    contentElement.SetAttribute("source", "");

    Console.WriteLine(doc.OuterXml);
}

Un problème avec cette idée, c'est que xpath "détruit" l'information.

Il y a un nombre infini d'arbres xml qui peut correspondre à de nombreuses requêtes xpath. Maintenant, dans certains cas, comme dans l'exemple que vous donnez, il est évident minimale arbre xml qui correspond à votre xpath, où vous avez un prédicat qui utilise "=".

Mais par exemple si le prédicat n'utilise pas l'égalité, ou de tout autre opérateur arithmétique autres que l'égalité, un nombre infini de possibilités existent. Vous pouvez essayer de choisir un "canonique" de l'arborescence xml qui impose, à dire le moins de bits pour représenter.

Supposons, par exemple, vous avez eu xpath /feed/entry/content[@source > 0]. Maintenant, n'importe quel arbre xml de la structure dans laquelle le nœud de contenu a un attribut source dont la valeur a > 0 match, mais il y a un nombre infini de nombres plus grand que zéro. En choisissant la "minimale" de la valeur, sans doute le 1er, vous pouvez tenter de donner une forme canonique votre xml.

Xpath prédicats peuvent contenir assez arbitraire des expressions arithmétiques, de sorte que la solution générale à ce est assez difficile, si pas impossible. On pourrait imaginer un énorme équation en y, et il devrait être résolu dans le sens inverse à venir avec des valeurs qui correspondent à l'équation; mais comme il peut y avoir un nombre infini de valeurs correspondantes (tant que c'est vraiment une inégalité pas une équation), une solution canonique devront être trouvés.

De nombreuses expressions d'autres formes également de détruire de l'information. Par exemple, un opérateur comme "ou" toujours détruit de l'information. Si vous savez que (X or Y) == 1, vous ne savez pas si X 1, Y 1, ou les deux est 1; tout ce que vous savez pour sûr, c'est que l'un d'eux est de 1! Donc si vous avez une expression à l'aide de OU, vous ne pouvez pas dire lequel des nœuds ou des valeurs qui sont entrées à la OU devrait être de 1 (vous pouvez faire un choix arbitraire et de définir à la fois 1, qui permettra de satisfaire l'expression pour sûr, que les deux choix, un seul d'entre eux est de 1).

Supposons maintenant qu'il existe plusieurs expressions xpath qui se réfèrent au même ensemble de valeurs. Ensuite, vous retrouver avec un système d'équations ou d'inéquations qui peut être pratiquement impossible à résoudre. Encore une fois, si vous restreindre à la limite permise de xpath pour un petit sous-ensemble de sa pleine puissance, vous pouvez résoudre ce problème. Je soupçonne entièrement le cas général est similaire à la Turing problème de l'arrêt, cependant, dans ce cas, étant donné un programme quelconque (xpath), figure un ensemble de données cohérentes qui correspond au programme, et il est dans un certain sens minimal.

La version C# de Mark Miller solution Java

    ///<summary>
///Makes the X path. Use a format like //configuration/appSettings/add[@key='name']/@value
///</summary>
///<param name="doc">The doc.</param>
///<param name="xpath">The xpath.</param>
///<returns></returns>
public static XmlNode createNodeFromXPath(XmlDocument doc, string xpath)
{
//Create a new Regex object
Regex r = new Regex(@"/+([\w]+)(\[@([\w]+)='([^']*)'\])?|/@([\w]+)");
//Find matches
Match m = r.Match(xpath);
XmlNode currentNode = doc.FirstChild;
StringBuilder currentPath = new StringBuilder();
while (m.Success)
{
String currentXPath = m.Groups[0].Value;    //"/configuration" or "/appSettings" or "/add"
String elementName = m.Groups[1].Value;     //"configuration" or "appSettings" or "add"
String filterName = m.Groups[3].Value;      //"" or "key"
String filterValue = m.Groups[4].Value;     //"" or "name"
String attributeName = m.Groups[5].Value;   //"" or "value"
StringBuilder builder = currentPath.Append(currentXPath);
String relativePath = builder.ToString();
XmlNode newNode = doc.SelectSingleNode(relativePath);
if (newNode == null)
{
if (!string.IsNullOrEmpty(attributeName))
{
((XmlElement)currentNode).SetAttribute(attributeName, "");
newNode = doc.SelectSingleNode(relativePath);
}
else if (!string.IsNullOrEmpty(elementName))
{
XmlElement element = doc.CreateElement(elementName);
if (!string.IsNullOrEmpty(filterName))
{
element.SetAttribute(filterName, filterValue);
}
currentNode.AppendChild(element);
newNode = element;
}
else
{
throw new FormatException("The given xPath is not supported " + relativePath);
}
}
currentNode = newNode;
m = m.NextMatch();
}
//Assure that the node is found or created
if (doc.SelectSingleNode(xpath) == null)
{
throw new FormatException("The given xPath cannot be created " + xpath);
}
return currentNode;
}

C'est une version améliorée de Christian Peeters solution qui prend en charge les espaces de noms dans l'expression xpath.

public static XNode CreateNodeFromXPath(XElement elem, string xpath)
{
//Create a new Regex object
Regex r = new Regex(@"/*([a-zA-Z0-9_\.\-\:]+)(\[@([a-zA-Z0-9_\.\-]+)='([^']*)'\])?|/@([a-zA-Z0-9_\.\-]+)");
xpath = xpath.Replace("\"", "'");
//Find matches
Match m = r.Match(xpath);
XNode currentNode = elem;
StringBuilder currentPath = new StringBuilder();
XPathNavigator XNav = elem.CreateNavigator();
while (m.Success)
{
String currentXPath = m.Groups[0].Value;    //"/ns:configuration" or "/appSettings" or "/add"
String NamespaceAndElementName = m.Groups[1].Value;     //"ns:configuration" or "appSettings" or "add"
String filterName = m.Groups[3].Value;      //"" or "key"
String filterValue = m.Groups[4].Value;     //"" or "name"
String attributeName = m.Groups[5].Value;   //"" or "value"
XNamespace nspace = "";
string elementName;
int p = NamespaceAndElementName.IndexOf(':');
if (p >= 0)
{
string ns = NamespaceAndElementName.Substring(0, p);
elementName = NamespaceAndElementName.Substring(p + 1);
nspace = XNav.GetNamespace(ns);
}
else
elementName = NamespaceAndElementName;
StringBuilder builder = currentPath.Append(currentXPath);
String relativePath = builder.ToString();
XNode newNode = (XNode)elem.XPathSelectElement(relativePath, XNav);
if (newNode == null)
{
if (!string.IsNullOrEmpty(attributeName))
{
((XElement)currentNode).Attribute(attributeName).Value = "";
newNode = (XNode)elem.XPathEvaluate(relativePath, XNav);
}
else if (!string.IsNullOrEmpty(elementName))
{
XElement newElem = new XElement(nspace + elementName);
if (!string.IsNullOrEmpty(filterName))
{
newElem.Add(new XAttribute(filterName, filterValue));
}
((XElement)currentNode).Add(newElem);
newNode = newElem;
}
else
{
throw new FormatException("The given xPath is not supported " + relativePath);
}
}
currentNode = newNode;
m = m.NextMatch();
}
//Assure that the node is found or created
if (elem.XPathEvaluate(xpath, XNav) == null)
{
throw new FormatException("The given xPath cannot be created " + xpath);
}
return currentNode;
}

J'avais besoin d'un XNode au lieu d'un XmlNode mise en œuvre, et la RegEx ne fonctionne pas pour moi (parce que les noms d'élément avec . ou - ne sont pas en fonctionnement)

Donc ce qu'est ce qui a fonctionné pour moi:

public static XNode createNodeFromXPath(XElement elem, string xpath)
{
//Create a new Regex object
Regex r = new Regex(@"/*([a-zA-Z0-9_\.\-]+)(\[@([a-zA-Z0-9_\.\-]+)='([^']*)'\])?|/@([a-zA-Z0-9_\.\-]+)");
xpath = xpath.Replace("\"", "'");
//Find matches
Match m = r.Match(xpath);
XNode currentNode = elem;
StringBuilder currentPath = new StringBuilder();
while (m.Success)
{
String currentXPath = m.Groups[0].Value;    //"/configuration" or "/appSettings" or "/add"
String elementName = m.Groups[1].Value;     //"configuration" or "appSettings" or "add"
String filterName = m.Groups[3].Value;      //"" or "key"
String filterValue = m.Groups[4].Value;     //"" or "name"
String attributeName = m.Groups[5].Value;   //"" or "value"
StringBuilder builder = currentPath.Append(currentXPath);
String relativePath = builder.ToString();
XNode newNode = (XNode)elem.XPathSelectElement(relativePath);
if (newNode == null)
{
if (!string.IsNullOrEmpty(attributeName))
{
((XElement)currentNode).Attribute(attributeName).Value = "";
newNode = (XNode)elem.XPathEvaluate(relativePath);
}
else if (!string.IsNullOrEmpty(elementName))
{
XElement newElem = new XElement(elementName);
if (!string.IsNullOrEmpty(filterName))
{
newElem.Add(new XAttribute(filterName, filterValue));
}
((XElement)currentNode).Add(newElem);
newNode = newElem;
}
else
{
throw new FormatException("The given xPath is not supported " + relativePath);
}
}
currentNode = newNode;
m = m.NextMatch();
}
//Assure that the node is found or created
if (elem.XPathEvaluate(xpath) == null)
{
throw new FormatException("The given xPath cannot be created " + xpath);
}
return currentNode;
}

Je sais que c'est un très vieux fil ... mais je viens d'essayer la même chose et est venu avec la regex suivante qui n'est pas parfait mais je le trouve plus générique

/+([\w]+)(\[@([\w]+)='([^']*)'\])?|/@([\w]+)

La chaîne /configuration/appSettings/add[@key='nom']/@value

doit être analysée pour

Trouvé 14 match(es):

start=0, fin=14
Groupe(0) = /configuration
Groupe(1) = configuration
Groupe(2) = null
Groupe(3) = null
Groupe(4) = null
Groupe(5) = null

start=14, fin=26
Groupe(0) = /appSettings
Groupe(1) = appSettings
Groupe(2) = null
Groupe(3) = null
Groupe(4) = null
Groupe(5) = null

start=26, fin=43
Groupe(0) = /add[@key='nom']
Groupe(1) = ajouter
Groupe(2) = [@key='nom']
Groupe(3) = clé
Groupe(4) = nom
Groupe(5) = null

start=43, fin=50
Groupe(0) = /@value
Groupe(1) = null
Groupe(2) = null
Groupe(3) = null
Groupe(4) = null
Groupe(5) = valeur

---

Qui signifie que nous avons

Groupe(0) = Ignoré
Groupe(1) = Le nom de l'élément
Groupe(2) = Ignoré
Groupe(3) = Filtre d'attribut nom
Groupe(4) = Filtre de valeur de l'attribut

Ici est une méthode java qui peut utiliser le modèle de

public static Node createNodeFromXPath(Document doc, String expression) throws XPathExpressionException {
StringBuilder currentPath = new StringBuilder();
Matcher matcher = xpathParserPattern.matcher(expression);
Node currentNode = doc.getFirstChild();
while (matcher.find()) {
String currentXPath = matcher.group(0);
String elementName = matcher.group(1);
String filterName = matcher.group(3);
String filterValue = matcher.group(4);
String attributeName = matcher.group(5);
StringBuilder builder = currentPath.append(currentXPath);
String relativePath = builder.toString();
Node newNode = selectSingleNode(doc, relativePath);
if (newNode == null) {
if (attributeName != null) {
((Element) currentNode).setAttribute(attributeName, "");
newNode = selectSingleNode(doc, relativePath);
} else if (elementName != null) {
Element element = doc.createElement(elementName);
if (filterName != null) {
element.setAttribute(filterName, filterValue);
}
currentNode.appendChild(element);
newNode = element;
} else {
throw new UnsupportedOperationException("The given xPath is not supported " + relativePath);
}
}
currentNode = newNode;
}
if (selectSingleNode(doc, expression) == null) {
throw new IllegalArgumentException("The given xPath cannot be created " + expression);
}
return currentNode;

}