Cel mai bun mod de a obține InnerXml al unui XElement?

Am ajuns să folosesc acest lucru:

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

Personal, am ajuns să scriu o metodă de extensie InnerXml folosind metoda Aggregate:

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

Codul clientului meu este la fel de tare ca și în vechiul spațiu de nume System.Xml:

var innerXml = myXElement.InnerXml();

tu stii? cel mai bun lucru de făcut este să vă întoarceți la CDATA: (im uita la soluții aici, dar cred că CDATA este de departe cel mai simplu și mai ieftin, nu cel mai convenabil de a dezvolta cu tho

Cu toată încrederea acordată celor care au descoperit și au dovedit cea mai bună abordare (mulțumită!), Aici este înfășurată într-o metodă de extensie:

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

Ce zici de folosirea acestei metode de "extensie" pe XElement? a lucrat pentru mine!

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();
}

Sau foloseste un pic 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: The code above has to use element.Nodes() as opposed to element.Elements(). Very important thing to remember the difference between the two. element.Nodes() gives you everything like XText, XAttribute etc, but XElement only an Element.

doc.ToString() or doc.ToString(SaveOptions) does the work. See http://msdn.microsoft.com/en-us/library/system.xml.linq.xelement.tostring(v=vs.110).aspx

Cred că aceasta este o metodă mult mai bună (în VB, nu ar trebui să fie greu de tradus):

Având un XElement x:

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

Păstrați-l simplu și eficient:

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

• Agregatul este memorie și performanță ineficiente atunci când concatenarea șirurilor
• Folosind Join ("", sth) folosiți o matrice de șir de două ori mai mare decât Concat ... Și arată destul de ciudat în cod.
• Folosind + = pare foarte ciudat, dar se pare că nu este mult mai rău decât să folosești "+" - probabil că ar fi optimizat la același cod, deoarece rezultatul alocării nu este folosit și ar putea fi înlăturat în siguranță de compilator.
• StringBuilder este atât de imperativ - și toată lumea știe că "starea" inutilă este insuportabilă.

Am vrut să văd care dintre aceste soluții sugerate a fost cea mai bună, așa că am făcut niște teste comparative. Din interes, am comparat, de asemenea, metodele LINQ cu metoda System.Xml veche, sugerată de Greg. Variația a fost interesantă și nu cea pe care am așteptat-o, cele mai lente metode fiind mai mult de 3 ori mai lent decât cele mai rapide .

Rezultatele comandate de cel mai rapid la cel mai lent:

1. CreateReader - Hunter de instanță (0.113 secunde)
2. Sistemul vechi System.Xml - Greg Hurlman (0.134 secunde)
3. Agregat cu concatenare în șir - Mike Powell (0.324 secunde)
4. StringBuilder - Vin (0.333 secunde)
5. String.Join pe matrice - Terry (0.360 secunde)
6. String.Concat pe matrice - Marcin Kosieradzki (0.364)

Metoda

Am folosit un singur document xml cu 20 de noduri identice (numit "hint"):

  Thinking of using a fake address?
  

  Please don't. If we can't verify your address we might just
  have to reject your application.

Numerele afișate ca secunde de mai sus sunt rezultatul extragerii "interiorului XML" al celor 20 de noduri, de 1000 de ori la rând, și luarea mediei (mediei) a 5 runde. Nu am inclus timpul necesar pentru a încărca și analiza xml într-un XmlDocument (pentru metoda System.Xml ) sau XDocument pentru toți ceilalți).

The LINQ algorithms I used were: (C# - all take an XElement "parent" and return the inner xml string)

CreateReader:

var reader = parent.CreateReader();
reader.MoveToContent();

return reader.ReadInnerXml();

Agregat cu concatenare șir:

return parent.Nodes().Aggregate("", (b, node) => b += node.ToString());

StringBuilder:

StringBuilder sb = new StringBuilder();

foreach(var node in parent.Nodes()) {
    sb.Append(node.ToString());
}

return sb.ToString();

String.Join on array:

return String.Join("", parent.Nodes().Select(x => x.ToString()).ToArray());

String.Concat pe matrice:

return String.Concat(parent.Nodes().Select(x => x.ToString()).ToArray());

Nu am arătat algoritmul "Câmpie veche System.Xml" aici, deoarece el doar a sunat .InnerXml pe noduri.

Concluzie

Dacă performanța este importantă (de ex. O mulțime de XML, este analizată frecvent), aș folosi metoda CreateReader de fiecare dată când . Dacă faceți doar câteva întrebări, vă recomandăm să utilizați metoda Aggregate mai concisă a lui Mike.

Dacă utilizați xml pe elemente mari cu numeroase noduri (poate 100), probabil că veți începe să vedeți beneficiul folosirii StringBuilder prin metoda Aggregate, dar nu peste CreateReader . Nu cred că metodele Alăturați-vă și Concat ar fi mai eficiente în aceste condiții datorită pedepsii de a converti o listă mare într-o gamă largă liste mai mici).

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("", xElement.Name), "");
    return innerXml.Trim();
}

// utilizarea Regex ar putea fi mai rapidă pentru a decupa pur și simplu eticheta elementului de început și sfârșit

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