How to return XML in ASP.NET?

I have encountered many half-solutions to the task of returning XML in ASP.NET. I don’t want to blindly copy & paste some code that happens to work most of the time, though; I want the right code, and I want to know why it’s right. I want criticism; I want information; I want knowledge; I want understanding.

Below are code fragments, in order of increasing complexity, representing some of the partial solutions I’ve seen, including some of the further questions each one causes, and which I’d like to have answered here.

A thorough answer must address why we must have or must not have any of the following things, or else explain why it’s irrelevant.

  • Response.Clear();
  • Response.ContentType = “text/xml”;
  • Response.ContentEncoding = Encoding.UTF8;
  • Response.ContentEncoding = Encoding.UTF16;
  • Response.ContentType = “text/xml; charset=utf-8”;
  • Response.ContentType = “text/xml; charset=utf-16”;
  • Response.End()
  • Using an aspx with the front-file guts ripped out
  • Using an ashx file

In the end, imagine you need to write the contents of a helper function like this:

///<summary>Use this call inside your (Page_Xxx) method to write the
///xml to the web client. </summary>
///<remarks>See for
///for proper usage.</remarks>
public static void ReturnXmlDocumentToWebClient(
    XmlDocument document,
    Page page)

Every solution I see starts with taking an empty aspx page, and trimming all the HTML out of the front file (which causes warnings in Visual Studio):

<%@ Page Language="C#"
      Inherits="GetTheXml" %>

Next we use the Page_Load event to write to the output:

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";


Do we need to change the ContentType to “text/xml”? I.e.:

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";

   Response.ContentType = "text/xml";

Do we need to call Response.Clear first?

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";

   Response.ContentType = "text/xml";

Do we really need to call that? Doesn’t Response.Clear make the prior step of making sure that the code in the front file was empty (not even a space or a carriage return) outside of the <% ... %> unnecessary?

Does Response.Clear make it more robust, in case someone left a blank line or space in the code-front file?

Is using ashx the same as a blank aspx main file, because it’s understood that it’s not going to output HTML?

Do we need to call Response.End? I.e.:

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";

   Response.ContentType = "text/xml";

What else could possibly happen after Response.Write that needs us to end the response right now?

Is the content-type of text/xml sufficient, or should it instead be text/xml; charset=utf-8?

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";

   Response.ContentType = "text/xml; charset=utf-8";

Or should it specifically not be that? Does having a charset in the content type, but not setting the property, screw up the server?

Why not some other content type, e.g.:

  • UTF-8
  • utf-16
  • UTF-16

Should the charset be specified in Response.ContentEncoding?

protected void Page_Load(object sender, EventArgs e)
   String xml = "<foo>Hello, world!</foo>";

   Response.ContentType = "text/xml";
   Response.ContentEncoding = Encoding.UTF8;

Is using Response.ContentEncoding better than jamming it into Response.ContentType? Is it worse? Is the former supported? Is the latter?

I don’t actually want to write a String out; I want to write out an XmlDocument. Someone suggests I can use the XmlWriter:

