La meilleure façon D'obtenir InnerXml d'un XElement?

je pense que c'est une méthode bien meilleure (en VB, ne devrait pas être difficile à traduire):

Donné un XElement x:

Dim xReader = x.CreateReader
xReader.MoveToContent
xReader.ReadInnerXml

Que Diriez-vous d'utiliser cette méthode d'extension sur XElement? a fonctionné pour moi !

public static string InnerXml(this XElement element)
{
    StringBuilder innerXml = new StringBuilder();

    foreach (XNode node in element.Nodes())
    {
        // append node's xml string to innerXml
        innerXml.Append(node.ToString());
    }

    return innerXml.ToString();
}

ou utilisez un peu de Linq

public static string InnerXml(this XElement element)
{
    StringBuilder innerXml = new StringBuilder();
    doc.Nodes().ToList().ForEach( node => innerXml.Append(node.ToString()));

    return innerXml.ToString();
}

Note : le code ci-dessus doit utiliser element.Nodes() par opposition à element.Elements() . Chose très importante à retenir la différence entre les deux. element.Nodes() vous donne tout comme XText , XAttribute etc, mais XElement seulement un élément.

avec tout le mérite de ceux qui ont découvert et prouvé la meilleure approche (merci!

public static string InnerXml(this XNode node) {
    using (var reader = node.CreateReader()) {
        reader.MoveToContent();
        return reader.ReadInnerXml();
    }
}

Keep it simple et efficace:

String.Concat(node.Nodes().Select(x => x.ToString()).ToArray())

• le total est de la mémoire et des performances inefficace lors de la concaténation de chaînes de caractères
• utilisant Join ( "" , sth) utilise un tableau de chaînes de caractères deux fois plus grand que Concat... Et semble assez étrange dans le code.
• en utilisant + = semble très étrange, mais n'est apparemment pas beaucoup pire que d'utiliser ' + ' - serait probablement optimisé pour le même code, becase résultat d'attribution est inutilisée et pourrait être retiré en toute sécurité par compilateur.
• StringBuilder est tellement impératif - et tout le monde sait que "l'état" inutile craint.

j'ai fini par utiliser ceci:

Body = t.Element("body").Nodes().Aggregate("", (b, node) => b += node.ToString());

personnellement, j'ai fini par écrire une méthode d'extension InnerXml utilisant la méthode agrégée:

public static string InnerXml(this XElement thiz)
{
   return thiz.Nodes().Aggregate( string.Empty, ( element, node ) => element += node.ToString() );
}

mon code client est alors aussi concis qu'il le serait avec l'ancien système.Espace de noms Xml:

var innerXml = myXElement.InnerXml();

@Greg: il semble que vous ayez modifié votre réponse pour être une réponse complètement différente. À laquelle ma réponse est oui, je pourrais le faire en utilisant le Système.Xml mais j'espérais me mouiller les pieds avec LINQ à XML.

je vais laisser ma réponse originale ci-dessous au cas où quelqu'un d'autre se demande pourquoi je ne peux pas juste utiliser les XElement .Valeur de la propriété pour obtenir ce dont j'ai besoin:

@Greg: la propriété Value concaténate tout le contenu de texte de tous les noeuds enfant. Donc si le corps l'élément ne contient que du texte qui fonctionne, mais s'il contient du XHTML, j'obtiens tout le texte concaténé, mais aucune des balises.

/ / L'utilisation de Regex pourrait être plus rapide pour simplement couper l'étiquette d'élément de début et de fin

var content = element.ToString();
var matchBegin = Regex.Match(content, @"<.+?>");
content = content.Substring(matchBegin.Index + matchBegin.Length);          
var matchEnd = Regex.Match(content, @"</.+?>", RegexOptions.RightToLeft);
content = content.Substring(0, matchEnd.Index);

doc.ToString () ou doc.ToString (SaveOptions) fait le travail. Voir http://msdn.microsoft.com/en-us/library/system.xml.linq.xelement.tostring (v=V110).aspx

Est-il possible d'utiliser le Système.Objets XML namespace pour faire le travail ici au lieu D'utiliser LINQ? Comme vous l'avez déjà mentionné, XmlNode.InnerXml est exactement ce dont vous avez besoin.

Demandais si (avis que je me suis débarrassé de la b+= et b+)

t.Element( "body" ).Nodes()
 .Aggregate( "", ( b, node ) => b + node.ToString() );

pourrait être légèrement moins efficace que

string.Join( "", t.Element.Nodes()
                  .Select( n => n.ToString() ).ToArray() );

pas sûr à 100%...mais en regardant Aggregate() et string.Joindre () dans le réflecteur...I penser Je l'ai lu comme agrégat juste en ajoutant une valeur de retour, donc essentiellement vous obtenez:

string = string + chaîne

contre string.Rejoindre, il a quelques mention là-dedans de Fast Tringallocation ou quelque chose, ce qui me fait quelque chose les gens de Microsoft pourraient avoir mis un coup de pouce supplémentaire de performance là-dedans. Bien sûr, ma .ToArray () appelle cela ma négation, mais je voulais juste proposer une autre suggestion.

tu sais? la meilleure chose à faire est de revenir à CDATA :( je regarde des solutions ici, mais je pense que CDATA est de loin le plus simple et le moins cher, pas le plus commode à développer avec tho

public static string InnerXml(this XElement xElement)
{
    //remove start tag
    string innerXml = xElement.ToString().Trim().Replace(string.Format("<{0}>", xElement.Name), "");
    ////remove end tag
    innerXml = innerXml.Trim().Replace(string.Format("</{0}>", xElement.Name), "");
    return innerXml.Trim();
}