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

 using System.Collections;
 using System.Globalization;
 using System.IO;
 using System.Security;
 using System.Security.Permissions;
 using System.Text;
 using System.Xml.Schema;
 using System.Xml.XPath;

 namespace System.Xml
 {
     public class XmlDocument : XmlNode
     {
         private XmlImplementation implementation;

         private DomNameTable domNameTable;

         private XmlLinkedNode lastChild;

         private XmlNamedNodeMap entities;

         private Hashtable htElementIdMap;

         private Hashtable htElementIDAttrDecl;

         private SchemaInfo schemaInfo;

         private XmlSchemaSet schemas;

         private bool reportValidity;

         private bool actualLoadingStatus;

         private XmlNodeChangedEventHandler onNodeInsertingDelegate;

         private XmlNodeChangedEventHandler onNodeInsertedDelegate;

         private XmlNodeChangedEventHandler onNodeRemovingDelegate;

         private XmlNodeChangedEventHandler onNodeRemovedDelegate;

         private XmlNodeChangedEventHandler onNodeChangingDelegate;

         private XmlNodeChangedEventHandler onNodeChangedDelegate;

         internal bool fEntRefNodesPresent;

         internal bool fCDataNodesPresent;

         private bool preserveWhitespace;

         private bool isLoading;

         internal string strDocumentName;

         internal string strDocumentFragmentName;

         internal string strCommentName;

         internal string strTextName;

         internal string strCDataSectionName;

         internal string strEntityName;

         internal string strID;

         internal string strXmlns;

         internal string strXml;

         internal string strSpace;

         internal string strLang;

         internal string strEmpty;

         internal string strNonSignificantWhitespaceName;

         internal string strSignificantWhitespaceName;

         internal string strReservedXmlns;

         internal string strReservedXml;

         internal string baseURI;

         private XmlResolver resolver;

         internal bool bSetResolver;

         internal object objLock;

         private XmlAttribute namespaceXml;

         internal static EmptyEnumerator EmptyEnumerator = new EmptyEnumerator();

         internal static IXmlSchemaInfo NotKnownSchemaInfo = new XmlSchemaInfo(XmlSchemaValidity.NotKnown);

         internal static IXmlSchemaInfo ValidSchemaInfo = new XmlSchemaInfo(XmlSchemaValidity.Valid);

         internal static IXmlSchemaInfo InvalidSchemaInfo = new XmlSchemaInfo(XmlSchemaValidity.Invalid);

         internal SchemaInfo DtdSchemaInfo
         {
             get
             {
                 return schemaInfo;
             }
             set
             {
                 schemaInfo = value;
             }
         }

         public override XmlNodeType NodeType => XmlNodeType.Document;

         public override XmlNode ParentNode => null;

         public virtual XmlDocumentType DocumentType => (XmlDocumentType)FindChild(XmlNodeType.DocumentType);

         internal virtual XmlDeclaration Declaration
         {
             get
             {
                 if (HasChildNodes)
                 {
                     return FirstChild as XmlDeclaration;
                 }
                 return null;
             }
         }

         public XmlImplementation Implementation => implementation;

         public override string Name => strDocumentName;

         public override string LocalName => strDocumentName;

         public XmlElement DocumentElement => (XmlElement)FindChild(XmlNodeType.Element);

         internal override bool IsContainer => true;

         internal override XmlLinkedNode LastNode
         {
             get
             {
                 return lastChild;
             }
             set
             {
                 lastChild = value;
             }
         }

         public override XmlDocument OwnerDocument => null;

         public XmlSchemaSet Schemas
         {
             get
             {
                 if (schemas == null)
                 {
                     schemas = new XmlSchemaSet(NameTable);
                 }
                 return schemas;
             }
             set
             {
                 schemas = value;
             }
         }

         internal bool CanReportValidity => reportValidity;

         internal bool HasSetResolver => bSetResolver;

         public virtual XmlResolver XmlResolver
         {
             set
             {
                 if (value != null)
                 {
                     try
                     {
                         new NamedPermissionSet("FullTrust").Demand();
                     }
                     catch (SecurityException inner)
                     {
                         throw new SecurityException(Res.GetString("Xml_UntrustedCodeSettingResolver"), inner);
                     }
                 }
                 resolver = value;
                 if (!bSetResolver)
                 {
                     bSetResolver = true;
                 }
                 XmlDocumentType documentType = DocumentType;
                 if (documentType != null)
                 {
                     documentType.DtdSchemaInfo = null;
                 }
             }
         }

         public XmlNameTable NameTable => implementation.NameTable;

         public bool PreserveWhitespace
         {
             get
             {
                 return preserveWhitespace;
             }
             set
             {
                 preserveWhitespace = value;
             }
         }

         public override bool IsReadOnly => false;

         internal XmlNamedNodeMap Entities
         {
             get
             {
                 if (entities == null)
                 {
                     entities = new XmlNamedNodeMap(this);
                 }
                 return entities;
             }
             set
             {
                 entities = value;
             }
         }

         internal bool IsLoading
         {
             get
             {
                 return isLoading;
             }
             set
             {
                 isLoading = value;
             }
         }

         internal bool ActualLoadingStatus
         {
             get
             {
                 return actualLoadingStatus;
             }
             set
             {
                 actualLoadingStatus = value;
             }
         }

         internal Encoding TextEncoding
         {
             get
             {
                 if (Declaration != null)
                 {
                     string encoding = Declaration.Encoding;
                     if (encoding.Length > 0)
                     {
                         return System.Text.Encoding.GetEncoding(encoding);
                     }
                 }
                 return null;
             }
         }

         public override string InnerText
         {
             set
             {
                 throw new InvalidOperationException(Res.GetString("Xdom_Document_Innertext"));
             }
         }

         public override string InnerXml
         {
             get
             {
                 return base.InnerXml;
             }
             set
             {
                 LoadXml(value);
             }
         }

         internal string Version => Declaration?.Version;

         internal string Encoding => Declaration?.Encoding;

         internal string Standalone => Declaration?.Standalone;

         public override IXmlSchemaInfo SchemaInfo
         {
             get
             {
                 if (reportValidity)
                 {
                     XmlElement documentElement = DocumentElement;
                     if (documentElement != null)
                     {
                         switch (documentElement.SchemaInfo.Validity)
                         {
                         case XmlSchemaValidity.Valid:
                             return ValidSchemaInfo;
                         case XmlSchemaValidity.Invalid:
                             return InvalidSchemaInfo;
                         }
                     }
                 }
                 return NotKnownSchemaInfo;
             }
         }

         public override string BaseURI => baseURI;

         internal override XPathNodeType XPNodeType => XPathNodeType.Root;

         internal bool HasEntityReferences => fEntRefNodesPresent;

         internal XmlAttribute NamespaceXml
         {
             get
             {
                 if (namespaceXml == null)
                 {
                     namespaceXml = new XmlAttribute(AddAttrXmlName(strXmlns, strXml, strReservedXmlns, null), this);
                     namespaceXml.Value = strReservedXml;
                 }
                 return namespaceXml;
             }
         }

         public event XmlNodeChangedEventHandler NodeInserting
         {
             add
             {
                 onNodeInsertingDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeInsertingDelegate, value);
             }
             remove
             {
                 onNodeInsertingDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeInsertingDelegate, value);
             }
         }

         public event XmlNodeChangedEventHandler NodeInserted
         {
             add
             {
                 onNodeInsertedDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeInsertedDelegate, value);
             }
             remove
             {
                 onNodeInsertedDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeInsertedDelegate, value);
             }
         }

         public event XmlNodeChangedEventHandler NodeRemoving
         {
             add
             {
                 onNodeRemovingDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeRemovingDelegate, value);
             }
             remove
             {
                 onNodeRemovingDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeRemovingDelegate, value);
             }
         }

         public event XmlNodeChangedEventHandler NodeRemoved
         {
             add
             {
                 onNodeRemovedDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeRemovedDelegate, value);
             }
             remove
             {
                 onNodeRemovedDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeRemovedDelegate, value);
             }
         }

         public event XmlNodeChangedEventHandler NodeChanging
         {
             add
             {
                 onNodeChangingDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeChangingDelegate, value);
             }
             remove
             {
                 onNodeChangingDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeChangingDelegate, value);
             }
         }

         public event XmlNodeChangedEventHandler NodeChanged
         {
             add
             {
                 onNodeChangedDelegate = (XmlNodeChangedEventHandler)Delegate.Combine(onNodeChangedDelegate, value);
             }
             remove
             {
                 onNodeChangedDelegate = (XmlNodeChangedEventHandler)Delegate.Remove(onNodeChangedDelegate, value);
             }
         }

         public XmlDocument()
             : this(new XmlImplementation())
         {
         }

         public XmlDocument(XmlNameTable nt)
             : this(new XmlImplementation(nt))
         {
         }

         protected internal XmlDocument(XmlImplementation imp)
         {
             implementation = imp;
             domNameTable = new DomNameTable(this);
             XmlNameTable nameTable = NameTable;
             nameTable.Add(string.Empty);
             strDocumentName = nameTable.Add("#document");
             strDocumentFragmentName = nameTable.Add("#document-fragment");
             strCommentName = nameTable.Add("#comment");
             strTextName = nameTable.Add("#text");
             strCDataSectionName = nameTable.Add("#cdata-section");
             strEntityName = nameTable.Add("#entity");
             strID = nameTable.Add("id");
             strNonSignificantWhitespaceName = nameTable.Add("#whitespace");
             strSignificantWhitespaceName = nameTable.Add("#significant-whitespace");
             strXmlns = nameTable.Add("xmlns");
             strXml = nameTable.Add("xml");
             strSpace = nameTable.Add("space");
             strLang = nameTable.Add("lang");
             strReservedXmlns = nameTable.Add("http://www.w3.org/2000/xmlns/");
             strReservedXml = nameTable.Add("http://www.w3.org/XML/1998/namespace");
             strEmpty = nameTable.Add(string.Empty);
             baseURI = string.Empty;
             objLock = new object();
         }

         internal static void CheckName(string name)
         {
             int num = ValidateNames.ParseNmtoken(name, 0);
             if (num < name.Length)
             {
                 throw new XmlException("Xml_BadNameChar", XmlException.BuildCharExceptionArgs(name, num));
             }
         }

         internal XmlName AddXmlName(string prefix, string localName, string namespaceURI, IXmlSchemaInfo schemaInfo)
         {
             return domNameTable.AddName(prefix, localName, namespaceURI, schemaInfo);
         }

         internal XmlName GetXmlName(string prefix, string localName, string namespaceURI, IXmlSchemaInfo schemaInfo)
         {
             return domNameTable.GetName(prefix, localName, namespaceURI, schemaInfo);
         }

         internal XmlName AddAttrXmlName(string prefix, string localName, string namespaceURI, IXmlSchemaInfo schemaInfo)
         {
             XmlName xmlName = AddXmlName(prefix, localName, namespaceURI, schemaInfo);
             if (!IsLoading)
             {
                 object prefix2 = xmlName.Prefix;
                 object namespaceURI2 = xmlName.NamespaceURI;
                 object localName2 = xmlName.LocalName;
                 if ((prefix2 == strXmlns || (prefix2 == strEmpty && localName2 == strXmlns)) ^ (namespaceURI2 == strReservedXmlns))
                 {
                     throw new ArgumentException(Res.GetString("Xdom_Attr_Reserved_XmlNS", namespaceURI));
                 }
             }
             return xmlName;
         }

         internal bool AddIdInfo(XmlName eleName, XmlName attrName)
         {
             if (htElementIDAttrDecl == null || htElementIDAttrDecl[eleName] == null)
             {
                 if (htElementIDAttrDecl == null)
                 {
                     htElementIDAttrDecl = new Hashtable();
                 }
                 htElementIDAttrDecl.Add(eleName, attrName);
                 return true;
             }
             return false;
         }

         private XmlName GetIDInfoByElement_(XmlName eleName)
         {
             XmlName xmlName = GetXmlName(eleName.Prefix, eleName.LocalName, string.Empty, null);
             if (xmlName != null)
             {
                 return (XmlName)htElementIDAttrDecl[xmlName];
             }
             return null;
         }

         internal XmlName GetIDInfoByElement(XmlName eleName)
         {
             if (htElementIDAttrDecl == null)
             {
                 return null;
             }
             return GetIDInfoByElement_(eleName);
         }

         private WeakReference GetElement(ArrayList elementList, XmlElement elem)
         {
             ArrayList arrayList = new ArrayList();
             foreach (WeakReference element in elementList)
             {
                 if (!element.IsAlive)
                 {
                     arrayList.Add(element);
                 }
                 else if ((XmlElement)element.Target == elem)
                 {
                     return element;
                 }
             }
             foreach (WeakReference item in arrayList)
             {
                 elementList.Remove(item);
             }
             return null;
         }

         internal void AddElementWithId(string id, XmlElement elem)
         {
             if (htElementIdMap == null || !htElementIdMap.Contains(id))
             {
                 if (htElementIdMap == null)
                 {
                     htElementIdMap = new Hashtable();
                 }
                 ArrayList arrayList = new ArrayList();
                 arrayList.Add(new WeakReference(elem));
                 htElementIdMap.Add(id, arrayList);
             }
             else
             {
                 ArrayList arrayList2 = (ArrayList)htElementIdMap[id];
                 if (GetElement(arrayList2, elem) == null)
                 {
                     arrayList2.Add(new WeakReference(elem));
                 }
             }
         }

         internal void RemoveElementWithId(string id, XmlElement elem)
         {
             if (htElementIdMap == null || !htElementIdMap.Contains(id))
             {
                 return;
             }
             ArrayList arrayList = (ArrayList)htElementIdMap[id];
             WeakReference element = GetElement(arrayList, elem);
             if (element != null)
             {
                 arrayList.Remove(element);
                 if (arrayList.Count == 0)
                 {
                     htElementIdMap.Remove(id);
                 }
             }
         }

         public override XmlNode CloneNode(bool deep)
         {
             XmlDocument xmlDocument = Implementation.CreateDocument();
             xmlDocument.SetBaseURI(baseURI);
             if (deep)
             {
                 xmlDocument.ImportChildren(this, xmlDocument, deep);
             }
             return xmlDocument;
         }

         internal XmlResolver GetResolver()
         {
             return resolver;
         }

         internal override bool IsValidChildType(XmlNodeType type)
         {
             switch (type)
             {
             case XmlNodeType.ProcessingInstruction:
             case XmlNodeType.Comment:
             case XmlNodeType.Whitespace:
             case XmlNodeType.SignificantWhitespace:
                 return true;
             case XmlNodeType.DocumentType:
                 if (DocumentType != null)
                 {
                     throw new InvalidOperationException(Res.GetString("Xdom_DualDocumentTypeNode"));
                 }
                 return true;
             case XmlNodeType.Element:
                 if (DocumentElement != null)
                 {
                     throw new InvalidOperationException(Res.GetString("Xdom_DualDocumentElementNode"));
                 }
                 return true;
             case XmlNodeType.XmlDeclaration:
                 if (Declaration != null)
                 {
                     throw new InvalidOperationException(Res.GetString("Xdom_DualDeclarationNode"));
                 }
                 return true;
             default:
                 return false;
             }
         }

         private bool HasNodeTypeInPrevSiblings(XmlNodeType nt, XmlNode refNode)
         {
             if (refNode == null)
             {
                 return false;
             }
             XmlNode xmlNode = null;
             if (refNode.ParentNode != null)
             {
                 xmlNode = refNode.ParentNode.FirstChild;
             }
             while (xmlNode != null)
             {
                 if (xmlNode.NodeType == nt)
                 {
                     return true;
                 }
                 if (xmlNode == refNode)
                 {
                     break;
                 }
                 xmlNode = xmlNode.NextSibling;
             }
             return false;
         }

         private bool HasNodeTypeInNextSiblings(XmlNodeType nt, XmlNode refNode)
         {
             for (XmlNode xmlNode = refNode; xmlNode != null; xmlNode = xmlNode.NextSibling)
             {
                 if (xmlNode.NodeType == nt)
                 {
                     return true;
                 }
             }
             return false;
         }

         internal override bool CanInsertBefore(XmlNode newChild, XmlNode refChild)
         {
             if (refChild == null)
             {
                 refChild = FirstChild;
             }
             if (refChild == null)
             {
                 return true;
             }
             switch (newChild.NodeType)
             {
             case XmlNodeType.XmlDeclaration:
                 return refChild == FirstChild;
             case XmlNodeType.ProcessingInstruction:
             case XmlNodeType.Comment:
                 return refChild.NodeType != XmlNodeType.XmlDeclaration;
             case XmlNodeType.DocumentType:
                 if (refChild.NodeType != XmlNodeType.XmlDeclaration)
                 {
                     return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild.PreviousSibling);
                 }
                 break;
             case XmlNodeType.Element:
                 if (refChild.NodeType != XmlNodeType.XmlDeclaration)
                 {
                     return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild);
                 }
                 break;
             }
             return false;
         }

         internal override bool CanInsertAfter(XmlNode newChild, XmlNode refChild)
         {
             if (refChild == null)
             {
                 refChild = LastChild;
             }
             if (refChild == null)
             {
                 return true;
             }
             switch (newChild.NodeType)
             {
             case XmlNodeType.ProcessingInstruction:
             case XmlNodeType.Comment:
             case XmlNodeType.Whitespace:
             case XmlNodeType.SignificantWhitespace:
                 return true;
             case XmlNodeType.DocumentType:
                 return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild);
             case XmlNodeType.Element:
                 return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild.NextSibling);
             default:
                 return false;
             }
         }

         public XmlAttribute CreateAttribute(string name)
         {
             string prefix = string.Empty;
             string localName = string.Empty;
             string namespaceURI = string.Empty;
             XmlNode.SplitName(name, out prefix, out localName);
             SetDefaultNamespace(prefix, localName, ref namespaceURI);
             return CreateAttribute(prefix, localName, namespaceURI);
         }

         internal void SetDefaultNamespace(string prefix, string localName, ref string namespaceURI)
         {
             if (prefix == strXmlns || (prefix.Length == 0 && localName == strXmlns))
             {
                 namespaceURI = strReservedXmlns;
             }
             else if (prefix == strXml)
             {
                 namespaceURI = strReservedXml;
             }
         }

         public virtual XmlCDataSection CreateCDataSection(string data)
         {
             fCDataNodesPresent = true;
             return new XmlCDataSection(data, this);
         }

         public virtual XmlComment CreateComment(string data)
         {
             return new XmlComment(data, this);
         }

         [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
         public virtual XmlDocumentType CreateDocumentType(string name, string publicId, string systemId, string internalSubset)
         {
             return new XmlDocumentType(name, publicId, systemId, internalSubset, this);
         }

         public virtual XmlDocumentFragment CreateDocumentFragment()
         {
             return new XmlDocumentFragment(this);
         }

         public XmlElement CreateElement(string name)
         {
             string prefix = string.Empty;
             string localName = string.Empty;
             XmlNode.SplitName(name, out prefix, out localName);
             return CreateElement(prefix, localName, string.Empty);
         }

         internal void AddDefaultAttributes(XmlElement elem)
         {
             SchemaInfo dtdSchemaInfo = DtdSchemaInfo;
             SchemaElementDecl schemaElementDecl = GetSchemaElementDecl(elem);
             if (schemaElementDecl == null || schemaElementDecl.AttDefs == null)
             {
                 return;
             }
             IDictionaryEnumerator dictionaryEnumerator = schemaElementDecl.AttDefs.GetEnumerator();
             while (dictionaryEnumerator.MoveNext())
             {
                 SchemaAttDef schemaAttDef = (SchemaAttDef)dictionaryEnumerator.Value;
                 if (schemaAttDef.Presence == SchemaDeclBase.Use.Default || schemaAttDef.Presence == SchemaDeclBase.Use.Fixed)
                 {
                     string empty = string.Empty;
                     string name = schemaAttDef.Name.Name;
                     string attrNamespaceURI = string.Empty;
                     if (dtdSchemaInfo.SchemaType == SchemaType.DTD)
                     {
                         empty = schemaAttDef.Name.Namespace;
                     }
                     else
                     {
                         empty = schemaAttDef.Prefix;
                         attrNamespaceURI = schemaAttDef.Name.Namespace;
                     }
                     XmlAttribute attributeNode = PrepareDefaultAttribute(schemaAttDef, empty, name, attrNamespaceURI);
                     elem.SetAttributeNode(attributeNode);
                 }
             }
         }

         private SchemaElementDecl GetSchemaElementDecl(XmlElement elem)
         {
             SchemaInfo dtdSchemaInfo = DtdSchemaInfo;
             if (dtdSchemaInfo != null)
             {
                 XmlQualifiedName key = new XmlQualifiedName(elem.LocalName, (dtdSchemaInfo.SchemaType == SchemaType.DTD) ? elem.Prefix : elem.NamespaceURI);
                 if (dtdSchemaInfo.ElementDecls.TryGetValue(key, out SchemaElementDecl value))
                 {
                     return value;
                 }
             }
             return null;
         }

         private XmlAttribute PrepareDefaultAttribute(SchemaAttDef attdef, string attrPrefix, string attrLocalname, string attrNamespaceURI)
         {
             SetDefaultNamespace(attrPrefix, attrLocalname, ref attrNamespaceURI);
             XmlAttribute xmlAttribute = CreateDefaultAttribute(attrPrefix, attrLocalname, attrNamespaceURI);
             xmlAttribute.InnerXml = attdef.DefaultValueRaw;
             (xmlAttribute as XmlUnspecifiedAttribute)?.SetSpecified(f: false);
             return xmlAttribute;
         }

         public virtual XmlEntityReference CreateEntityReference(string name)
         {
             return new XmlEntityReference(name, this);
         }

         public virtual XmlProcessingInstruction CreateProcessingInstruction(string target, string data)
         {
             return new XmlProcessingInstruction(target, data, this);
         }

         public virtual XmlDeclaration CreateXmlDeclaration(string version, string encoding, string standalone)
         {
             return new XmlDeclaration(version, encoding, standalone, this);
         }

         public virtual XmlText CreateTextNode(string text)
         {
             return new XmlText(text, this);
         }

         public virtual XmlSignificantWhitespace CreateSignificantWhitespace(string text)
         {
             return new XmlSignificantWhitespace(text, this);
         }

         public override XPathNavigator CreateNavigator()
         {
             return CreateNavigator(this);
         }

         protected internal virtual XPathNavigator CreateNavigator(XmlNode node)
         {
             switch (node.NodeType)
             {
             case XmlNodeType.EntityReference:
             case XmlNodeType.Entity:
             case XmlNodeType.DocumentType:
             case XmlNodeType.Notation:
             case XmlNodeType.XmlDeclaration:
                 return null;
             case XmlNodeType.Text:
             case XmlNodeType.CDATA:
             case XmlNodeType.SignificantWhitespace:
             {
                 XmlNode parentNode = node.ParentNode;
                 if (parentNode != null)
                 {
                     do
                     {
                         switch (parentNode.NodeType)
                         {
                         case XmlNodeType.Attribute:
                             return null;
                         case XmlNodeType.EntityReference:
                             goto IL_006a;
                         }
                         break;
                         IL_006a:
                         parentNode = parentNode.ParentNode;
                     }
                     while (parentNode != null);
                 }
                 node = NormalizeText(node);
                 break;
             }
             case XmlNodeType.Whitespace:
             {
                 XmlNode parentNode = node.ParentNode;
                 if (parentNode != null)
                 {
                     do
                     {
                         switch (parentNode.NodeType)
                         {
                         case XmlNodeType.Attribute:
                         case XmlNodeType.Document:
                             return null;
                         case XmlNodeType.EntityReference:
                             goto IL_009f;
                         }
                         break;
                         IL_009f:
                         parentNode = parentNode.ParentNode;
                     }
                     while (parentNode != null);
                 }
                 node = NormalizeText(node);
                 break;
             }
             }
             return new DocumentXPathNavigator(this, node);
         }

         internal static bool IsTextNode(XmlNodeType nt)
         {
             switch (nt)
             {
             case XmlNodeType.Text:
             case XmlNodeType.CDATA:
             case XmlNodeType.Whitespace:
             case XmlNodeType.SignificantWhitespace:
                 return true;
             default:
                 return false;
             }
         }

         private XmlNode NormalizeText(XmlNode n)
         {
             XmlNode xmlNode = null;
             while (IsTextNode(n.NodeType))
             {
                 xmlNode = n;
                 n = n.PreviousSibling;
                 if (n == null)
                 {
                     XmlNode xmlNode2 = xmlNode;
                     while (xmlNode2.ParentNode != null && xmlNode2.ParentNode.NodeType == XmlNodeType.EntityReference)
                     {
                         if (xmlNode2.ParentNode.PreviousSibling != null)
                         {
                             n = xmlNode2.ParentNode.PreviousSibling;
                             break;
                         }
                         xmlNode2 = xmlNode2.ParentNode;
                         if (xmlNode2 == null)
                         {
                             break;
                         }
                     }
                 }
                 if (n == null)
                 {
                     break;
                 }
                 while (n.NodeType == XmlNodeType.EntityReference)
                 {
                     n = n.LastChild;
                 }
             }
             return xmlNode;
         }

         public virtual XmlWhitespace CreateWhitespace(string text)
         {
             return new XmlWhitespace(text, this);
         }

         public virtual XmlNodeList GetElementsByTagName(string name)
         {
             return new XmlElementList(this, name);
         }

         public XmlAttribute CreateAttribute(string qualifiedName, string namespaceURI)
         {
             string prefix = string.Empty;
             string localName = string.Empty;
             XmlNode.SplitName(qualifiedName, out prefix, out localName);
             return CreateAttribute(prefix, localName, namespaceURI);
         }

         public XmlElement CreateElement(string qualifiedName, string namespaceURI)
         {
             string prefix = string.Empty;
             string localName = string.Empty;
             XmlNode.SplitName(qualifiedName, out prefix, out localName);
             return CreateElement(prefix, localName, namespaceURI);
         }

         public virtual XmlNodeList GetElementsByTagName(string localName, string namespaceURI)
         {
             return new XmlElementList(this, localName, namespaceURI);
         }

         public virtual XmlElement GetElementById(string elementId)
         {
             if (htElementIdMap != null)
             {
                 ArrayList arrayList = (ArrayList)htElementIdMap[elementId];
                 if (arrayList != null)
                 {
                     foreach (WeakReference item in arrayList)
                     {
                         XmlElement xmlElement = (XmlElement)item.Target;
                         if (xmlElement != null && xmlElement.IsConnected())
                         {
                             return xmlElement;
                         }
                     }
                 }
             }
             return null;
         }

         public virtual XmlNode ImportNode(XmlNode node, bool deep)
         {
             return ImportNodeInternal(node, deep);
         }

         private XmlNode ImportNodeInternal(XmlNode node, bool deep)
         {
             XmlNode xmlNode = null;
             if (node == null)
             {
                 throw new InvalidOperationException(Res.GetString("Xdom_Import_NullNode"));
             }
             switch (node.NodeType)
             {
             case XmlNodeType.Element:
                 xmlNode = CreateElement(node.Prefix, node.LocalName, node.NamespaceURI);
                 ImportAttributes(node, xmlNode);
                 if (deep)
                 {
                     ImportChildren(node, xmlNode, deep);
                 }
                 break;
             case XmlNodeType.Attribute:
                 xmlNode = CreateAttribute(node.Prefix, node.LocalName, node.NamespaceURI);
                 ImportChildren(node, xmlNode, deep: true);
                 break;
             case XmlNodeType.Text:
                 xmlNode = CreateTextNode(node.Value);
                 break;
             case XmlNodeType.Comment:
                 xmlNode = CreateComment(node.Value);
                 break;
             case XmlNodeType.ProcessingInstruction:
                 xmlNode = CreateProcessingInstruction(node.Name, node.Value);
                 break;
             case XmlNodeType.XmlDeclaration:
             {
                 XmlDeclaration xmlDeclaration = (XmlDeclaration)node;
                 xmlNode = CreateXmlDeclaration(xmlDeclaration.Version, xmlDeclaration.Encoding, xmlDeclaration.Standalone);
                 break;
             }
             case XmlNodeType.CDATA:
                 xmlNode = CreateCDataSection(node.Value);
                 break;
             case XmlNodeType.DocumentType:
             {
                 XmlDocumentType xmlDocumentType = (XmlDocumentType)node;
                 xmlNode = CreateDocumentType(xmlDocumentType.Name, xmlDocumentType.PublicId, xmlDocumentType.SystemId, xmlDocumentType.InternalSubset);
                 break;
             }
             case XmlNodeType.DocumentFragment:
                 xmlNode = CreateDocumentFragment();
                 if (deep)
                 {
                     ImportChildren(node, xmlNode, deep);
                 }
                 break;
             case XmlNodeType.EntityReference:
                 xmlNode = CreateEntityReference(node.Name);
                 break;
             case XmlNodeType.Whitespace:
                 xmlNode = CreateWhitespace(node.Value);
                 break;
             case XmlNodeType.SignificantWhitespace:
                 xmlNode = CreateSignificantWhitespace(node.Value);
                 break;
             default:
                 throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Res.GetString("Xdom_Import"), new object[1]
                 {
                     node.NodeType.ToString()
                 }));
             }
             return xmlNode;
         }

         private void ImportAttributes(XmlNode fromElem, XmlNode toElem)
         {
             int count = fromElem.Attributes.Count;
             for (int i = 0; i < count; i++)
             {
                 if (fromElem.Attributes[i].Specified)
                 {
                     toElem.Attributes.SetNamedItem(ImportNodeInternal(fromElem.Attributes[i], deep: true));
                 }
             }
         }

         private void ImportChildren(XmlNode fromNode, XmlNode toNode, bool deep)
         {
             for (XmlNode xmlNode = fromNode.FirstChild; xmlNode != null; xmlNode = xmlNode.NextSibling)
             {
                 toNode.AppendChild(ImportNodeInternal(xmlNode, deep));
             }
         }

         public virtual XmlAttribute CreateAttribute(string prefix, string localName, string namespaceURI)
         {
             return new XmlAttribute(AddAttrXmlName(prefix, localName, namespaceURI, null), this);
         }

         protected internal virtual XmlAttribute CreateDefaultAttribute(string prefix, string localName, string namespaceURI)
         {
             return new XmlUnspecifiedAttribute(prefix, localName, namespaceURI, this);
         }

         public virtual XmlElement CreateElement(string prefix, string localName, string namespaceURI)
         {
             XmlElement xmlElement = new XmlElement(AddXmlName(prefix, localName, namespaceURI, null), empty: true, this);
             if (!IsLoading)
             {
                 AddDefaultAttributes(xmlElement);
             }
             return xmlElement;
         }

         public virtual XmlNode CreateNode(XmlNodeType type, string prefix, string name, string namespaceURI)
         {
             switch (type)
             {
             case XmlNodeType.Element:
                 if (prefix != null)
                 {
                     return CreateElement(prefix, name, namespaceURI);
                 }
                 return CreateElement(name, namespaceURI);
             case XmlNodeType.Attribute:
                 if (prefix != null)
                 {
                     return CreateAttribute(prefix, name, namespaceURI);
                 }
                 return CreateAttribute(name, namespaceURI);
             case XmlNodeType.Text:
                 return CreateTextNode(string.Empty);
             case XmlNodeType.CDATA:
                 return CreateCDataSection(string.Empty);
             case XmlNodeType.EntityReference:
                 return CreateEntityReference(name);
             case XmlNodeType.ProcessingInstruction:
                 return CreateProcessingInstruction(name, string.Empty);
             case XmlNodeType.XmlDeclaration:
                 return CreateXmlDeclaration("1.0", null, null);
             case XmlNodeType.Comment:
                 return CreateComment(string.Empty);
             case XmlNodeType.DocumentFragment:
                 return CreateDocumentFragment();
             case XmlNodeType.DocumentType:
                 return CreateDocumentType(name, string.Empty, string.Empty, string.Empty);
             case XmlNodeType.Document:
                 return new XmlDocument();
             case XmlNodeType.SignificantWhitespace:
                 return CreateSignificantWhitespace(string.Empty);
             case XmlNodeType.Whitespace:
                 return CreateWhitespace(string.Empty);
             default:
                 throw new ArgumentException(Res.GetString("Arg_CannotCreateNode", type));
             }
         }

         public virtual XmlNode CreateNode(string nodeTypeString, string name, string namespaceURI)
         {
             return CreateNode(ConvertToNodeType(nodeTypeString), name, namespaceURI);
         }

         public virtual XmlNode CreateNode(XmlNodeType type, string name, string namespaceURI)
         {
             return CreateNode(type, null, name, namespaceURI);
         }

         [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
         public virtual XmlNode ReadNode(XmlReader reader)
         {
             XmlNode xmlNode = null;
             try
             {
                 IsLoading = true;
                 XmlLoader xmlLoader = new XmlLoader();
                 return xmlLoader.ReadCurrentNode(this, reader);
             }
             finally
             {
                 IsLoading = false;
             }
         }

         internal XmlNodeType ConvertToNodeType(string nodeTypeString)
         {
             if (nodeTypeString == "element")
             {
                 return XmlNodeType.Element;
             }
             if (nodeTypeString == "attribute")
             {
                 return XmlNodeType.Attribute;
             }
             if (nodeTypeString == "text")
             {
                 return XmlNodeType.Text;
             }
             if (nodeTypeString == "cdatasection")
             {
                 return XmlNodeType.CDATA;
             }
             if (nodeTypeString == "entityreference")
             {
                 return XmlNodeType.EntityReference;
             }
             if (nodeTypeString == "entity")
             {
                 return XmlNodeType.Entity;
             }
             if (nodeTypeString == "processinginstruction")
             {
                 return XmlNodeType.ProcessingInstruction;
             }
             if (nodeTypeString == "comment")
             {
                 return XmlNodeType.Comment;
             }
             if (nodeTypeString == "document")
             {
                 return XmlNodeType.Document;
             }
             if (nodeTypeString == "documenttype")
             {
                 return XmlNodeType.DocumentType;
             }
             if (nodeTypeString == "documentfragment")
             {
                 return XmlNodeType.DocumentFragment;
             }
             if (nodeTypeString == "notation")
             {
                 return XmlNodeType.Notation;
             }
             if (nodeTypeString == "significantwhitespace")
             {
                 return XmlNodeType.SignificantWhitespace;
             }
             if (nodeTypeString == "whitespace")
             {
                 return XmlNodeType.Whitespace;
             }
             throw new ArgumentException(Res.GetString("Xdom_Invalid_NT_String", nodeTypeString));
         }

         private XmlTextReader SetupReader(XmlTextReader tr)
         {
             tr.XmlValidatingReaderCompatibilityMode = true;
             tr.EntityHandling = EntityHandling.ExpandCharEntities;
             if (HasSetResolver)
             {
                 tr.XmlResolver = GetResolver();
             }
             return tr;
         }

         public virtual void Load(string filename)
         {
             XmlTextReader xmlTextReader = SetupReader(new XmlTextReader(filename, NameTable));
             try
             {
                 Load(xmlTextReader);
             }
             finally
             {
                 xmlTextReader.Close();
             }
         }

         public virtual void Load(Stream inStream)
         {
             XmlTextReader xmlTextReader = SetupReader(new XmlTextReader(inStream, NameTable));
             try
             {
                 Load(xmlTextReader);
             }
             finally
             {
                 xmlTextReader.Impl.Close(closeInput: false);
             }
         }

         public virtual void Load(TextReader txtReader)
         {
             XmlTextReader xmlTextReader = SetupReader(new XmlTextReader(txtReader, NameTable));
             try
             {
                 Load(xmlTextReader);
             }
             finally
             {
                 xmlTextReader.Impl.Close(closeInput: false);
             }
         }

         public virtual void Load(XmlReader reader)
         {
             try
             {
                 IsLoading = true;
                 actualLoadingStatus = true;
                 RemoveAll();
                 fEntRefNodesPresent = false;
                 fCDataNodesPresent = false;
                 reportValidity = true;
                 XmlLoader xmlLoader = new XmlLoader();
                 xmlLoader.Load(this, reader, preserveWhitespace);
             }
             finally
             {
                 IsLoading = false;
                 actualLoadingStatus = false;
                 reportValidity = true;
             }
         }

         public virtual void LoadXml(string xml)
         {
             XmlTextReader xmlTextReader = SetupReader(new XmlTextReader(new StringReader(xml), NameTable));
             try
             {
                 Load(xmlTextReader);
             }
             finally
             {
                 xmlTextReader.Close();
             }
         }

         public virtual void Save(string filename)
         {
             if (DocumentElement == null)
             {
                 throw new XmlException("Xml_InvalidXmlDocument", Res.GetString("Xdom_NoRootEle"));
             }
             XmlDOMTextWriter xmlDOMTextWriter = new XmlDOMTextWriter(filename, TextEncoding);
             try
             {
                 if (!preserveWhitespace)
                 {
                     xmlDOMTextWriter.Formatting = Formatting.Indented;
                 }
                 WriteTo(xmlDOMTextWriter);
                 xmlDOMTextWriter.Flush();
             }
             finally
             {
                 xmlDOMTextWriter.Close();
             }
         }

         public virtual void Save(Stream outStream)
         {
             XmlDOMTextWriter xmlDOMTextWriter = new XmlDOMTextWriter(outStream, TextEncoding);
             if (!preserveWhitespace)
             {
                 xmlDOMTextWriter.Formatting = Formatting.Indented;
             }
             WriteTo(xmlDOMTextWriter);
             xmlDOMTextWriter.Flush();
         }

         public virtual void Save(TextWriter writer)
         {
             XmlDOMTextWriter xmlDOMTextWriter = new XmlDOMTextWriter(writer);
             if (!preserveWhitespace)
             {
                 xmlDOMTextWriter.Formatting = Formatting.Indented;
             }
             Save(xmlDOMTextWriter);
         }

         public virtual void Save(XmlWriter w)
         {
             XmlNode xmlNode = FirstChild;
             if (xmlNode == null)
             {
                 return;
             }
             if (w.WriteState == WriteState.Start)
             {
                 if (xmlNode is XmlDeclaration)
                 {
                     if (Standalone.Length == 0)
                     {
                         w.WriteStartDocument();
                     }
                     else if (Standalone == "yes")
                     {
                         w.WriteStartDocument(standalone: true);
                     }
                     else if (Standalone == "no")
                     {
                         w.WriteStartDocument(standalone: false);
                     }
                     xmlNode = xmlNode.NextSibling;
                 }
                 else
                 {
                     w.WriteStartDocument();
                 }
             }
             while (xmlNode != null)
             {
                 xmlNode.WriteTo(w);
                 xmlNode = xmlNode.NextSibling;
             }
             w.Flush();
         }

         public override void WriteTo(XmlWriter w)
         {
             WriteContentTo(w);
         }

         public override void WriteContentTo(XmlWriter xw)
         {
             IEnumerator enumerator = GetEnumerator();
             try
             {
                 while (enumerator.MoveNext())
                 {
                     XmlNode xmlNode = (XmlNode)enumerator.Current;
                     xmlNode.WriteTo(xw);
                 }
             }
             finally
             {
                 IDisposable disposable = enumerator as IDisposable;
                 if (disposable != null)
                 {
                     disposable.Dispose();
                 }
             }
         }

         public void Validate(ValidationEventHandler validationEventHandler)
         {
             Validate(validationEventHandler, this);
         }

         public void Validate(ValidationEventHandler validationEventHandler, XmlNode nodeToValidate)
         {
             if (schemas == null || schemas.Count == 0)
             {
                 throw new InvalidOperationException(Res.GetString("XmlDocument_NoSchemaInfo"));
             }
             XmlDocument document = nodeToValidate.Document;
             if (document != this)
             {
                 throw new ArgumentException(Res.GetString("XmlDocument_NodeNotFromDocument", "nodeToValidate"));
             }
             if (nodeToValidate == this)
             {
                 reportValidity = false;
             }
             DocumentSchemaValidator documentSchemaValidator = new DocumentSchemaValidator(this, schemas, validationEventHandler);
             documentSchemaValidator.Validate(nodeToValidate);
             if (nodeToValidate == this)
             {
                 reportValidity = true;
             }
         }

         internal override XmlNodeChangedEventArgs GetEventArgs(XmlNode node, XmlNode oldParent, XmlNode newParent, string oldValue, string newValue, XmlNodeChangedAction action)
         {
             reportValidity = false;
             switch (action)
             {
             case XmlNodeChangedAction.Insert:
                 if (onNodeInsertingDelegate == null && onNodeInsertedDelegate == null)
                 {
                     return null;
                 }
                 break;
             case XmlNodeChangedAction.Remove:
                 if (onNodeRemovingDelegate == null && onNodeRemovedDelegate == null)
                 {
                     return null;
                 }
                 break;
             case XmlNodeChangedAction.Change:
                 if (onNodeChangingDelegate == null && onNodeChangedDelegate == null)
                 {
                     return null;
                 }
                 break;
             }
             return new XmlNodeChangedEventArgs(node, oldParent, newParent, oldValue, newValue, action);
         }

         internal XmlNodeChangedEventArgs GetInsertEventArgsForLoad(XmlNode node, XmlNode newParent)
         {
             if (onNodeInsertingDelegate == null && onNodeInsertedDelegate == null)
             {
                 return null;
             }
             string value = node.Value;
             return new XmlNodeChangedEventArgs(node, null, newParent, value, value, XmlNodeChangedAction.Insert);
         }

         internal override void BeforeEvent(XmlNodeChangedEventArgs args)
         {
             if (args == null)
             {
                 return;
             }
             switch (args.Action)
             {
             case XmlNodeChangedAction.Insert:
                 if (onNodeInsertingDelegate != null)
                 {
                     onNodeInsertingDelegate(this, args);
                 }
                 break;
             case XmlNodeChangedAction.Remove:
                 if (onNodeRemovingDelegate != null)
                 {
                     onNodeRemovingDelegate(this, args);
                 }
                 break;
             case XmlNodeChangedAction.Change:
                 if (onNodeChangingDelegate != null)
                 {
                     onNodeChangingDelegate(this, args);
                 }
                 break;
             }
         }

         internal override void AfterEvent(XmlNodeChangedEventArgs args)
         {
             if (args == null)
             {
                 return;
             }
             switch (args.Action)
             {
             case XmlNodeChangedAction.Insert:
                 if (onNodeInsertedDelegate != null)
                 {
                     onNodeInsertedDelegate(this, args);
                 }
                 break;
             case XmlNodeChangedAction.Remove:
                 if (onNodeRemovedDelegate != null)
                 {
                     onNodeRemovedDelegate(this, args);
                 }
                 break;
             case XmlNodeChangedAction.Change:
                 if (onNodeChangedDelegate != null)
                 {
                     onNodeChangedDelegate(this, args);
                 }
                 break;
             }
         }

         internal XmlAttribute GetDefaultAttribute(XmlElement elem, string attrPrefix, string attrLocalname, string attrNamespaceURI)
         {
             SchemaInfo dtdSchemaInfo = DtdSchemaInfo;
             SchemaElementDecl schemaElementDecl = GetSchemaElementDecl(elem);
             if (schemaElementDecl != null && schemaElementDecl.AttDefs != null)
             {
                 IDictionaryEnumerator dictionaryEnumerator = schemaElementDecl.AttDefs.GetEnumerator();
                 while (dictionaryEnumerator.MoveNext())
                 {
                     SchemaAttDef schemaAttDef = (SchemaAttDef)dictionaryEnumerator.Value;
                     if ((schemaAttDef.Presence == SchemaDeclBase.Use.Default || schemaAttDef.Presence == SchemaDeclBase.Use.Fixed) && schemaAttDef.Name.Name == attrLocalname && ((dtdSchemaInfo.SchemaType == SchemaType.DTD && schemaAttDef.Name.Namespace == attrPrefix) || (dtdSchemaInfo.SchemaType != SchemaType.DTD && schemaAttDef.Name.Namespace == attrNamespaceURI)))
                     {
                         return PrepareDefaultAttribute(schemaAttDef, attrPrefix, attrLocalname, attrNamespaceURI);
                     }
                 }
             }
             return null;
         }

         internal XmlEntity GetEntityNode(string name)
         {
             if (DocumentType != null)
             {
                 XmlNamedNodeMap xmlNamedNodeMap = DocumentType.Entities;
                 if (xmlNamedNodeMap != null)
                 {
                     return (XmlEntity)xmlNamedNodeMap.GetNamedItem(name);
                 }
             }
             return null;
         }

         internal void SetBaseURI(string inBaseURI)
         {
             baseURI = inBaseURI;
         }

         internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc)
         {
             if (!IsValidChildType(newChild.NodeType))
             {
                 throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_TypeConflict"));
             }
             if (!CanInsertAfter(newChild, LastChild))
             {
                 throw new InvalidOperationException(Res.GetString("Xdom_Node_Insert_Location"));
             }
             XmlNodeChangedEventArgs insertEventArgsForLoad = GetInsertEventArgsForLoad(newChild, this);
             if (insertEventArgsForLoad != null)
             {
                 BeforeEvent(insertEventArgsForLoad);
             }
             XmlLinkedNode xmlLinkedNode = (XmlLinkedNode)newChild;
             if (lastChild == null)
             {
                 xmlLinkedNode.next = xmlLinkedNode;
             }
             else
             {
                 xmlLinkedNode.next = lastChild.next;
                 lastChild.next = xmlLinkedNode;
             }
             lastChild = xmlLinkedNode;
             xmlLinkedNode.SetParentForLoad(this);
             if (insertEventArgsForLoad != null)
             {
                 AfterEvent(insertEventArgsForLoad);
             }
             return xmlLinkedNode;
         }
     }
 }
