This class implements the System.Xml.XmlWriter class.

XmlTextWriter maintains a namespace stack corresponding to all the namespaces defined in the current element stack. Using XmlTextWriter you can declare namespaces manually.

 w.WriteStartElement("root");
 w.WriteAttributeString("xmlns", "x", null, "urn:1");
  w.WriteStartElement("item","urn:1");
  w.WriteEndElement();
  w.WriteStartElement("item","urn:1");
  w.WriteEndElement();
 w.WriteEndElement();

The above C# code produces the following output. XmlTextWriter promotes the namespace declaration to the root element to avoid having it duplicated on the two child elements. The child elements pick up the prefix from the namespace declaration.

 <root xmlns:x="urn:1">
  <x:item/>
  <x:item/>
 </x:root>

XmlTextWriter also allows you to override the current namespace declaration. In the following example, the namespace URI "123" is overridden by "abc" to produce the XML element <x:node xmlns:x="abc"/>.

 w.WriteStartElement("x","node","123");
 w.WriteAttributeString("xmlns","x",null,"abc");

By using the write methods that take a prefix as an argument you can also specify which prefix to use. In the following example, two different prefixes are mapped to the same namespace URI to produce the XML text <x:root xmlns:x="urn:1"><y:item xmlns:y="urn:1"/></x:root>.

 XmlTextWriter w = new XmlTextWriter(Console.Out);
 w.WriteStartElement("x","root","urn:1");
  w.WriteStartElement("y","item","urn:1");
  w.WriteEndElement();
 w.WriteEndElement();
 w.Close();

If there are multiple namespace declarations mapping different prefixes to the same namespace URI, XmlTextWriter walks the stack of namespace declarations backwards and picks the closest one.

 XmlTextWriter w = new XmlTextWriter(Console.Out);
 w.Formatting = Formatting.Indented;
 w.WriteStartElement("x","root","urn:1");
 w.WriteStartElement("y","item","urn:1");
 w.WriteAttributeString("attr","urn:1","123");
 w.WriteEndElement();
 w.WriteEndElement();
 w.Close();

In the above C# example, because the WriteAttributeString call does not specify a prefix, the writer uses the last prefix pushed onto the namespace stack, and produces the following XML:

 <x:root xmlns:x="urn:1">
  <y:item y:attr="123" xmlns:y="urn:1" />
 </x:root>

If namespace conflicts occur, XmlTextWriter resolves them by generating alternate prefixes. For example, if an attribute and element have the same prefix but different namespaces, XmlWriter generates an alternate prefix for the attribute. The generated prefixes are named n{i} where i is a number beginning at 1. The number is reset to 1 for each element.

Attributes which are associated with a namespace URI must have a prefix (default namespaces do not apply to attributes). This conforms to section 5.2 of the W3C Namespaces in XML recommendation. If an attribute references a namespace URI, but does not specify a prefix, the writer generates a prefix for the attribute.

When writing an empty element, an additional space is added between tag name and the closing tag, for example <item />. This provides compatibility with older browsers.

When a String is used as method parameter, null and String.Empty are equivalent. String.Empty follows the W3C rules.

To write strongly typed data, use the System.Xml.XmlConvert class to convert data types to string. For example, the following C# code converts the data from Double to String and writes the element <price>19.95</price>.

 Double price = 19.95;
 writer.WriteElementString("price", XmlConvert.ToString(price));

XmlTextWriter does not check for the following:

• Invalid characters in attribute and element names.

• Unicode characters that do not fit the specified encoding. If the Unicode characters do not fit the specified encoding, the XmlTextWriter does not escape the Unicode characters into character entities.

• Duplicate attributes.

• Characters in the DOCTYPE public identifier or system identifier.

For more information about writing XML, see Writing XML with the XmlWriter.

Security Considerations

The following items are things to consider when working with the System.Xml.XmlTextWriter class.

• Exceptions thrown by the System.Xml.XmlTextWriter can disclose path information that you do not want bubbled up to the application. Your applications must catch exceptions and process them appropriately.

• When you pass the System.Xml.XmlTextWriter to another application the underlying stream is exposed to that application. If you need to pass the System.Xml.XmlTextWriter to a semi-trusted application, you should use an System.Xml.XmlWriter object created by the XmlWriter.Create(XmlWriter) method instead.

• The System.Xml.XmlTextWriter does not validate any data that is passed to the XmlTextWriter.WriteDocType(string, string, string, string) or erload:System.Xml.XmlTextWriter.WriteRaw methods. You should not pass arbitrary data to these methods.

• If the default settings are changed, there is no guarantee that the generated output is well-formed XML data.

• Do not accept supporting components, such as an System.Text.Encoding object, from an untrusted source.

The following example demonstrates how this class resolves namespace conflicts inside an element. In the example, the writer writes an element that contains two attributes. The element and both attributes have the same prefix but different namespaces. The resulting XML fragment is written to the console.

using System;
using System.Xml;

public class WriteFragment 
{
  public static void Main() 
  {
    XmlTextWriter xWriter = new XmlTextWriter(Console.Out);    
    xWriter.WriteStartElement("prefix", "Element1", "namespace"); 
    xWriter.WriteStartAttribute("prefix", "Attr1", "namespace1"); 
    xWriter.WriteString("value1"); 
    xWriter.WriteStartAttribute("prefix", "Attr2", "namespace2"); 
    xWriter.WriteString("value2"); 
    xWriter.Close();           
  }
}
   

The output is

<prefix:Element1 n1:Attr1="value1" n2:Attr2="value2" xmlns:n2="namespace2" xmlns:n1="namespace1" xnlns:prefix="namespace" />