Use OutputStream With XmlWriter - ASP.NET

Problem

Effectively use Response.OutputStream along with XmlWriter. We need to write XML directly into an .aspx page in ASP.NET, replacing the entire page with well-formed XML. There are many ways to do this, but some ways are better than others. We want to see how to use XmlWriter and OutputStream to solve our problem easily, and maintain correct content encodings.

Solution: C#

You know what Response.Write does--it is a C# function in ASP.NET that writes text directly to the page. If you call Response.Write in a code-behind file, the parameter will be inserted directly into the page. Let me show some common ASP.NET objects that we can use for our solution.

Google Sitemap

For our example, we will make a cool Google sitemap using some of the above methods and objects. Let me say that what we are doing here is replacing the entire .aspx markup stored in the file with the output of code that writes to the Response. It sounds complicated, but it is simpler than some approaches.

What do I put in my .aspx page?

The first code sample here is an example aspx page. I use a script block at the very start of the page to store some C# code. In that block, we need to use the Page_Load event. Don't worry about the parameters to Page_Load or the protected keyword--that is just boilerplate.

<%@ Page Language="C#" %>
<script runat="server" type="text/C#">
    protected void Page_Load(object sender, EventArgs e)
    {
        Response.ContentType = "text/xml"; // Set ContentType.
        // Custom "Google map" function called here.
        WriteGoogleMap("http://dotnetperls.com/", Response.OutputStream);
        Response.End(); // Important!
        return;
    }
</script>

• Response.ContentType is set to "text/xml"
  You need to do this for XML files like Google Sitemaps or RSS feeds. Internet Explorer can be difficult to deal with unless you do this right!
• Custom method called
  A method called WriteGoogleMap is called and is passed a string and a Stream object.
• Response.OutputStream is sent
  This is a Stream object just like FileStream or many other versions in .NET. It can be written to in the same way.
• Response.End terminates the page
  Response.End() is called to stop any further content from being rendered.

How do we write to the OutputStream?

Let's look at the method that actually writes the XML to the Response.OutputStream. What this method does is construct an entire XML document from start to finish. Because the OutputStream is set as the buffer for XmlWriter, when XmlWriter adds elements they will be added to the Response text automatically.

/// <summary>
/// Write an XML document.
/// </summary>
public void WriteGoogleMap(string urlBase, Stream stream)
{
    XmlWriterSettings settings = new XmlWriterSettings();
    settings.Encoding = Encoding.UTF8;
    settings.Indent = true;

    // Write XML to the stream. 'using' will ensure that resources
    // are efficiently managed by the runtime.
    using (XmlWriter writer = XmlWriter.Create(stream, settings))
    {
        writer.WriteStartDocument();
        writer.WriteStartElement("urlset",
            "http://www.sitemaps.org/schemas/sitemap/0.9");

        // The following statements and the foreach loop simply add stuff to the XML
        // file. This code isn't important to my example.
        // We use the var keyword for simpler syntax.
        var pageList = from page in _x.Elements("SitePage")
                       where page.Element("Visibility").Value != "External"
                       orderby page.Element("Url").Value
                       select page;

        foreach (XElement page in pageList)
        {
            writer.WriteStartElement("url");
            writer.WriteElementString("loc", urlBase + page.Element("Url").Value);
            writer.WriteEndElement();
        }
        writer.WriteEndElement();
        writer.WriteEndDocument();
    }
}

• Mostly app-specific
  Much of the code is application-specific and you don't need to fret about it. What I want to show is that the method receives a Stream, which is the OutputStream of the .aspx file.
• XmlWriter writes to Stream
  When we use the XmlWriter to write XML to the page, it is actually added directly to the aspx page.
• Writer settings
  XmlWriterSettings is used to specify an encoding for XmlWriter. Encodings are tricky and I will discuss these in more detail later.
• ... and many method calls
  Look at the writer.WriteStartDocument() call, and the WriteStartElement, WriteElementString, and WriteEndElement calls. These simply add XML tags to our Stream.

What should I know about content encoding?

This is important, and is the hardest thing about this stuff. Your text encoding needs to match the XML declaration. Calling Response.Write may result in a different encoding than regular C# strings. So, we can't mix C# XML strings with Response.Write. Don't use Response.Write for XML because it will mess up with your encoding.

• Example eliminates strings
  This example eliminates the C# strings and uses the OutputStream directly, which is much better. Use OutputStream for writing XML to a document in the correct ContentEncoding.
• Internet Explorer 7
  Internet Explorer 7 will not tolerate pages with abnormal encoding setups, so it is critical that you write the XML with the encodings normalized. If you don't use Response.Write and use OutputStream instead, you won't have this headache.

Conclusion

Using OutputStream and XmlWriter is a great way to fix encoding problems, and easily create dynamic XML files in aspx code-behind. It works very well and the XML you create will be interoperable and usable in every web browser and compliant program. Response.Write will make your life harder, even though it seems simpler.