System.Text.Encoding
Represents a character encoding.To browse the .NET Framework source code for this type,...
Definition: Encoding.cs:15

System.Security
Definition: AllowPartiallyTrustedCallersAttribute.cs:3

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.WriteState
WriteState
Specifies the state of the T:System.Xml.XmlWriter.
Definition: WriteState.cs:5

System.Xml.XmlNodeType.XmlDeclaration
The XML declaration (for example, <?xml version='1.0'?> ).

System.Xml.XmlNodeChangedEventHandler
delegate void XmlNodeChangedEventHandler(object sender, XmlNodeChangedEventArgs e)
Represents the method that handles E:System.Xml.XmlDocument.NodeChanged, E:System....

System.Xml.XmlDocument.CreateDocumentFragment
virtual XmlDocumentFragment CreateDocumentFragment()
Creates an T:System.Xml.XmlDocumentFragment.
Definition: XmlDocument.cs:839

System.Xml.XmlDocument
Represents an XML document. You can use this class to load, validate, edit, add, and position XML in ...
Definition: XmlDocument.cs:13

System.Xml.XmlDocument.Load
virtual void Load(string filename)
Loads the XML document from the specified URL.
Definition: XmlDocument.cs:1467

System.Xml.XmlNode.LocalName
abstract string LocalName
Gets the local name of the node, when overridden in a derived class.
Definition: XmlNode.cs:163

