CODEWITHSUNDEEP
c#xml
Anton P
Anton P

Reputation:

StringBuilder vs XmlTextWriter

I am trying to squeeze as much performance as i can from a custom HttpHandler that serves Xml content.

I' m wondering which is better for performance. Using the XmlTextWriter class or ad-hoc StringBuilder operations like:

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

Does anyone have first hand experience?

Upvotes: 9

Views: 6952

Answers (4)

George Polevoy
George Polevoy

Reputation: 7681

I agree that XmlWriter is better for code maintainability, but if we are talking about performance optimization, you should avoid both XmlWriter and StringBuilder.AppendFormat, because using a formatter ruins performance.

changing 

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

to

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

makes the StringBuilder version 2.5 times faster then the other from Robert's answer.

Upvotes: 8

Robert Rossney
Robert Rossney

Reputation: 96770

As Josh said, this is a micro-optimization that you shouldn't even consider if you haven't proved its necessity. It's also really not difficult to test:

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

Not only is the XmlWriter version consistently faster by a millisecond or two, it produces well-formed XML, which the other method doesn't.

But both methods are creating 100,000-element XML documents in about 60 milliseconds on my two-year-old laptop, an amount of time that dwindles into insignificance compared with the time it will take to push that much data over the network.

Upvotes: 13

AakashM
AakashM

Reputation: 63358

When SOMEVALUE has a & or < in it, this approach will get you into trouble. Use xml-aware classes to to generate xml. Have a read of HOWTO Avoid Being Called a Bozo When Producing XML.

Upvotes: 2

Josh
Josh

Reputation: 44916

Honestly until you really, really, really, really, really need to care about performance... don't.

Go with the more maintainable solution first, and only compromise when performance becomes a measurable issue. XmlTextWriter offers you the benefit of "Knowing" about how Xml is supposed to work. StringBuilder does not, and is therefore error prone. You don't want to spend a day tracking down a malformed node somewhere in your gnarly stringbuilder code.

Let the framework work for you.

Upvotes: 1

Related Questions