mscorlib-4.0-offline-doxygenated-documentation/html/_xml_text_writer_8cs_source.html

 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Globalization;
 using System.IO;
 using System.Text;

 namespace System.Xml
 {
     [EditorBrowsable(EditorBrowsableState.Never)]
     public class XmlTextWriter : XmlWriter
     {
         private enum NamespaceState
         {
             Uninitialized,
             NotDeclaredButInScope,
             DeclaredButNotWrittenOut,
             DeclaredAndWrittenOut
         }

         private struct TagInfo
         {
             internal string name;

             internal string prefix;

             internal string defaultNs;

             internal NamespaceState defaultNsState;

             internal XmlSpace xmlSpace;

             internal string xmlLang;

             internal int prevNsTop;

             internal int prefixCount;

             internal bool mixed;

             internal void Init(int nsTop)
             {
                 name = null;
                 defaultNs = string.Empty;
                 defaultNsState = NamespaceState.Uninitialized;
                 xmlSpace = XmlSpace.None;
                 xmlLang = null;
                 prevNsTop = nsTop;
                 prefixCount = 0;
                 mixed = false;
             }
         }

         private struct Namespace
         {
             internal string prefix;

             internal string ns;

             internal bool declared;

             internal int prevNsIndex;

             internal void Set(string prefix, string ns, bool declared)
             {
                 this.prefix = prefix;
                 this.ns = ns;
                 this.declared = declared;
                 prevNsIndex = -1;
             }
         }

         private enum SpecialAttr
         {
             None,
             XmlSpace,
             XmlLang,
             XmlNs
         }

         private enum State
         {
             Start,
             Prolog,
             PostDTD,
             Element,
             Attribute,
             Content,
             AttrOnly,
             Epilog,
             Error,
             Closed
         }

         private enum Token
         {
             PI,
             Doctype,
             Comment,
             CData,
             StartElement,
             EndElement,
             LongEndElement,
             StartAttribute,
             EndAttribute,
             Content,
             Base64,
             RawData,
             Whitespace,
             Empty
         }

         private TextWriter textWriter;

         private XmlTextEncoder xmlEncoder;

         private Encoding encoding;

         private Formatting formatting;

         private bool indented;

         private int indentation;

         private char indentChar;

         private TagInfo[] stack;

         private int top;

         private State[] stateTable;

         private State currentState;

         private Token lastToken;

         private XmlTextWriterBase64Encoder base64Encoder;

         private char quoteChar;

         private char curQuoteChar;

         private bool namespaces;

         private SpecialAttr specialAttr;

         private string prefixForXmlNs;

         private bool flush;

         private Namespace[] nsStack;

         private int nsTop;

         private Dictionary<string, int> nsHashtable;

         private bool useNsHashtable;

         private XmlCharType xmlCharType = XmlCharType.Instance;

         private const int NamespaceStackInitialSize = 8;

         private const int MaxNamespacesWalkCount = 16;

         private static string[] stateName = new string[10]
         {
             "Start",
             "Prolog",
             "PostDTD",
             "Element",
             "Attribute",
             "Content",
             "AttrOnly",
             "Epilog",
             "Error",
             "Closed"
         };

         private static string[] tokenName = new string[14]
         {
             "PI",
             "Doctype",
             "Comment",
             "CData",
             "StartElement",
             "EndElement",
             "LongEndElement",
             "StartAttribute",
             "EndAttribute",
             "Content",
             "Base64",
             "RawData",
             "Whitespace",
             "Empty"
         };

         private static readonly State[] stateTableDefault = new State[104]
         {
             State.Prolog,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Epilog,
             State.PostDTD,
             State.PostDTD,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Prolog,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Epilog,
             State.Content,
             State.Content,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Epilog,
             State.Element,
             State.Element,
             State.Element,
             State.Element,
             State.Element,
             State.Element,
             State.Error,
             State.Element,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Error,
             State.AttrOnly,
             State.Error,
             State.Error,
             State.Attribute,
             State.Attribute,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Element,
             State.Error,
             State.Epilog,
             State.Error,
             State.Content,
             State.Content,
             State.Error,
             State.Content,
             State.Attribute,
             State.Content,
             State.Attribute,
             State.Epilog,
             State.Content,
             State.Content,
             State.Error,
             State.Content,
             State.Attribute,
             State.Content,
             State.Attribute,
             State.Epilog,
             State.Prolog,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Attribute,
             State.Content,
             State.Attribute,
             State.Epilog,
             State.Prolog,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Attribute,
             State.Content,
             State.Attribute,
             State.Epilog
         };

         private static readonly State[] stateTableDocument = new State[104]
         {
             State.Error,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Epilog,
             State.Error,
             State.PostDTD,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Epilog,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Element,
             State.Element,
             State.Element,
             State.Element,
             State.Element,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Content,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Attribute,
             State.Attribute,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Element,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Attribute,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Error,
             State.Content,
             State.Attribute,
             State.Content,
             State.Error,
             State.Error,
             State.Error,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Attribute,
             State.Content,
             State.Error,
             State.Epilog,
             State.Error,
             State.Prolog,
             State.PostDTD,
             State.Content,
             State.Attribute,
             State.Content,
             State.Error,
             State.Epilog
         };

         public Stream BaseStream => (textWriter as StreamWriter)?.BaseStream;

         public bool Namespaces
         {
             get
             {
                 return namespaces;
             }
             set
             {
                 if (currentState != 0)
                 {
                     throw new InvalidOperationException(Res.GetString("Xml_NotInWriteState"));
                 }
                 namespaces = value;
             }
         }

         public Formatting Formatting
         {
             get
             {
                 return formatting;
             }
             set
             {
                 formatting = value;
                 indented = (value == Formatting.Indented);
             }
         }

         public int Indentation
         {
             get
             {
                 return indentation;
             }
             set
             {
                 if (value < 0)
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidIndentation"));
                 }
                 indentation = value;
             }
         }

         public char IndentChar
         {
             get
             {
                 return indentChar;
             }
             set
             {
                 indentChar = value;
             }
         }

         public char QuoteChar
         {
             get
             {
                 return quoteChar;
             }
             set
             {
                 if (value != '"' && value != '\'')
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidQuote"));
                 }
                 quoteChar = value;
                 xmlEncoder.QuoteChar = value;
             }
         }

         public override WriteState WriteState
         {
             get
             {
                 switch (currentState)
                 {
                 case State.Start:
                     return WriteState.Start;
                 case State.Prolog:
                 case State.PostDTD:
                     return WriteState.Prolog;
                 case State.Element:
                     return WriteState.Element;
                 case State.Attribute:
                 case State.AttrOnly:
                     return WriteState.Attribute;
                 case State.Content:
                 case State.Epilog:
                     return WriteState.Content;
                 case State.Error:
                     return WriteState.Error;
                 case State.Closed:
                     return WriteState.Closed;
                 default:
                     return WriteState.Error;
                 }
             }
         }

         public override XmlSpace XmlSpace
         {
             get
             {
                 for (int num = top; num > 0; num--)
                 {
                     XmlSpace xmlSpace = stack[num].xmlSpace;
                     if (xmlSpace != 0)
                     {
                         return xmlSpace;
                     }
                 }
                 return XmlSpace.None;
             }
         }

         public override string XmlLang
         {
             get
             {
                 for (int num = top; num > 0; num--)
                 {
                     string xmlLang = stack[num].xmlLang;
                     if (xmlLang != null)
                     {
                         return xmlLang;
                     }
                 }
                 return null;
             }
         }

         internal XmlTextWriter()
         {
             namespaces = true;
             formatting = Formatting.None;
             indentation = 2;
             indentChar = ' ';
             nsStack = new Namespace[8];
             nsTop = -1;
             stack = new TagInfo[10];
             top = 0;
             stack[top].Init(-1);
             quoteChar = '"';
             stateTable = stateTableDefault;
             currentState = State.Start;
             lastToken = Token.Empty;
         }

         public XmlTextWriter(Stream w, Encoding encoding)
             : this()
         {
             this.encoding = encoding;
             if (encoding != null)
             {
                 textWriter = new StreamWriter(w, encoding);
             }
             else
             {
                 textWriter = new StreamWriter(w);
             }
             xmlEncoder = new XmlTextEncoder(textWriter);
             xmlEncoder.QuoteChar = quoteChar;
         }

         public XmlTextWriter(string filename, Encoding encoding)
             : this(new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.Read), encoding)
         {
         }

         public XmlTextWriter(TextWriter w)
             : this()
         {
             textWriter = w;
             encoding = w.Encoding;
             xmlEncoder = new XmlTextEncoder(w);
             xmlEncoder.QuoteChar = quoteChar;
         }

         public override void WriteStartDocument()
         {
             StartDocument(-1);
         }

         public override void WriteStartDocument(bool standalone)
         {
             StartDocument(standalone ? 1 : 0);
         }

         public override void WriteEndDocument()
         {
             try
             {
                 AutoCompleteAll();
                 if (currentState != State.Epilog)
                 {
                     if (currentState == State.Closed)
                     {
                         throw new ArgumentException(Res.GetString("Xml_ClosedOrError"));
                     }
                     throw new ArgumentException(Res.GetString("Xml_NoRoot"));
                 }
                 stateTable = stateTableDefault;
                 currentState = State.Start;
                 lastToken = Token.Empty;
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteDocType(string name, string pubid, string sysid, string subset)
         {
             try
             {
                 ValidateName(name, isNCName: false);
                 AutoComplete(Token.Doctype);
                 textWriter.Write("<!DOCTYPE ");
                 textWriter.Write(name);
                 if (pubid != null)
                 {
                     textWriter.Write(" PUBLIC " + quoteChar.ToString());
                     textWriter.Write(pubid);
                     textWriter.Write(quoteChar.ToString() + " " + quoteChar.ToString());
                     textWriter.Write(sysid);
                     textWriter.Write(quoteChar);
                 }
                 else if (sysid != null)
                 {
                     textWriter.Write(" SYSTEM " + quoteChar.ToString());
                     textWriter.Write(sysid);
                     textWriter.Write(quoteChar);
                 }
                 if (subset != null)
                 {
                     textWriter.Write("[");
                     textWriter.Write(subset);
                     textWriter.Write("]");
                 }
                 textWriter.Write('>');
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteStartElement(string prefix, string localName, string ns)
         {
             try
             {
                 AutoComplete(Token.StartElement);
                 PushStack();
                 textWriter.Write('<');
                 if (namespaces)
                 {
                     stack[top].defaultNs = stack[top - 1].defaultNs;
                     if (stack[top - 1].defaultNsState != 0)
                     {
                         stack[top].defaultNsState = NamespaceState.NotDeclaredButInScope;
                     }
                     stack[top].mixed = stack[top - 1].mixed;
                     if (ns == null)
                     {
                         if (prefix != null && prefix.Length != 0 && LookupNamespace(prefix) == -1)
                         {
                             throw new ArgumentException(Res.GetString("Xml_UndefPrefix"));
                         }
                     }
                     else if (prefix == null)
                     {
                         string text = FindPrefix(ns);
                         if (text != null)
                         {
                             prefix = text;
                         }
                         else
                         {
                             PushNamespace(null, ns, declared: false);
                         }
                     }
                     else if (prefix.Length == 0)
                     {
                         PushNamespace(null, ns, declared: false);
                     }
                     else
                     {
                         if (ns.Length == 0)
                         {
                             prefix = null;
                         }
                         VerifyPrefixXml(prefix, ns);
                         PushNamespace(prefix, ns, declared: false);
                     }
                     stack[top].prefix = null;
                     if (prefix != null && prefix.Length != 0)
                     {
                         stack[top].prefix = prefix;
                         textWriter.Write(prefix);
                         textWriter.Write(':');
                     }
                 }
                 else if ((ns != null && ns.Length != 0) || (prefix != null && prefix.Length != 0))
                 {
                     throw new ArgumentException(Res.GetString("Xml_NoNamespaces"));
                 }
                 stack[top].name = localName;
                 textWriter.Write(localName);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteEndElement()
         {
             InternalWriteEndElement(longFormat: false);
         }

         public override void WriteFullEndElement()
         {
             InternalWriteEndElement(longFormat: true);
         }

         public override void WriteStartAttribute(string prefix, string localName, string ns)
         {
             try
             {
                 AutoComplete(Token.StartAttribute);
                 specialAttr = SpecialAttr.None;
                 if (namespaces)
                 {
                     if (prefix != null && prefix.Length == 0)
                     {
                         prefix = null;
                     }
                     if (ns == "http://www.w3.org/2000/xmlns/" && prefix == null && localName != "xmlns")
                     {
                         prefix = "xmlns";
                     }
                     if (prefix == "xml")
                     {
                         if (localName == "lang")
                         {
                             specialAttr = SpecialAttr.XmlLang;
                         }
                         else if (localName == "space")
                         {
                             specialAttr = SpecialAttr.XmlSpace;
                         }
                     }
                     else if (prefix == "xmlns")
                     {
                         if ("http://www.w3.org/2000/xmlns/" != ns && ns != null)
                         {
                             throw new ArgumentException(Res.GetString("Xml_XmlnsBelongsToReservedNs"));
                         }
                         if (localName == null || localName.Length == 0)
                         {
                             localName = prefix;
                             prefix = null;
                             prefixForXmlNs = null;
                         }
                         else
                         {
                             prefixForXmlNs = localName;
                         }
                         specialAttr = SpecialAttr.XmlNs;
                     }
                     else if (prefix == null && localName == "xmlns")
                     {
                         if ("http://www.w3.org/2000/xmlns/" != ns && ns != null)
                         {
                             throw new ArgumentException(Res.GetString("Xml_XmlnsBelongsToReservedNs"));
                         }
                         specialAttr = SpecialAttr.XmlNs;
                         prefixForXmlNs = null;
                     }
                     else if (ns == null)
                     {
                         if (prefix != null && LookupNamespace(prefix) == -1)
                         {
                             throw new ArgumentException(Res.GetString("Xml_UndefPrefix"));
                         }
                     }
                     else if (ns.Length == 0)
                     {
                         prefix = string.Empty;
                     }
                     else
                     {
                         VerifyPrefixXml(prefix, ns);
                         if (prefix != null && LookupNamespaceInCurrentScope(prefix) != -1)
                         {
                             prefix = null;
                         }
                         string text = FindPrefix(ns);
                         if (text != null && (prefix == null || prefix == text))
                         {
                             prefix = text;
                         }
                         else
                         {
                             if (prefix == null)
                             {
                                 prefix = GeneratePrefix();
                             }
                             PushNamespace(prefix, ns, declared: false);
                         }
                     }
                     if (prefix != null && prefix.Length != 0)
                     {
                         textWriter.Write(prefix);
                         textWriter.Write(':');
                     }
                 }
                 else
                 {
                     if ((ns != null && ns.Length != 0) || (prefix != null && prefix.Length != 0))
                     {
                         throw new ArgumentException(Res.GetString("Xml_NoNamespaces"));
                     }
                     if (localName == "xml:lang")
                     {
                         specialAttr = SpecialAttr.XmlLang;
                     }
                     else if (localName == "xml:space")
                     {
                         specialAttr = SpecialAttr.XmlSpace;
                     }
                 }
                 xmlEncoder.StartAttribute(specialAttr != SpecialAttr.None);
                 textWriter.Write(localName);
                 textWriter.Write('=');
                 if (curQuoteChar != quoteChar)
                 {
                     curQuoteChar = quoteChar;
                     xmlEncoder.QuoteChar = quoteChar;
                 }
                 textWriter.Write(curQuoteChar);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteEndAttribute()
         {
             try
             {
                 AutoComplete(Token.EndAttribute);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteCData(string text)
         {
             try
             {
                 AutoComplete(Token.CData);
                 if (text != null && text.IndexOf("]]>", StringComparison.Ordinal) >= 0)
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidCDataChars"));
                 }
                 textWriter.Write("<![CDATA[");
                 if (text != null)
                 {
                     xmlEncoder.WriteRawWithSurrogateChecking(text);
                 }
                 textWriter.Write("]]>");
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteComment(string text)
         {
             try
             {
                 if (text != null && (text.IndexOf("--", StringComparison.Ordinal) >= 0 || (text.Length != 0 && text[text.Length - 1] == '-')))
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidCommentChars"));
                 }
                 AutoComplete(Token.Comment);
                 textWriter.Write("<!--");
                 if (text != null)
                 {
                     xmlEncoder.WriteRawWithSurrogateChecking(text);
                 }
                 textWriter.Write("-->");
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteProcessingInstruction(string name, string text)
         {
             try
             {
                 if (text != null && text.IndexOf("?>", StringComparison.Ordinal) >= 0)
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidPiChars"));
                 }
                 if (string.Compare(name, "xml", StringComparison.OrdinalIgnoreCase) == 0 && stateTable == stateTableDocument)
                 {
                     throw new ArgumentException(Res.GetString("Xml_DupXmlDecl"));
                 }
                 AutoComplete(Token.PI);
                 InternalWriteProcessingInstruction(name, text);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteEntityRef(string name)
         {
             try
             {
                 ValidateName(name, isNCName: false);
                 AutoComplete(Token.Content);
                 xmlEncoder.WriteEntityRef(name);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteCharEntity(char ch)
         {
             try
             {
                 AutoComplete(Token.Content);
                 xmlEncoder.WriteCharEntity(ch);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteWhitespace(string ws)
         {
             try
             {
                 if (ws == null)
                 {
                     ws = string.Empty;
                 }
                 if (!xmlCharType.IsOnlyWhitespace(ws))
                 {
                     throw new ArgumentException(Res.GetString("Xml_NonWhitespace"));
                 }
                 AutoComplete(Token.Whitespace);
                 xmlEncoder.Write(ws);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteString(string text)
         {
             try
             {
                 if (text != null && text.Length != 0)
                 {
                     AutoComplete(Token.Content);
                     xmlEncoder.Write(text);
                 }
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteSurrogateCharEntity(char lowChar, char highChar)
         {
             try
             {
                 AutoComplete(Token.Content);
                 xmlEncoder.WriteSurrogateCharEntity(lowChar, highChar);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteChars(char[] buffer, int index, int count)
         {
             try
             {
                 AutoComplete(Token.Content);
                 xmlEncoder.Write(buffer, index, count);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteRaw(char[] buffer, int index, int count)
         {
             try
             {
                 AutoComplete(Token.RawData);
                 xmlEncoder.WriteRaw(buffer, index, count);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteRaw(string data)
         {
             try
             {
                 AutoComplete(Token.RawData);
                 xmlEncoder.WriteRawWithSurrogateChecking(data);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteBase64(byte[] buffer, int index, int count)
         {
             try
             {
                 if (!flush)
                 {
                     AutoComplete(Token.Base64);
                 }
                 flush = true;
                 if (base64Encoder == null)
                 {
                     base64Encoder = new XmlTextWriterBase64Encoder(xmlEncoder);
                 }
                 base64Encoder.Encode(buffer, index, count);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteBinHex(byte[] buffer, int index, int count)
         {
             try
             {
                 AutoComplete(Token.Content);
                 BinHexEncoder.Encode(buffer, index, count, this);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void Close()
         {
             try
             {
                 AutoCompleteAll();
             }
             catch
             {
             }
             finally
             {
                 currentState = State.Closed;
                 textWriter.Close();
             }
         }

         public override void Flush()
         {
             textWriter.Flush();
         }

         public override void WriteName(string name)
         {
             try
             {
                 AutoComplete(Token.Content);
                 InternalWriteName(name, isNCName: false);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override void WriteQualifiedName(string localName, string ns)
         {
             try
             {
                 AutoComplete(Token.Content);
                 if (namespaces)
                 {
                     if (ns != null && ns.Length != 0 && ns != stack[top].defaultNs)
                     {
                         string text = FindPrefix(ns);
                         if (text == null)
                         {
                             if (currentState != State.Attribute)
                             {
                                 throw new ArgumentException(Res.GetString("Xml_UndefNamespace", ns));
                             }
                             text = GeneratePrefix();
                             PushNamespace(text, ns, declared: false);
                         }
                         if (text.Length != 0)
                         {
                             InternalWriteName(text, isNCName: true);
                             textWriter.Write(':');
                         }
                     }
                 }
                 else if (ns != null && ns.Length != 0)
                 {
                     throw new ArgumentException(Res.GetString("Xml_NoNamespaces"));
                 }
                 InternalWriteName(localName, isNCName: true);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         public override string LookupPrefix(string ns)
         {
             if (ns == null || ns.Length == 0)
             {
                 throw new ArgumentException(Res.GetString("Xml_EmptyName"));
             }
             string text = FindPrefix(ns);
             if (text == null && ns == stack[top].defaultNs)
             {
                 text = string.Empty;
             }
             return text;
         }

         public override void WriteNmToken(string name)
         {
             try
             {
                 AutoComplete(Token.Content);
                 if (name == null || name.Length == 0)
                 {
                     throw new ArgumentException(Res.GetString("Xml_EmptyName"));
                 }
                 if (!ValidateNames.IsNmtokenNoNamespaces(name))
                 {
                     throw new ArgumentException(Res.GetString("Xml_InvalidNameChars", name));
                 }
                 textWriter.Write(name);
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         private void StartDocument(int standalone)
         {
             try
             {
                 if (currentState != 0)
                 {
                     throw new InvalidOperationException(Res.GetString("Xml_NotTheFirst"));
                 }
                 stateTable = stateTableDocument;
                 currentState = State.Prolog;
                 StringBuilder stringBuilder = new StringBuilder(128);
                 stringBuilder.Append("version=" + quoteChar.ToString() + "1.0" + quoteChar.ToString());
                 if (encoding != null)
                 {
                     stringBuilder.Append(" encoding=");
                     stringBuilder.Append(quoteChar);
                     stringBuilder.Append(encoding.WebName);
                     stringBuilder.Append(quoteChar);
                 }
                 if (standalone >= 0)
                 {
                     stringBuilder.Append(" standalone=");
                     stringBuilder.Append(quoteChar);
                     stringBuilder.Append((standalone == 0) ? "no" : "yes");
                     stringBuilder.Append(quoteChar);
                 }
                 InternalWriteProcessingInstruction("xml", stringBuilder.ToString());
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         private void AutoComplete(Token token)
         {
             if (currentState == State.Closed)
             {
                 throw new InvalidOperationException(Res.GetString("Xml_Closed"));
             }
             if (currentState == State.Error)
             {
                 throw new InvalidOperationException(Res.GetString("Xml_WrongToken", tokenName[(int)token], stateName[8]));
             }
             State state = stateTable[(int)((int)token * 8 + currentState)];
             if (state == State.Error)
             {
                 throw new InvalidOperationException(Res.GetString("Xml_WrongToken", tokenName[(int)token], stateName[(int)currentState]));
             }
             switch (token)
             {
             case Token.Doctype:
                 if (indented && currentState != 0)
                 {
                     Indent(beforeEndElement: false);
                 }
                 break;
             case Token.PI:
             case Token.Comment:
             case Token.CData:
             case Token.StartElement:
                 if (currentState == State.Attribute)
                 {
                     WriteEndAttributeQuote();
                     WriteEndStartTag(empty: false);
                 }
                 else if (currentState == State.Element)
                 {
                     WriteEndStartTag(empty: false);
                 }
                 if (token == Token.CData)
                 {
                     stack[top].mixed = true;
                 }
                 else if (indented && currentState != 0)
                 {
                     Indent(beforeEndElement: false);
                 }
                 break;
             case Token.EndElement:
             case Token.LongEndElement:
                 if (flush)
                 {
                     FlushEncoders();
                 }
                 if (currentState == State.Attribute)
                 {
                     WriteEndAttributeQuote();
                 }
                 if (currentState == State.Content)
                 {
                     token = Token.LongEndElement;
                 }
                 else
                 {
                     WriteEndStartTag(token == Token.EndElement);
                 }
                 if (stateTableDocument == stateTable && top == 1)
                 {
                     state = State.Epilog;
                 }
                 break;
             case Token.StartAttribute:
                 if (flush)
                 {
                     FlushEncoders();
                 }
                 if (currentState == State.Attribute)
                 {
                     WriteEndAttributeQuote();
                     textWriter.Write(' ');
                 }
                 else if (currentState == State.Element)
                 {
                     textWriter.Write(' ');
                 }
                 break;
             case Token.EndAttribute:
                 if (flush)
                 {
                     FlushEncoders();
                 }
                 WriteEndAttributeQuote();
                 break;
             case Token.Content:
             case Token.RawData:
             case Token.Whitespace:
                 if (flush)
                 {
                     FlushEncoders();
                 }
                 goto case Token.Base64;
             case Token.Base64:
                 if (currentState == State.Element && lastToken != Token.Content)
                 {
                     WriteEndStartTag(empty: false);
                 }
                 if (state == State.Content)
                 {
                     stack[top].mixed = true;
                 }
                 break;
             default:
                 throw new InvalidOperationException(Res.GetString("Xml_InvalidOperation"));
             }
             currentState = state;
             lastToken = token;
         }

         private void AutoCompleteAll()
         {
             if (flush)
             {
                 FlushEncoders();
             }
             while (top > 0)
             {
                 WriteEndElement();
             }
         }

         private void InternalWriteEndElement(bool longFormat)
         {
             try
             {
                 if (top <= 0)
                 {
                     throw new InvalidOperationException(Res.GetString("Xml_NoStartTag"));
                 }
                 AutoComplete(longFormat ? Token.LongEndElement : Token.EndElement);
                 if (lastToken == Token.LongEndElement)
                 {
                     if (indented)
                     {
                         Indent(beforeEndElement: true);
                     }
                     textWriter.Write('<');
                     textWriter.Write('/');
                     if (namespaces && stack[top].prefix != null)
                     {
                         textWriter.Write(stack[top].prefix);
                         textWriter.Write(':');
                     }
                     textWriter.Write(stack[top].name);
                     textWriter.Write('>');
                 }
                 int prevNsTop = stack[top].prevNsTop;
                 if (useNsHashtable && prevNsTop < nsTop)
                 {
                     PopNamespaces(prevNsTop + 1, nsTop);
                 }
                 nsTop = prevNsTop;
                 top--;
             }
             catch
             {
                 currentState = State.Error;
                 throw;
             }
         }

         private void WriteEndStartTag(bool empty)
         {
             xmlEncoder.StartAttribute(cacheAttrValue: false);
             for (int num = nsTop; num > stack[top].prevNsTop; num--)
             {
                 if (!nsStack[num].declared)
                 {
                     textWriter.Write(" xmlns");
                     textWriter.Write(':');
                     textWriter.Write(nsStack[num].prefix);
                     textWriter.Write('=');
                     textWriter.Write(quoteChar);
                     xmlEncoder.Write(nsStack[num].ns);
                     textWriter.Write(quoteChar);
                 }
             }
             if (stack[top].defaultNs != stack[top - 1].defaultNs && stack[top].defaultNsState == NamespaceState.DeclaredButNotWrittenOut)
             {
                 textWriter.Write(" xmlns");
                 textWriter.Write('=');
                 textWriter.Write(quoteChar);
                 xmlEncoder.Write(stack[top].defaultNs);
                 textWriter.Write(quoteChar);
                 stack[top].defaultNsState = NamespaceState.DeclaredAndWrittenOut;
             }
             xmlEncoder.EndAttribute();
             if (empty)
             {
                 textWriter.Write(" /");
             }
             textWriter.Write('>');
         }

         private void WriteEndAttributeQuote()
         {
             if (specialAttr != 0)
             {
                 HandleSpecialAttribute();
             }
             xmlEncoder.EndAttribute();
             textWriter.Write(curQuoteChar);
         }

         private void Indent(bool beforeEndElement)
         {
             if (top == 0)
             {
                 textWriter.WriteLine();
             }
             else if (!stack[top].mixed)
             {
                 textWriter.WriteLine();
                 int num = beforeEndElement ? (top - 1) : top;
                 for (num *= indentation; num > 0; num--)
                 {
                     textWriter.Write(indentChar);
                 }
             }
         }

         private void PushNamespace(string prefix, string ns, bool declared)
         {
             if ("http://www.w3.org/2000/xmlns/" == ns)
             {
                 throw new ArgumentException(Res.GetString("Xml_CanNotBindToReservedNamespace"));
             }
             if (prefix == null)
             {
                 switch (stack[top].defaultNsState)
                 {
                 default:
                     return;
                 case NamespaceState.Uninitialized:
                 case NamespaceState.NotDeclaredButInScope:
                     stack[top].defaultNs = ns;
                     break;
                 case NamespaceState.DeclaredButNotWrittenOut:
                     break;
                 }
                 stack[top].defaultNsState = (declared ? NamespaceState.DeclaredAndWrittenOut : NamespaceState.DeclaredButNotWrittenOut);
                 return;
             }
             if (prefix.Length != 0 && ns.Length == 0)
             {
                 throw new ArgumentException(Res.GetString("Xml_PrefixForEmptyNs"));
             }
             int num = LookupNamespace(prefix);
             if (num != -1 && nsStack[num].ns == ns)
             {
                 if (declared)
                 {
                     nsStack[num].declared = true;
                 }
                 return;
             }
             if (declared && num != -1 && num > stack[top].prevNsTop)
             {
                 nsStack[num].declared = true;
             }
             AddNamespace(prefix, ns, declared);
         }

         private void AddNamespace(string prefix, string ns, bool declared)
         {
             int num = ++nsTop;
             if (num == nsStack.Length)
             {
                 Namespace[] destinationArray = new Namespace[num * 2];
                 Array.Copy(nsStack, destinationArray, num);
                 nsStack = destinationArray;
             }
             nsStack[num].Set(prefix, ns, declared);
             if (useNsHashtable)
             {
                 AddToNamespaceHashtable(num);
             }
             else if (num == 16)
             {
                 nsHashtable = new Dictionary<string, int>(new SecureStringHasher());
                 for (int i = 0; i <= num; i++)
                 {
                     AddToNamespaceHashtable(i);
                 }
                 useNsHashtable = true;
             }
         }

         private void AddToNamespaceHashtable(int namespaceIndex)
         {
             string prefix = nsStack[namespaceIndex].prefix;
             if (nsHashtable.TryGetValue(prefix, out int value))
             {
                 nsStack[namespaceIndex].prevNsIndex = value;
             }
             nsHashtable[prefix] = namespaceIndex;
         }

         private void PopNamespaces(int indexFrom, int indexTo)
         {
             for (int num = indexTo; num >= indexFrom; num--)
             {
                 if (nsStack[num].prevNsIndex == -1)
                 {
                     nsHashtable.Remove(nsStack[num].prefix);
                 }
                 else
                 {
                     nsHashtable[nsStack[num].prefix] = nsStack[num].prevNsIndex;
                 }
             }
         }

         private string GeneratePrefix()
         {
             int num = stack[top].prefixCount++;
             return "d" + top.ToString("d", CultureInfo.InvariantCulture) + "p" + (num + 1).ToString("d", CultureInfo.InvariantCulture);
         }

         private void InternalWriteProcessingInstruction(string name, string text)
         {
             textWriter.Write("<?");
             ValidateName(name, isNCName: false);
             textWriter.Write(name);
             textWriter.Write(' ');
             if (text != null)
             {
                 xmlEncoder.WriteRawWithSurrogateChecking(text);
             }
             textWriter.Write("?>");
         }

         private int LookupNamespace(string prefix)
         {
             if (useNsHashtable)
             {
                 if (nsHashtable.TryGetValue(prefix, out int value))
                 {
                     return value;
                 }
             }
             else
             {
                 for (int num = nsTop; num >= 0; num--)
                 {
                     if (nsStack[num].prefix == prefix)
                     {
                         return num;
                     }
                 }
             }
             return -1;
         }

         private int LookupNamespaceInCurrentScope(string prefix)
         {
             if (useNsHashtable)
             {
                 if (nsHashtable.TryGetValue(prefix, out int value) && value > stack[top].prevNsTop)
                 {
                     return value;
                 }
             }
             else
             {
                 for (int num = nsTop; num > stack[top].prevNsTop; num--)
                 {
                     if (nsStack[num].prefix == prefix)
                     {
                         return num;
                     }
                 }
             }
             return -1;
         }

         private string FindPrefix(string ns)
         {
             for (int num = nsTop; num >= 0; num--)
             {
                 if (nsStack[num].ns == ns && LookupNamespace(nsStack[num].prefix) == num)
                 {
                     return nsStack[num].prefix;
                 }
             }
             return null;
         }

         private void InternalWriteName(string name, bool isNCName)
         {
             ValidateName(name, isNCName);
             textWriter.Write(name);
         }

         private void ValidateName(string name, bool isNCName)
         {
             if (name == null || name.Length == 0)
             {
                 throw new ArgumentException(Res.GetString("Xml_EmptyName"));
             }
             int length = name.Length;
             if (namespaces)
             {
                 int num = -1;
                 int num2 = ValidateNames.ParseNCName(name);
                 while (true)
                 {
                     if (num2 == length)
                     {
                         return;
                     }
                     if (name[num2] != ':' || isNCName || num != -1 || num2 <= 0 || num2 + 1 >= length)
                     {
                         break;
                     }
                     num = num2;
                     num2++;
                     num2 += ValidateNames.ParseNmtoken(name, num2);
                 }
             }
             else if (ValidateNames.IsNameNoNamespaces(name))
             {
                 return;
             }
             throw new ArgumentException(Res.GetString("Xml_InvalidNameChars", name));
         }

         private void HandleSpecialAttribute()
         {
             string attributeValue = xmlEncoder.AttributeValue;
             switch (specialAttr)
             {
             case SpecialAttr.XmlLang:
                 stack[top].xmlLang = attributeValue;
                 break;
             case SpecialAttr.XmlSpace:
                 attributeValue = XmlConvert.TrimString(attributeValue);
                 if (attributeValue == "default")
                 {
                     stack[top].xmlSpace = XmlSpace.Default;
                     break;
                 }
                 if (attributeValue == "preserve")
                 {
                     stack[top].xmlSpace = XmlSpace.Preserve;
                     break;
                 }
                 throw new ArgumentException(Res.GetString("Xml_InvalidXmlSpace", attributeValue));
             case SpecialAttr.XmlNs:
                 VerifyPrefixXml(prefixForXmlNs, attributeValue);
                 PushNamespace(prefixForXmlNs, attributeValue, declared: true);
                 break;
             }
         }

         private void VerifyPrefixXml(string prefix, string ns)
         {
             if (prefix != null && prefix.Length == 3 && (prefix[0] == 'x' || prefix[0] == 'X') && (prefix[1] == 'm' || prefix[1] == 'M') && (prefix[2] == 'l' || prefix[2] == 'L') && "http://www.w3.org/XML/1998/namespace" != ns)
             {
                 throw new ArgumentException(Res.GetString("Xml_InvalidPrefix"));
             }
         }

         private void PushStack()
         {
             if (top == stack.Length - 1)
             {
                 TagInfo[] destinationArray = new TagInfo[stack.Length + 10];
                 if (top > 0)
                 {
                     Array.Copy(stack, destinationArray, top + 1);
                 }
                 stack = destinationArray;
             }
             top++;
             stack[top].Init(nsTop);
         }

         private void FlushEncoders()
         {
             if (base64Encoder != null)
             {
                 base64Encoder.Flush();
             }
             flush = false;
         }
     }
 }
System.Text.Encoding
Represents a character encoding.To browse the .NET Framework source code for this type,...
Definition: Encoding.cs:15

System.Text
Definition: ASCIIEncoding.cs:4

System.Globalization.CultureInfo.InvariantCulture
static CultureInfo InvariantCulture
Gets the T:System.Globalization.CultureInfo object that is culture-independent (invariant).
Definition: CultureInfo.cs:263

System.Xml.XmlWriter.WriteBase64
abstract void WriteBase64(byte[] buffer, int index, int count)
When overridden in a derived class, encodes the specified binary bytes as Base64 and writes out the r...

System.Xml.WriteState.Prolog
Indicates that the prolog is being written.

System.Xml.XmlWriter.WriteChars
abstract void WriteChars(char[] buffer, int index, int count)
When overridden in a derived class, writes text one buffer at a time.

System.Xml.XmlTextWriter.Indentation
int Indentation
Gets or sets how many IndentChars to write for each level in the hierarchy when P:System....
Definition: XmlTextWriter.cs:456

System.Text.StringBuilder.ToString
unsafe override string ToString()
Converts the value of this instance to a T:System.String.
Definition: StringBuilder.cs:419

System.Xml.XmlWriter.WriteBinHex
virtual void WriteBinHex(byte[] buffer, int index, int count)
When overridden in a derived class, encodes the specified binary bytes as BinHex and writes out the r...
Definition: XmlWriter.cs:345

System.Collections.Generic
Definition: ArrayBuilder.cs:1

System.Xml.XmlWriter.Create
static XmlWriter Create(string outputFileName)
Creates a new T:System.Xml.XmlWriter instance using the specified filename.
Definition: XmlWriter.cs:854

System.Xml.XmlWriter.WriteStartDocument
abstract void WriteStartDocument()
When overridden in a derived class, writes the XML declaration with the version "1....

System.StringComparison
StringComparison
Specifies the culture, case, and sort rules to be used by certain overloads of the M:System....
Definition: StringComparison.cs:9

System.Diagnostics.EventLogPermissionAccess.Write
The T:System.Diagnostics.EventLog can write to existing logs, and create event sources and logs.

System.IO.FileMode
FileMode
Specifies how the operating system should open a file.
Definition: FileMode.cs:8

System.AppDomainManagerInitializationOptions.None
No initialization action.

System.ComponentModel.EditorBrowsableState
EditorBrowsableState
Specifies the browsable state of a property or method from within an editor.
Definition: EditorBrowsableState.cs:5

System.Attribute
Represents the base class for custom attributes.
Definition: Attribute.cs:15

System
Definition: __Canon.cs:3

System.Diagnostics.PerformanceCounterPermissionAccess.Read
The T:System.Diagnostics.PerformanceCounter can read categories.

System.Xml.XmlWriter.WriteEndAttribute
abstract void WriteEndAttribute()
When overridden in a derived class, closes the previous M:System.Xml.XmlWriter.WriteStartAttribute(Sy...

System.Xml.XmlWriter.WriteStartAttribute
void WriteStartAttribute(string localName, string ns)
Writes the start of an attribute with the specified local name and namespace URI.
Definition: XmlWriter.cs:199

System.Xml.XmlWriter.WriteWhitespace
abstract void WriteWhitespace(string ws)
When overridden in a derived class, writes out the given white space.

System.Xml.XmlWriter.WriteQualifiedName
virtual void WriteQualifiedName(string localName, string ns)
When overridden in a derived class, writes out the namespace-qualified name. This method looks up the...
Definition: XmlWriter.cs:405

System.ComponentModel.DesignerSerializationVisibility.Content
The code generator produces code for the contents of the object, rather than for the object itself.

System.Xml.XmlWriter.WriteString
abstract void WriteString(string text)
When overridden in a derived class, writes the given text content.

System.Xml.XmlWriter.XmlLang
virtual string XmlLang
When overridden in a derived class, gets the current xml:lang scope.
Definition: XmlWriter.cs:65

System.Xml.XmlWriter.WriteEndDocument
abstract void WriteEndDocument()
When overridden in a derived class, closes any open elements or attributes and puts the writer back i...

System.Xml.XmlWriter.LookupPrefix
abstract string LookupPrefix(string ns)
When overridden in a derived class, returns the closest prefix defined in the current namespace scope...

System.Xml.XmlWriter
Represents a writer that provides a fast, non-cached, forward-only way to generate streams or files t...
Definition: XmlWriter.cs:12

System.Xml.XmlWriter.WriteNmToken
virtual void WriteNmToken(string name)
When overridden in a derived class, writes out the specified name, ensuring it is a valid NmToken acc...
Definition: XmlWriter.cs:377

System.Xml.XmlWriter.Flush
abstract void Flush()
When overridden in a derived class, flushes whatever is in the buffer to the underlying streams and a...

System.IO.StreamWriter
Implements a T:System.IO.TextWriter for writing characters to a stream in a particular encoding....
Definition: StreamWriter.cs:15

System.IO.TextWriter.Encoding
abstract Encoding Encoding
When overridden in a derived class, returns the character encoding in which the output is written.
Definition: TextWriter.cs:449

System.Text.StringBuilder.Append
StringBuilder Append(char value, int repeatCount)
Appends a specified number of copies of the string representation of a Unicode character to this inst...
Definition: StringBuilder.cs:540

System.Text.Encoding.WebName
virtual string WebName
When overridden in a derived class, gets the name registered with the Internet Assigned Numbers Autho...
Definition: Encoding.cs:750

System.Xml.XmlWriter.WriteFullEndElement
abstract void WriteFullEndElement()
When overridden in a derived class, closes one element and pops the corresponding namespace scope.

System.Xml.XmlWriter.XmlSpace
virtual XmlSpace XmlSpace
When overridden in a derived class, gets an T:System.Xml.XmlSpace representing the current xml:space ...
Definition: XmlWriter.cs:52

System.IO.FileStream
Provides a T:System.IO.Stream for a file, supporting both synchronous and asynchronous read and write...
Definition: FileStream.cs:15

System.Xml.XmlTextWriter
Represents a writer that provides a fast, non-cached, forward-only way of generating streams or files...
Definition: XmlTextWriter.cs:11

System.IO
Definition: __ConsoleStream.cs:7

System.Xml.XmlWriter.WriteCharEntity
abstract void WriteCharEntity(char ch)
When overridden in a derived class, forces the generation of a character entity for the specified Uni...

System.IO.TextWriter
Represents a writer that can write a sequential series of characters. This class is abstract.
Definition: TextWriter.cs:15

System.Xml.XmlWriter.WriteCData
abstract void WriteCData(string text)
When overridden in a derived class, writes out a <![CDATA[...]]> block containing the specified text.

System.Xml.XmlNodeType.EndElement
An end element tag (for example, </item> ).

System.Xml.XmlWriter.WriteDocType
abstract void WriteDocType(string name, string pubid, string sysid, string subset)
When overridden in a derived class, writes the DOCTYPE declaration with the specified name and option...

System.Xml.XmlWriter.WriteEndElement
abstract void WriteEndElement()
When overridden in a derived class, closes one element and pops the corresponding namespace scope.

System.ComponentModel
Definition: AddingNewEventArgs.cs:3

System.IO.TextWriter.Flush
virtual void Flush()
Clears all buffers for the current writer and causes any buffered data to be written to the underlyin...
Definition: TextWriter.cs:515

System.Xml.XmlTextWriter.IndentChar
char IndentChar
Gets or sets which character to use for indenting when P:System.Xml.XmlTextWriter....
Definition: XmlTextWriter.cs:474

System.Text.StringBuilder
Represents a mutable string of characters. This class cannot be inherited.To browse the ....
Definition: StringBuilder.cs:14

System.Xml.XmlWriter.WriteSurrogateCharEntity
abstract void WriteSurrogateCharEntity(char lowChar, char highChar)
When overridden in a derived class, generates and writes the surrogate character entity for the surro...

System.Collections.Generic.Dictionary< string, int >

System.Xml.XmlTextWriter.Formatting
Formatting Formatting
Indicates how the output is formatted.
Definition: XmlTextWriter.cs:440

System.Xml.XmlWriter.WriteEntityRef
abstract void WriteEntityRef(string name)
When overridden in a derived class, writes out an entity reference as &name;.

System.Xml.XmlWriter.WriteRaw
abstract void WriteRaw(char[] buffer, int index, int count)
When overridden in a derived class, writes raw markup manually from a character buffer.

System.ArgumentException
The exception that is thrown when one of the arguments provided to a method is not valid.
Definition: ArgumentException.cs:11

System.Xml.XmlWriter.Close
virtual void Close()
When overridden in a derived class, closes this stream and the underlying stream.
Definition: XmlWriter.cs:353

System.Xml.Schema.XmlTypeCode.Namespace
This value supports the .NET Framework infrastructure and is not intended to be used directly from yo...

System.Collections
Definition: ArrayList.cs:7

System.IO.FileAccess
FileAccess
Defines constants for read, write, or read/write access to a file.
Definition: FileAccess.cs:9

System.Xml.XmlWriter.WriteComment
abstract void WriteComment(string text)
When overridden in a derived class, writes out a comment <!–...–> containing the specified text.

System.Xml.XmlTextWriter.Namespaces
bool Namespaces
Gets or sets a value indicating whether to do namespace support.
Definition: XmlTextWriter.cs:422

System.IO.TextWriter.WriteLine
virtual void WriteLine()
Writes a line terminator to the text string or stream.
Definition: TextWriter.cs:778

System.IO.TextWriter.Close
virtual void Close()
Closes the current writer and releases any system resources associated with the writer.
Definition: TextWriter.cs:491

System.Xml.Formatting
Formatting
Specifies formatting options for the T:System.Xml.XmlTextWriter.
Definition: Formatting.cs:4

System.InvalidOperationException
The exception that is thrown when a method call is invalid for the object's current state.
Definition: InvalidOperationException.cs:10

System.Xml.XmlWriter.WriteProcessingInstruction
abstract void WriteProcessingInstruction(string name, string text)
When overridden in a derived class, writes out a processing instruction with a space between the name...

System.Xml.XmlSpace
XmlSpace
Specifies the current xml:space scope.
Definition: XmlSpace.cs:5

System.Globalization.CultureInfo
Provides information about a specific culture (called a locale for unmanaged code development)....
Definition: CultureInfo.cs:16

System.Xml
Definition: AsyncHelper.cs:3

System.IO.TextWriter.Write
virtual void Write(char value)
Writes a character to the text string or stream.
Definition: TextWriter.cs:543

System.Xml.XmlTextWriter.BaseStream
Stream BaseStream
Gets the underlying stream object.
Definition: XmlTextWriter.cs:415

System.Collections.Generic.Dictionary.TryGetValue
bool TryGetValue(TKey key, out TValue value)
Gets the value associated with the specified key.
Definition: Dictionary.cs:1624

System.Xml.XmlWriter.WriteState
abstract WriteState WriteState
When overridden in a derived class, gets the state of the writer.
Definition: XmlWriter.cs:36

System.Globalization
Definition: AppDomainSortingSetupInfo.cs:1

System.Xml.XmlWriter.WriteName
virtual void WriteName(string name)
When overridden in a derived class, writes out the specified name, ensuring it is a valid name accord...
Definition: XmlWriter.cs:392

System.IO.FileShare
FileShare
Contains constants for controlling the kind of access other T:System.IO.FileStream objects can have t...
Definition: FileShare.cs:9

System.Xml.XmlWriter.WriteStartElement
void WriteStartElement(string localName, string ns)
When overridden in a derived class, writes the specified start tag and associates it with the given n...
Definition: XmlWriter.cs:110

System.IO.Stream
Provides a generic view of a sequence of bytes. This is an abstract class.To browse the ....
Definition: Stream.cs:16