System.Xml.XmlDocument.DocumentType
virtual XmlDocumentType DocumentType
Gets the node containing the DOCTYPE declaration.
Definition: XmlDocument.cs:127

System.Xml.XmlDeclaration
Represents the XML declaration node <?xml version='1.0'...?>.
Definition: XmlDeclaration.cs:6

System.Xml.XmlDocument.WriteContentTo
override void WriteContentTo(XmlWriter xw)
Saves all the children of the XmlDocument node to the specified T:System.Xml.XmlWriter.
Definition: XmlDocument.cs:1654

System.Xml.XmlNode.GetEnumerator
IEnumerator GetEnumerator()
Get an enumerator that iterates through the child nodes in the current node.
Definition: XmlNode.cs:1111

System.Xml.XmlDocument.Save
virtual void Save(string filename)
Saves the XML document to the specified file. If the specified file exists, this method overwrites it...
Definition: XmlDocument.cs:1555

System.Xml.XmlDocument.NodeChanging
XmlNodeChangedEventHandler NodeChanging
Occurs when the P:System.Xml.XmlNode.Value of a node belonging to this document is about to be change...
Definition: XmlDocument.cs:440

System.Xml.Schema.IXmlSchemaInfo
Defines the post-schema-validation infoset of a validated XML node.
Definition: IXmlSchemaInfo.cs:4

