StringBuilder vs XmlTextWriter

Question

Sto provando a spremere più prestazioni che posso da un HttpHandler personalizzato che serve contenuti Xml.

Mi chiedo quale sia il migliore per le prestazioni. Utilizzando la classe XmlTextWriter o ad-hoc operazioni StringBuilder come:

StringBuilder sb = new StringBuilder("<?xml version="1.0" encoding="UTF-8" ?>");  
sb.AppendFormat("<element>{0}</element>", SOMEVALUE); 

Qualcuno ha esperienza di prima mano?

Answer 1

Come ha detto Josh, questa è una micro-ottimizzazione che non dovresti nemmeno prendere in considerazione se non hai dimostrato la sua necessità. E 'anche molto difficile da testare:

static void Main(string[] arguments) 
{ 
    const int iterations = 100000; 

    Stopwatch sw = new Stopwatch(); 
    sw.Start(); 
    string s = CreateUsingStringBuilder("content", iterations); 
    sw.Stop(); 
    Console.WriteLine(String.Format("CreateUsingStringBuilder: {0}", sw.ElapsedMilliseconds)); 

    sw.Reset(); 
    sw.Start(); 
    s = CreateUsingXmlWriter("content", iterations); 
    sw.Stop(); 
    Console.WriteLine(String.Format("CreateUsingXmlWriter: {0}", sw.ElapsedMilliseconds)); 

    Console.ReadKey(); 
} 

private static string CreateUsingStringBuilder(string content, int iterations) 
{ 
    StringBuilder sb = new StringBuilder(); 
    for (int i = 0; i < iterations; i++) 
     sb.AppendFormat("<element>{0}</element>", content); 

    return sb.ToString(); 
} 

private static string CreateUsingXmlWriter(string content, int iterations) 
{ 
    StringBuilder sb = new StringBuilder(); 
    using (StringWriter sw = new StringWriter(sb)) 
    using (XmlWriter xw = XmlWriter.Create(sw)) 
    { 
     xw.WriteStartElement("root"); 
     for (int i = 0; i < iterations; i++) 
      xw.WriteElementString("element", content); 
     xw.WriteEndElement(); 
    } 
    return sb.ToString(); 
} 

Non solo è la versione XmlWriter costantemente più veloce per un millesimo di secondo o due, produce XML ben formato, che l'altro metodo non lo fa.

Ma entrambi i metodi stanno creando documenti XML di 100.000 elementi in circa 60 millisecondi sul mio computer portatile di due anni, una quantità di tempo che si riduce ad essere irrilevante rispetto al tempo necessario per spingere tanti dati sulla rete .

Answer 2

Onestamente fino a quando davvero, davvero, davvero, davvero, davvero è necessario preoccuparsi delle prestazioni ... no.

Per prima cosa, scegli la soluzione più manutenibile e comprometti solo quando le prestazioni diventano un problema misurabile. XmlTextWriter ti offre il vantaggio di "Sapere" su come Xml dovrebbe funzionare. StringBuilder non lo fa, ed è quindi soggetto a errori. Non vuoi trascorrere un giorno rintracciare un nodo malformato da qualche parte nel tuo codice gnarly per il builder.

Lascia che il framework funzioni per te.

Answer 3

Quando SOMEVALUE ha un & o < in esso, questo approccio ti porterà nei guai. Utilizzare le classi che riconoscono xml per generare xml. Leggere il numero HOWTO Avoid Being Called a Bozo When Producing XML.

Answer 4

Sono d'accordo che XmlWriter è migliore per la manutenibilità del codice, ma se si parla di ottimizzazione delle prestazioni, si dovrebbe evitare sia XmlWriter che StringBuilder.AppendFormat, perché l'utilizzo di un formattatore rovina le prestazioni.

cambiando

sb.AppendFormat("<element>{0}</element>", content); 

a

sb.Append("<element>").Append(content).Append("</element>"); 

rende la versione StringBuilder 2,5 volte più veloce poi l'altro dalla risposta di Robert.