Volevo vedere quale di queste soluzioni suggerite funzionasse meglio, quindi ho eseguito alcuni test comparativi. Per interesse, ho anche confrontato i metodi LINQ con il semplice vecchio metodo System.Xml suggerito da Greg. La variazione è stata interessante e non quella che mi aspettavo, con i metodi più lenti più di 3 volte più lenti del più veloce .
I risultati ordinati dal più veloce al più lento:
- CreateReader - Instance Hunter (0.113 secondi)
- Semplicemente vecchio System.Xml - Greg Hurlman (0.134 secondi)
- Aggregato con concatenazione di stringhe - Mike Powell (0,324 secondi)
- StringBuilder - Vin (0.333 secondi)
- String.Join on array - Terry (0.360 secondi)
- String.Concat on array - Marcin Kosieradzki (0.364)
Metodo
Ho usato un singolo documento XML con 20 nodi identici (chiamato 'suggerimento'):
<hint>
<strong>Thinking of using a fake address?</strong>
<br />
Please don't. If we can't verify your address we might just
have to reject your application.
</hint>
I numeri mostrati come secondi sopra sono il risultato dell'estrazione dell '"XML interno" dei 20 nodi, 1000 volte di fila, e prendendo la media (media) di 5 corse. Non ho incluso il tempo impiegato per caricare e analizzare l'XML in un XmlDocument(per il metodo System.Xml ) o XDocument(per tutti gli altri).
Gli algoritmi LINQ che ho usato erano: (C # - tutti prendono un XElement"genitore" e restituiscono la stringa XML interna)
CreateReader:
var reader = parent.CreateReader();
reader.MoveToContent();
return reader.ReadInnerXml();
Aggregato con concatenazione di stringhe:
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 su array:
return String.Join("", parent.Nodes().Select(x => x.ToString()).ToArray());
String.Concat su array:
return String.Concat(parent.Nodes().Select(x => x.ToString()).ToArray());
Non ho mostrato l'algoritmo "Plain old System.Xml" qui come sta solo chiamando .InnerXml sui nodi.
Conclusione
Se le prestazioni sono importanti (ad esempio un sacco di XML, analizzate frequentemente), utilizzerei il CreateReadermetodo di Daniel ogni volta . Se stai solo facendo alcune domande, potresti voler utilizzare il metodo aggregato più conciso di Mike.
Se stai usando XML su elementi di grandi dimensioni con molti nodi (forse 100), probabilmente inizieresti a vedere i vantaggi dell'utilizzo StringBuilderdel metodo Aggregate, ma non di quello CreateReader. Non credo che i metodi Joine Concatsarebbero mai più efficienti in queste condizioni a causa della penalità di convertire un elenco di grandi dimensioni in un array di grandi dimensioni (anche qui ovvio con elenchi più piccoli).