System.Collections.Hashtable.Add
virtual void Add(object key, object value)
Adds an element with the specified key and value into the T:System.Collections.Hashtable.
Definition: Hashtable.cs:916

System.Collections.IEnumerator.MoveNext
bool MoveNext()
Advances the enumerator to the next element of the collection.

System.Xml.XmlCDataSection
Represents a CDATA section.
Definition: XmlCDataSection.cs:6

System.Xml.XmlNode.ParentNode
virtual XmlNode ParentNode
Gets the parent of this node (for nodes that can have parents).
Definition: XmlNode.cs:60

System.Xml.XmlNodeList
Represents an ordered collection of nodes.
Definition: XmlNodeList.cs:7

System.Xml.XmlDocument.NameTable
XmlNameTable NameTable
Gets the T:System.Xml.XmlNameTable associated with this implementation.
Definition: XmlDocument.cs:230

System.Xml.XmlDocument.BaseURI
override string BaseURI
Gets the base URI of the current node.
Definition: XmlDocument.cs:367

System.Xml.XmlDocument.Save
virtual void Save(Stream outStream)
Saves the XML document to the specified stream.
Definition: XmlDocument.cs:1580

System.Xml.XmlWhitespace
Represents white space in element content.
Definition: XmlWhitespace.cs:6