protected void Page_Load(object sender, EventArgs e)
   XmlDocument xml = GetXmlDocumentToShowTheUser();

   Response.ContentType = "text/xml";
   Response.ContentEncoding = Encoding.UTF8;

   using (TextWriter textWriter = new StreamWriter(
       XmlTextWriter xmlWriter = new XmlTextWriter(textWriter);
       // Write XML using xmlWriter
       //TODO: How to do this?

Note the use of Response.OutputStream, rather than Response.Write. Is this good? Bad? Better? Worse? Faster? Slower? More memory intensive? Less memory intensive?

I read that you should render

the XML in the page’s Render() method
to avoid problems with chunking
encountered when using Page_Load().

What is chunking?
What are the problems with chunking, and how does using using Page_Render eliminate them?

I don’t want to write the contents of my XmlDocument object into a string and then write that because that wastes memory. That is, any of these would be bad:


Similar Questions

How to return XML in ASP.NET


How Return XML From ASPX in ASP.NET 1.1

Writing XML output to an ASP.NET webpage

How do you output XML from ASP.NET?

Creating an ASHX handler in ASP.NET


Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

I’ve found the proper way to return XML to a client in ASP.NET. I think if I point out the wrong ways, it will make the right way more understandable.






Response.ContentType = "text/xml";
Response.ContentEncoding = System.Text.Encoding.UTF8;


Response.ContentType = "text/xml"; //Must be 'text/xml'
Response.ContentEncoding = System.Text.Encoding.UTF8; //We'd like UTF-8
doc.Save(Response.Output); //Save to the text-writer
      //using the encoding of the text-writer
      //(which comes from response.contentEncoding)

Use a TextWriter

Do not use Response.OutputStream

Do use Response.Output

Both are streams, but Output is a TextWriter. When an XmlDocument saves itself to a TextWriter, it will use the encoding specified by that TextWriter. The XmlDocument will automatically change the xml declaration node to match the encoding used by the TextWriter. e.g. in this case the XML declaration node:

<?xml version="1.0" encoding="ISO-8859-1"?>

would become

<?xml version="1.0" encoding="UTF-8"?>

This is because the TextWriter has been set to UTF-8. (More on this in a moment). As the TextWriter is fed character data, it will encode it with the byte sequences appropriate for its set encoding.



In this example the document is incorrectly saved to the OutputStream, which performs no encoding change, and may not match the response’s content-encoding or the XML declaration node’s specified encoding.



The XML document is correctly saved to a TextWriter object, ensuring the encoding is properly handled.

Set Encoding

The encoding given to the client in the header:

Response.ContentEncoding = ...

must match the XML document’s encoding:

<?xml version="1.0" encoding="..."?>

must match the actual encoding present in the byte sequences sent to the client. To make all three of these things agree, set the single line:

Response.ContentEncoding = System.Text.Encoding.UTF8;

When the encoding is set on the Response object, it sets the same encoding on the TextWriter. The encoding set of the TextWriter causes the XmlDocument to change the xml declaration:

<?xml version="1.0" encoding="UTF-8"?>

when the document is Saved:


Save to the response Output

You do not want to save the document to a binary stream, or write a string:



Here the XML is incorrectly saved to a binary stream. The final byte encoding sequence won’t match the XML declaration, or the web-server response’s content-encoding.



Here the XML is incorrectly converted to a string, which does not have an encoding. The XML declaration node is not updated to reflect the encoding of the response, and the response is not properly encoded to match the response’s encoding. Also, storing the XML in an intermediate string wastes memory.

You don’t want to save the XML to a string, or stuff the XML into a string and response.Write a string, because that:

- doesn't follow the encoding specified
- doesn't set the XML declaration node to match
- wastes memory

Do use doc.Save(Response.Output);

Do not use doc.Save(Response.OutputStream);

Do not use Response.Write(doc.ToString());

Do not use ‘Response.Write(doc.InnerXml);`

Set the content-type

The Response’s ContentType must be set to "text/xml". If not, the client will not know you are sending it XML.

Final Answer

Response.Clear(); //Optional: if we've sent anything before
Response.ContentType = "text/xml"; //Must be 'text/xml'
Response.ContentEncoding = System.Text.Encoding.UTF8; //We'd like UTF-8
doc.Save(Response.Output); //Save to the text-writer
    //using the encoding of the text-writer
    //(which comes from response.contentEncoding)
Response.End(); //Optional: will end processing

Complete Example

Rob Kennedy had the good point that I failed to include the start-to-finish example.


<%@ WebHandler Language="C#" Class="Handler" %>

using System;
using System.Web;
using System.Xml;
using System.IO;
using System.Data.Common;

//Why a "Handler" and not a full ASP.NET form?
//Because many people online critisized my original solution
//that involved the aspx (and cutting out all the HTML in the front file),
//noting the overhead of a full viewstate build-up/tear-down and processing,
//when it's not a web-form at all. (It's a pure processing.)

public class Handler : IHttpHandler
   public void ProcessRequest(HttpContext context)
      //GetXmlToShow will look for parameters from the context
      XmlDocument doc = GetXmlToShow(context);

      //Don't forget to set a valid xml type.
      //If you leave the default "text/html", the browser will refuse to display it correctly
      context.Response.ContentType = "text/xml";

      //We'd like UTF-8.
      context.Response.ContentEncoding = System.Text.Encoding.UTF8;
      //context.Response.ContentEncoding = System.Text.Encoding.UnicodeEncoding; //But no reason you couldn't use UTF-16:
      //context.Response.ContentEncoding = System.Text.Encoding.UTF32; //Or UTF-32
      //context.Response.ContentEncoding = new System.Text.Encoding(500); //Or EBCDIC (500 is the code page for IBM EBCDIC International)
      //context.Response.ContentEncoding = System.Text.Encoding.ASCII; //Or ASCII
      //context.Response.ContentEncoding = new System.Text.Encoding(28591); //Or ISO8859-1
      //context.Response.ContentEncoding = new System.Text.Encoding(1252); //Or Windows-1252 (a version of ISO8859-1, but with 18 useful characters where they were empty spaces)

      //Tell the client don't cache it (it's too volatile)
      //Commenting out NoCache allows the browser to cache the results (so they can view the XML source)
      //But leaves the possiblity that the browser might not request a fresh copy

      //And now we tell the browser that it expires immediately, and the cached copy you have should be refreshed
      context.Response.Expires = -1;

      context.Response.Cache.SetAllowResponseInBrowserHistory(true); //"works around an Internet&nbsp;Explorer bug"

      doc.Save(context.Response.Output); //doc saves itself to the textwriter, using the encoding of the text-writer (which comes from response.contentEncoding)

      #region Notes
       * 1. Use Response.Output, and NOT Response.OutputStream.
       *  Both are streams, but Output is a TextWriter.
       *  When an XmlDocument saves itself to a TextWriter, it will use the encoding
       *  specified by the TextWriter. The XmlDocument will automatically change any
       *  XML declaration node, i.e.:
       *     <?xml version="1.0" encoding="ISO-8859-1"?>
       *  to match the encoding used by the Response.Output's encoding setting
       * 2. The Response.Output TextWriter's encoding settings comes from the
       *  Response.ContentEncoding value.
       * 3. Use doc.Save, not Response.Write(doc.ToString()) or Response.Write(doc.InnerXml)
       * 3. You DON'T want to save the XML to a string, or stuff the XML into a string
       *  and response.Write that, because that
       *   - doesn't follow the encoding specified
       *   - wastes memory
       * To sum up: by Saving to a TextWriter: the XML Declaration node, the XML contents,
       * and the HTML Response content-encoding will all match.
      #endregion Notes

   private XmlDocument GetXmlToShow(HttpContext context)
      //Use context.Request to get the account number they want to return
      //GET /GetPatronInformation.ashx?accountNumber=619

      //Or since this is sample code, pull XML out of your rear:
      XmlDocument doc = new XmlDocument();
      doc.LoadXml("<Patron><Name>Rob Kennedy</Name></Patron>");

      return doc;

   public bool IsReusable { get { return false; } }

Method 2

Ideally you would use an ashx to send XML although I do allow code in an ASPX to intercept normal execution.


I don’t use this if you not sure you’ve dumped anything in the response already the go find it and get rid of it.

Response.ContentType = "text/xml"

Definitely, a common client will not accept the content as XML without this content type present.

 Response.Charset = "UTF-8";

Let the response class handle building the content type header properly. Use UTF-8 unless you have a really, really good reason not to.


If you don’t send cache headers some browsers (namely IE) will cache the response, subsequent requests will not necessarily come to the server. You also need to AllowResponseInBrowser if you want this to work over HTTPS (due to yet another bug in IE).

To send content of an XmlDocument simply use:


Just be sure the encodings match, (another good reason to use UTF-8).

The XmlDocument object will automatically adjust its embedded encoding="..." encoding to that of the Response (e.g. UTF-8)


If you really have to in an ASPX but its a bit drastic, in an ASHX don’t do it.

Method 3

Below is an example of the correct way I think. At least it is what I use.
You need to do Response.Clear to get rid of any headers that are already populated.
You need to pass the correct ContentType of text/xml. That is the way you serve xml.
In general you want to serve it as charset UTF-8 as that is what most parsers are expecting. But I don’t think it has to be that. But if you change it make sure to change your xml document declaration and indicate the charset in there.
You need to use the XmlWriter so you can actually write in UTF-8 and not whatever charset is the default. And to have it properly encode your xml data in UTF-8.

   ' -----------------------------------------------------------------------------
   ' OutputDataSetAsXML
   ' Description: outputs the given dataset as xml to the response object
   ' Arguments:
   '    dsSource           - source data set
   ' Dependencies:
   ' History
   ' 2006-05-02 - WSR : created
   Private Sub OutputDataSetAsXML(ByRef dsSource As System.Data.DataSet)

      Dim xmlDoc As System.Xml.XmlDataDocument
      Dim xmlDec As System.Xml.XmlDeclaration
      Dim xmlWriter As System.Xml.XmlWriter

      ' setup response
      Me.Response.ContentType = "text/xml"
      Me.Response.Charset = "utf-8"
      xmlWriter = New System.Xml.XmlTextWriter(Me.Response.OutputStream, System.Text.Encoding.UTF8)

      ' create xml data document with xml declaration
      xmlDoc = New System.Xml.XmlDataDocument(dsSource)
      xmlDoc.DataSet.EnforceConstraints = False
      xmlDec = xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", Nothing)

      ' write xml document to response

   End Sub
   ' -----------------------------------------------------------------------------

Method 4

Seems like at least 10 questions rolled into one here, a couple points.

Response.Clear – it really depends on what else is going on in the app – if you have httpmodules early in the pipeline that might be writing stuff you don’t want – then clear it. Test it and find out. Fiddler or Wireshark useful for this.

Content Type to text/xml – yup – good idea – read up on HTTP spec as to why this is important.
IMO anyone doing web work should have read the 1.0 and 1.1 spec at least once.

Encoding – how is your xml encoded – if it is utf-8, then say so, if not, say something else appropriate, just make sure they all match.

Page – personally, would use ashx or httpmodule, if you are using page, and want it a bit faster, get rid of autoeventwireup and bind the event handlers manually.

Would probably be a bit of a waste of memory to dump the xml into a string first, but it depends a lot on the size of the xml as to whether you would ever notice.

As others have suggested, saving the xml to the output stream probably the fastest, I would normally do that, but if you aren’t sure, test it, don’t rely on what you read on the interweb. Don’t just believe anything I say.

For another approach, if the xml doesn’t change that much, you could just write it to the disk and serve the file directly, which would likely be quite performant, but like everything in programming, it depends…

Method 5

I’m surprised that nobody seems to have ever mentioned that you can use XDocument / XElement which are available in .NET 4.0 and make it much easier to output XML.

Method 6

Below is the server side code that would call the handler and recieve the stream data and loads into xml doc

 Stream stream = null;
       **Create a web request with the specified URL**
        WebRequest myWebRequest = WebRequest.Create(@"http://localhost/XMLProvider/XMLProcessorHandler.ashx");
        **Senda a web request and wait for response.**
        WebResponse webResponse = myWebRequest.GetResponse();
        **Get the stream object from response object**
        stream = webResponse.GetResponseStream();

       XmlDocument xmlDoc = new XmlDocument();
      **Load stream data into xml**

Method 7

Below is the way a handler will returns stream data that would contain xml data in the server side.

Here is the handler code that would returns the data.

    public void ProcessRequest(HttpContext context)

        StringBuilder xmlBuilder = new StringBuilder();

        context.Response.ContentType = "application/octet-stream";


Method 8

XmlDocument xd = new XmlDocument();

context.Response.ContentType = "text/xml";
context.Response.ContentEncoding = System.Text.Encoding.UTF8;
context.Response.SuppressContent = true;

Method 9

You’ve basically answered anything and everything already, so I’m no sure what the point is here?

FWIW I would use an httphandler – there seems no point in invoking a page lifecycle and having to deal with clipping off the bits of viewstate and session and what have you which don’t make sense for an XML doc. It’s like buying a car and stripping it for parts to make your motorbike.

And content-type is all important, it’s how the requester knows what to do with the response.

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

0 0 votes
Article Rating
Notify of

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x