System.Xml.XmlDocument.Load
virtual void Load(Stream inStream)
Loads the XML document from the specified stream.
Definition: XmlDocument.cs:1483

System.Security.PermissionSet.Demand
void Demand()
Forces a T:System.Security.SecurityException at run time if all callers higher in the call stack have...
Definition: PermissionSet.cs:1325

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

System.Xml.XmlNode.WriteTo
abstract void WriteTo(XmlWriter w)
Saves the current node to the specified T:System.Xml.XmlWriter, when overridden in a derived class.

System.Xml.XmlDocument.GetElementById
virtual XmlElement GetElementById(string elementId)
Gets the T:System.Xml.XmlElement with the specified ID.
Definition: XmlDocument.cs:1130

System.Xml.XmlDocument.LoadXml
virtual void LoadXml(string xml)
Loads the XML document from the specified string.
Definition: XmlDocument.cs:1539

System.Xml.XmlDocument.CreateElement
XmlElement CreateElement(string name)
Creates an element with the specified name.
Definition: XmlDocument.cs:847

System.IDisposable
Provides a mechanism for releasing unmanaged resources.To browse the .NET Framework source code for t...
Definition: IDisposable.cs:8

System.Xml.XmlNode.LastChild
virtual XmlNode LastChild
Gets the last child of the node.
Definition: XmlNode.cs:121

System.Xml.XmlDocument.Load
virtual void Load(XmlReader reader)
Loads the XML document from the specified T:System.Xml.XmlReader.
Definition: XmlDocument.cs:1515

System.Collections.ArrayList.Count
virtual int Count
Gets the number of elements actually contained in the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2255

System.Xml.XmlDocument.CreateNavigator
override XPathNavigator CreateNavigator()
Creates a new T:System.Xml.XPath.XPathNavigator object for navigating this document.
Definition: XmlDocument.cs:957

System
Definition: __Canon.cs:3

System.Xml.XmlDocument.ReadNode
virtual XmlNode ReadNode(XmlReader reader)
Creates an T:System.Xml.XmlNode object based on the information in the T:System.Xml....
Definition: XmlDocument.cs:1363

System.Xml.XmlDocument.CreateXmlDeclaration
virtual XmlDeclaration CreateXmlDeclaration(string version, string encoding, string standalone)
Creates an T:System.Xml.XmlDeclaration node with the specified values.
Definition: XmlDocument.cs:934

System.Xml.XmlDocument.NodeRemoving
XmlNodeChangedEventHandler NodeRemoving
Occurs when a node belonging to this document is about to be removed from the document.
Definition: XmlDocument.cs:414

System.Xml.XmlDocument.InnerText
override string InnerText
Throws an T:System.InvalidOperationException in all cases.
Definition: XmlDocument.cs:313

System.Xml.XmlResolver
Resolves external XML resources named by a Uniform Resource Identifier (URI).
Definition: XmlResolver.cs:8

System.Xml.XmlAttribute
Represents an attribute. Valid and default values for the attribute are defined in a document type de...
Definition: XmlAttribute.cs:7

System.Xml.XmlDocument.NodeChanged
XmlNodeChangedEventHandler NodeChanged
Occurs when the P:System.Xml.XmlNode.Value of a node belonging to this document has been changed.
Definition: XmlDocument.cs:453

System.Xml.XmlEntityReference
Represents an entity reference node.
Definition: XmlEntityReference.cs:6

System.Xml.XmlDocument.IsReadOnly
override bool IsReadOnly
Gets a value indicating whether the current node is read-only.
Definition: XmlDocument.cs:250

System.Xml.XmlDocument.CloneNode
override XmlNode CloneNode(bool deep)
Creates a duplicate of this node.
Definition: XmlDocument.cs:638

System.Xml.Schema.XmlSchemaSet.Count
int Count
Gets the number of logical XML Schema definition language (XSD) schemas in the T:System....
Definition: XmlSchemaSet.cs:98

System.Xml.XmlDocument.CreateAttribute
XmlAttribute CreateAttribute(string qualifiedName, string namespaceURI)
Creates an T:System.Xml.XmlAttribute with the specified qualified name and P:System....
Definition: XmlDocument.cs:1098

System.Xml.XmlNodeType
XmlNodeType
Specifies the type of node.
Definition: XmlNodeType.cs:5

System.Xml.XmlProcessingInstruction
Represents a processing instruction, which XML defines to keep processor-specific information in the ...
Definition: XmlProcessingInstruction.cs:6

System.Xml.XmlDocument.GetElementsByTagName
virtual XmlNodeList GetElementsByTagName(string name)
Returns an T:System.Xml.XmlNodeList containing a list of all descendant elements that match the speci...
Definition: XmlDocument.cs:1089

System.Xml.EntityHandling
EntityHandling
Specifies how the T:System.Xml.XmlTextReader or T:System.Xml.XmlValidatingReader handle entities.
Definition: EntityHandling.cs:4

System.Xml.XmlDocumentType
Represents the document type declaration.
Definition: XmlDocumentType.cs:6

System.Delegate.Remove
static Delegate Remove(Delegate source, Delegate value)
Removes the last occurrence of the invocation list of a delegate from the invocation list of another ...
Definition: Delegate.cs:287

System.Delegate.Combine
static Delegate Combine(Delegate a, Delegate b)
Concatenates the invocation lists of two delegates.
Definition: Delegate.cs:202

System.Xml.XmlDocument.XmlDocument
XmlDocument()
Initializes a new instance of the T:System.Xml.XmlDocument class.
Definition: XmlDocument.cs:465

System.Xml.XPath.XPathNodeType
XPathNodeType
Defines the XPath node types that can be returned from the T:System.Xml.XPath.XPathNavigator class.
Definition: XPathNodeType.cs:4

System.Text.Encoding.GetEncoding
static Encoding GetEncoding(int codepage)
Returns the encoding associated with the specified code page identifier.
Definition: Encoding.cs:1249

System.Xml.XmlNode.NamespaceURI
virtual string NamespaceURI
Gets the namespace URI of this node.
Definition: XmlNode.cs:143

System.Xml.XmlDocument.Save
virtual void Save(XmlWriter w)
Saves the XML document to the specified T:System.Xml.XmlWriter.
Definition: XmlDocument.cs:1607

System.Xml.XmlNode.HasChildNodes
virtual bool HasChildNodes
Gets a value indicating whether this node has any child nodes.
Definition: XmlNode.cs:139

System.Xml.XmlImplementation
Defines the context for a set of T:System.Xml.XmlDocument objects.
Definition: XmlImplementation.cs:4

System.Xml.Schema.IXmlSchemaInfo.Validity
XmlSchemaValidity Validity
Gets the T:System.Xml.Schema.XmlSchemaValidity value of this validated XML node.
Definition: IXmlSchemaInfo.cs:9

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.XmlDocument.NodeRemoved
XmlNodeChangedEventHandler NodeRemoved
Occurs when a node belonging to this document has been removed from its parent.
Definition: XmlDocument.cs:427

System.WeakReference
Represents a weak reference, which references an object while still allowing that object to be reclai...
Definition: WeakReference.cs:14

System.Xml.XmlTextReader
Represents a reader that provides fast, non-cached, forward-only access to XML data....
Definition: XmlTextReader.cs:12

System.Xml.XmlNamedNodeMap
Represents a collection of nodes that can be accessed by name or index.
Definition: XmlNamedNodeMap.cs:6

System.Security.NamedPermissionSet
Defines a permission set that has a name and description associated with it. This class cannot be inh...
Definition: NamedPermissionSet.cs:11

System.Xml.XmlNodeChangedEventArgs
Provides data for the E:System.Xml.XmlDocument.NodeChanged, E:System.Xml.XmlDocument....
Definition: XmlNodeChangedEventArgs.cs:4

System.Xml.XmlDocument.Validate
void Validate(ValidationEventHandler validationEventHandler, XmlNode nodeToValidate)
Validates the T:System.Xml.XmlNode object specified against the XML Schema Definition Language (XSD) ...
Definition: XmlDocument.cs:1689

System.Xml.XmlReader
Represents a reader that provides fast, noncached, forward-only access to XML data....
Definition: XmlReader.cs:15

System.Xml.XmlDocument.CreateComment
virtual XmlComment CreateComment(string data)
Creates an T:System.Xml.XmlComment containing the specified data.
Definition: XmlDocument.cs:820

System.Xml.XmlDocument.WriteTo
override void WriteTo(XmlWriter w)
Saves the XmlDocument node to the specified T:System.Xml.XmlWriter.
Definition: XmlDocument.cs:1647

System.Xml.XmlDocument.CreateTextNode
virtual XmlText CreateTextNode(string text)
Creates an T:System.Xml.XmlText with the specified text.
Definition: XmlDocument.cs:942

System.Xml.XmlDocument.ImportNode
virtual XmlNode ImportNode(XmlNode node, bool deep)
Imports a node from another document to the current document.
Definition: XmlDocument.cs:1156

System.Xml.XmlDocument.DocumentElement
XmlElement DocumentElement
Gets the root T:System.Xml.XmlElement for the document.
Definition: XmlDocument.cs:155

System.Xml.XmlDocument.SchemaInfo
override IXmlSchemaInfo SchemaInfo
Returns the Post-Schema-Validation-Infoset (PSVI) of the node.
Definition: XmlDocument.cs:344

System.Xml.XmlDeclaration.Encoding
string? Encoding
Gets or sets the encoding level of the XML document.
Definition: XmlDeclaration.cs:35

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.Security.Permissions.SecurityAction
SecurityAction
Specifies the security actions that can be performed using declarative security.
Definition: SecurityAction.cs:8

System.Xml.NameTable
Implements a single-threaded T:System.Xml.XmlNameTable.
Definition: NameTable.cs:5

System.Xml.XmlDocument.Save
virtual void Save(TextWriter writer)
Saves the XML document to the specified T:System.IO.TextWriter.
Definition: XmlDocument.cs:1594

System.Security.PermissionSet
Represents a collection that can contain many different types of permissions.
Definition: PermissionSet.cs:20

System.Xml.XmlDocument.CreateAttribute
virtual XmlAttribute CreateAttribute(string prefix, string localName, string namespaceURI)
Creates an T:System.Xml.XmlAttribute with the specified P:System.Xml.XmlNode.Prefix,...
Definition: XmlDocument.cs:1256

System.Xml.Schema.XmlSchemaInfo
Represents the post-schema-validation infoset of a validated XML node.
Definition: XmlSchemaInfo.cs:4

System.Xml.XmlDocument.PreserveWhitespace
bool PreserveWhitespace
Gets or sets a value indicating whether to preserve white space in element content.
Definition: XmlDocument.cs:236

System.Xml.XmlDocument.CreateDocumentType
virtual XmlDocumentType CreateDocumentType(string name, string publicId, string systemId, string internalSubset)
Returns a new T:System.Xml.XmlDocumentType object.
Definition: XmlDocument.cs:832

System.Xml.XmlDocument.GetElementsByTagName
virtual XmlNodeList GetElementsByTagName(string localName, string namespaceURI)
Returns an T:System.Xml.XmlNodeList containing a list of all descendant elements that match the speci...
Definition: XmlDocument.cs:1122

System.Xml.Schema.XmlSchemaValidity
XmlSchemaValidity
Represents the validity of an XML item validated by the T:System.Xml.Schema.XmlSchemaValidator class.
Definition: XmlSchemaValidity.cs:4

System.Xml.XmlDocument.CreateWhitespace
virtual XmlWhitespace CreateWhitespace(string text)
Creates an T:System.Xml.XmlWhitespace node.
Definition: XmlDocument.cs:1081

System.Version.Version
Version(int major, int minor, int build, int revision)
Initializes a new instance of the T:System.Version class with the specified major,...
Definition: Version.cs:179

System.Xml.XmlLinkedNode
Gets the node immediately preceding or following this node.
Definition: XmlLinkedNode.cs:4

System.Xml.XmlNodeChangedAction
XmlNodeChangedAction
Specifies the type of node change.
Definition: XmlNodeChangedAction.cs:4

System.Collections.Hashtable
Represents a collection of key/value pairs that are organized based on the hash code of the key....
Definition: Hashtable.cs:17

System.Xml.XmlNamedNodeMap.GetNamedItem
virtual XmlNode GetNamedItem(string name)
Retrieves an T:System.Xml.XmlNode specified by name.
Definition: XmlNamedNodeMap.cs:199

System.IO
Definition: __ConsoleStream.cs:7

System.Xml.XmlDocument.CreateElement
virtual XmlElement CreateElement(string prefix, string localName, string namespaceURI)
Creates an element with the specified P:System.Xml.XmlNode.Prefix, P:System.Xml.XmlDocument....
Definition: XmlDocument.cs:1276

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

System.Xml.XmlNode.Value
virtual string Value
Gets or sets the value of the node.
Definition: XmlNode.cs:36

System.Collections.IEnumerator.Current
object Current
Gets the element in the collection at the current position of the enumerator.
Definition: IEnumerator.cs:15

System.Delegate
Represents a delegate, which is a data structure that refers to a static method or to a class instanc...
Definition: Delegate.cs:15

System.Xml.XmlElement
Represents an element.
Definition: XmlElement.cs:7

System.Version
Represents the version number of an assembly, operating system, or the common language runtime....
Definition: Version.cs:11

System.Xml.XmlDocument.CreateAttribute
XmlAttribute CreateAttribute(string name)
Creates an T:System.Xml.XmlAttribute with the specified P:System.Xml.XmlDocument.Name.
Definition: XmlDocument.cs:786

System.Xml.XmlDocument.XmlDocument
internal XmlDocument(XmlImplementation imp)
Initializes a new instance of the XmlDocument class with the specified T:System.Xml....
Definition: XmlDocument.cs:479

System.Xml.XmlTextReader.Close
override void Close()
Changes the P:System.Xml.XmlReader.ReadState to Closed.
Definition: XmlTextReader.cs:515

System.Xml.XmlNameTable
Table of atomized string objects.
Definition: XmlNameTable.cs:5

System.Xml.XmlDocument.XmlDocument
XmlDocument(XmlNameTable nt)
Initializes a new instance of the XmlDocument class with the specified T:System.Xml....
Definition: XmlDocument.cs:472

System.Xml.XmlText
Represents the text content of an element or attribute.
Definition: XmlText.cs:6

System.Xml.XmlDocument.CreateProcessingInstruction
virtual XmlProcessingInstruction CreateProcessingInstruction(string target, string data)
Creates an T:System.Xml.XmlProcessingInstruction with the specified name and data.
Definition: XmlDocument.cs:923

System.Xml.XmlElement.SchemaInfo
override IXmlSchemaInfo SchemaInfo
Gets the post schema validation infoset that has been assigned to this node as a result of schema val...
Definition: XmlElement.cs:148

System.Xml.XmlDocument.OwnerDocument
override XmlDocument OwnerDocument
Gets the T:System.Xml.XmlDocument to which the current node belongs.
Definition: XmlDocument.cs:173

System.Xml.XmlNode.Prefix
virtual string Prefix
Gets or sets the namespace prefix of this node.
Definition: XmlNode.cs:150

System.Xml.XmlDocument.NodeInserted
XmlNodeChangedEventHandler NodeInserted
Occurs when a node belonging to this document has been inserted into another node.
Definition: XmlDocument.cs:401

System.Collections.ArrayList.Add
virtual int Add(object value)
Adds an object to the end of the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2381

System.Xml.XmlException
Returns detailed information about the last exception.
Definition: XmlException.cs:12

System.Xml.XmlDocument.CreateElement
XmlElement CreateElement(string qualifiedName, string namespaceURI)
Creates an T:System.Xml.XmlElement with the qualified name and P:System.Xml.XmlNode....
Definition: XmlDocument.cs:1110

System.Xml.XmlDocument.CreateNode
virtual XmlNode CreateNode(string nodeTypeString, string name, string namespaceURI)
Creates an T:System.Xml.XmlNode with the specified node type, P:System.Xml.XmlDocument....
Definition: XmlDocument.cs:1342

System.Xml.XPath
Definition: IXPathNavigable.cs:1

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.XmlDocument.CreateSignificantWhitespace
virtual XmlSignificantWhitespace CreateSignificantWhitespace(string text)
Creates an T:System.Xml.XmlSignificantWhitespace node.
Definition: XmlDocument.cs:950

System.Xml.XmlDocument.CreateDefaultAttribute
virtual internal XmlAttribute CreateDefaultAttribute(string prefix, string localName, string namespaceURI)
Creates a default attribute with the specified prefix, local name and namespace URI.
Definition: XmlDocument.cs:1266

System.Xml.XmlDocument.Validate
void Validate(ValidationEventHandler validationEventHandler)
Validates the T:System.Xml.XmlDocument against the XML Schema Definition Language (XSD) schemas conta...
Definition: XmlDocument.cs:1678

System.Collections
Definition: ArrayList.cs:7

System.Xml.XmlElement.SetAttributeNode
virtual XmlAttribute SetAttributeNode(XmlAttribute newAttr)
Adds the specified T:System.Xml.XmlAttribute.
Definition: XmlElement.cs:385

System.Xml.XmlDocument.Load
virtual void Load(TextReader txtReader)
Loads the XML document from the specified T:System.IO.TextReader.
Definition: XmlDocument.cs:1499

System.Collections.ArrayList.Remove
virtual void Remove(object obj)
Removes the first occurrence of a specific object from the T:System.Collections.ArrayList.
Definition: ArrayList.cs:2832

System.Collections.Hashtable.Contains
virtual bool Contains(object key)
Determines whether the T:System.Collections.Hashtable contains a specific key.
Definition: Hashtable.cs:972

System.Xml.XmlNameTable.Add
abstract string Add(char[] array, int offset, int length)
When overridden in a derived class, atomizes the specified string and adds it to the XmlNameTable.

System.Xml.XmlDocument.CreateNode
virtual XmlNode CreateNode(XmlNodeType type, string name, string namespaceURI)
Creates an T:System.Xml.XmlNode with the specified T:System.Xml.XmlNodeType, P:System....
Definition: XmlDocument.cs:1353

System.Xml.XmlDocument.CreateEntityReference
virtual XmlEntityReference CreateEntityReference(string name)
Creates an T:System.Xml.XmlEntityReference with the specified name.
Definition: XmlDocument.cs:914

System.Collections.Hashtable.Remove
virtual void Remove(object key)
Removes the element with the specified key from the T:System.Collections.Hashtable.
Definition: Hashtable.cs:1349

System.Xml.XmlDocument.CreateNode
virtual XmlNode CreateNode(XmlNodeType type, string prefix, string name, string namespaceURI)
Creates a T:System.Xml.XmlNode with the specified T:System.Xml.XmlNodeType, P:System....
Definition: XmlDocument.cs:1293

System.IO.TextReader
Represents a reader that can read a sequential series of characters.
Definition: TextReader.cs:14

System.Collections.IDictionaryEnumerator.Value
object Value
Gets the value of the current dictionary entry.
Definition: IDictionaryEnumerator.cs:25

System.Xml.XmlNode.FirstChild
virtual XmlNode FirstChild
Gets the first child of the node.
Definition: XmlNode.cs:117

System.Xml.XmlDocumentType.Entities
XmlNamedNodeMap Entities
Gets the collection of T:System.Xml.XmlEntity nodes declared in the document type declaration.
Definition: XmlDocumentType.cs:44

System.Xml.XPath.XPathNavigator
Provides a cursor model for navigating and editing XML data.
Definition: XPathNavigator.cs:14

System.Xml.XmlDocument.LocalName
override string LocalName
Gets the local name of the node.
Definition: XmlDocument.cs:151

System.Collections.IDictionaryEnumerator
Enumerates the elements of a nongeneric dictionary.
Definition: IDictionaryEnumerator.cs:8

System.Xml.XmlDocument.NodeType
override XmlNodeType NodeType
Gets the type of the current node.
Definition: XmlDocument.cs:119

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

System.Xml.XmlComment
Represents the content of an XML comment.
Definition: XmlComment.cs:6

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.XmlDocument.InnerXml
override string InnerXml
Gets or sets the markup representing the children of the current node.
Definition: XmlDocument.cs:324

System.Xml.XmlNode.NextSibling
virtual XmlNode NextSibling
Gets the node immediately following this node.
Definition: XmlNode.cs:95

System.Text.Encoding.Encoding
Encoding()
Initializes a new instance of the T:System.Text.Encoding class.
Definition: Encoding.cs:1053

System.Xml.XmlNode.RemoveAll
virtual void RemoveAll()
Removes all the child nodes and/or attributes of the current node.
Definition: XmlNode.cs:1143

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

System.Security.Permissions
Definition: BuiltInPermissionFlag.cs:1

System.Xml.XmlDocument.Name
override string Name
Gets the qualified name of the node.
Definition: XmlDocument.cs:147

System.Xml.XmlDocument.ParentNode
override XmlNode ParentNode
Gets the parent node of this node (for nodes that can have parents).
Definition: XmlDocument.cs:123

System.Xml.XmlAttribute.Value
override string Value
Gets or sets the value of the node.
Definition: XmlAttribute.cs:71

System.Xml.XmlDocument.Implementation
XmlImplementation Implementation
Gets the T:System.Xml.XmlImplementation object for the current document.
Definition: XmlDocument.cs:143

System.Xml
Definition: AsyncHelper.cs:3

System.Xml.XmlDocument.CreateCDataSection
virtual XmlCDataSection CreateCDataSection(string data)
Creates an T:System.Xml.XmlCDataSection containing the specified data.
Definition: XmlDocument.cs:811

System.IDisposable.Dispose
void Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resourc...

System.Xml.XmlDocument.Schemas
XmlSchemaSet Schemas
Gets or sets the T:System.Xml.Schema.XmlSchemaSet object associated with this T:System....
Definition: XmlDocument.cs:178

System.IO.StringReader
Implements a T:System.IO.TextReader that reads from a string.
Definition: StringReader.cs:10

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

System.Security.SecurityException
The exception that is thrown when a security error is detected.
Definition: SecurityException.cs:19

System.Xml.XmlNode
Represents a single node in the XML document.
Definition: XmlNode.cs:13

System.Xml.XmlNode.Name
abstract string Name
Gets the qualified name of the node, when overridden in a derived class.
Definition: XmlNode.cs:20

System.Collections.IEnumerator
Supports a simple iteration over a non-generic collection.
Definition: IEnumerator.cs:9

System.Globalization
Definition: AppDomainSortingSetupInfo.cs:1

System.Xml.Schema
Definition: ActiveAxis.cs:3

System.Xml.XmlNode.NodeType
abstract XmlNodeType NodeType
Gets the type of the current node, when overridden in a derived class.
Definition: XmlNode.cs:53

System.Xml.XmlDocumentFragment
Represents a lightweight object that is useful for tree insert operations.
Definition: XmlDocumentFragment.cs:7

System.Xml.XmlImplementation.CreateDocument
virtual XmlDocument CreateDocument()
Creates a new T:System.Xml.XmlDocument.
Definition: XmlImplementation.cs:39

System.Collections.ArrayList
Implements the T:System.Collections.IList interface using an array whose size is dynamically increase...
Definition: ArrayList.cs:14

System.Xml.XmlDocument.NodeInserting
XmlNodeChangedEventHandler NodeInserting
Occurs when a node belonging to this document is about to be inserted into another node.
Definition: XmlDocument.cs:388

System.Xml.XmlDocument.CreateNavigator
virtual internal XPathNavigator CreateNavigator(XmlNode node)
Creates an T:System.Xml.XPath.XPathNavigator object for navigating this document positioned on the T:...
Definition: XmlDocument.cs:965

System.Xml.Schema.XmlSchemaSet
Contains a cache of XML Schema definition language (XSD) schemas.
Definition: XmlSchemaSet.cs:8

System.Xml.XmlSignificantWhitespace
Represents white space between markup in a mixed content node or white space within an xml:space= 'pr...
Definition: XmlSignificantWhitespace.cs:6

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