16public class XmlAttribute : XmlNode {

23public class XmlDocument: XmlNode {

49public class XmlDocumentFragment : XmlNode {

12public class XmlEntity : XmlNode {

11public abstract class XmlLinkedNode: XmlNode {

13public class XmlNotation : XmlNode {

761XmlNode startupNode = null; 763XmlNode requiredRuntime = null; 781foreach (XmlNode xmlNodeS in supportedRuntimes)

385XmlNode root = xmlProjectDoc.DocumentElement; 462XmlNode root = xmlProjectDoc.DocumentElement; 465XmlNode nodeItemGroup = xmlProjectDoc.CreateElement(ITEMGROUP_NAME, root.NamespaceURI);

119XmlNode entryPoint = entryPointList[0];

222XmlNode current = args.Node;

522XmlNode oldValue = root.GetAttributeNode(name, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);

67public abstract void Save(XmlNode node); 73public abstract void Load(XmlNode node); 209public override void Save(XmlNode node) 237public override void Load(XmlNode node) 382public override void Save(XmlNode node) 404public override void Load(XmlNode node)

186private XmlNode ContextNode 314ContextNode = CollectionView.CurrentItem as XmlNode; 324ContextNode = DataItem as XmlNode; 381private XmlDocument DocumentFor(XmlNode node) 546private string IdentifyNode(XmlNode node) 607XmlNode parent = null; 608XmlNode valueNode = null; 640XmlNode resultNode = _hostWorker.GetResultNode() as XmlNode; 667private XmlNode _contextNode;

27internal class XmlDataCollection : ReadOnlyObservableCollection<XmlNode> 39internal XmlDataCollection(XmlDataProvider xmlDataProvider) : base(new ObservableCollection<XmlNode>())

660foreach(XmlNode node in doc.DocumentElement.ChildNodes)

480XmlNode node, // xml node to construct BamlTreeNode from

35internal FixedPageContentExtractor(XmlNode fixedPage)

39internal XmlFixedPageInfo(XmlNode fixedPageNode) 161private XmlNode _pageNode;

42internal XmlGlyphRunInfo(XmlNode glyphsNode)

361XmlNode node = doc.ReadNode(reader); // Reads the entire "StringAuthor" tag

523XmlNode root = doc.DocumentElement;

4185protected virtual XmlNode CallHostProcessRawXml(XmlNode rawXml, ConfigurationBuilder configBuilder) { 4295XmlNode processedXml = null;

68public ConfigurationErrorsException(string message, XmlNode node) : 71public ConfigurationErrorsException(string message, Exception inner, XmlNode node) : 303public static int GetLineNumber(XmlNode node) { 307public static string GetFilename(XmlNode node) { 311private static string GetUnsafeFilename(XmlNode node) {

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

29public override XmlNode CloneNode(bool deep) { 30XmlNode cloneNode = base.CloneNode(deep);

24public override XmlNode Decrypt(XmlNode encryptedNode) 31XmlNode cipherNode = TraverseToChild(encryptedNode, "CipherData", false); 35XmlNode cipherValue = TraverseToChild(cipherNode, "CipherValue", true); 50public override XmlNode Encrypt(XmlNode node) 216private static XmlNode TraverseToChild(XmlNode node, string name, bool onlyChild) 218foreach (XmlNode child in node.ChildNodes)

80static internal XmlNode CreateSectionXmlNode(ConfigXmlReader reader) { 83XmlNode xmlNode = doc.DocumentElement;

238public virtual XmlNode ProcessRawXml(XmlNode rawXml, ConfigurationBuilder builder) {

450XmlNode IInternalConfigurationBuilderHost.ProcessRawXml(XmlNode rawXml, ConfigurationBuilder builder) {

17public abstract XmlNode Encrypt(XmlNode node); 18public abstract XmlNode Decrypt(XmlNode encryptedNode);

74XmlNode resultNode = provider.Decrypt(doc.DocumentElement); 94XmlNode encNode = provider.Encrypt(xmlDocument.DocumentElement);

28public override XmlNode Decrypt(XmlNode encryptedNode) 43public override XmlNode Encrypt(XmlNode node) 88foreach (XmlNode node2 in xmlDocument.ChildNodes) 90foreach (XmlNode node3 in node2.ChildNodes) // node2 is the "foo" node

199private static void CheckForLockAttributes(string sectionName, XmlNode xmlNode) { 209foreach (XmlNode child in xmlNode.ChildNodes) { 256XmlNode xmlNode = ErrorInfoXmlDocument.CreateSectionXmlNode(reader);

173static internal ConfigurationException Configuration(string message, XmlNode node) { 737static internal ConfigurationException ConfigBaseNoChildNodes(XmlNode node) { // Res.Config_base_no_child_nodes 740static internal ConfigurationException ConfigBaseElementsOnly(XmlNode node) { // Res.Config_base_elements_only 743static internal ConfigurationException ConfigUnrecognizedAttributes(XmlNode node) { // Res.Config_base_unrecognized_attribute 746static internal ConfigurationException ConfigUnrecognizedElement(XmlNode node) { // Res.Config_base_unrecognized_element 752static internal ConfigurationException ConfigRequiredAttributeMissing(string name, XmlNode node) { // Res.Config_base_required_attribute_missing 755static internal ConfigurationException ConfigRequiredAttributeEmpty(string name, XmlNode node) { // Res.Config_base_required_attribute_empty

68virtual public object Create(object parent, object configContext, XmlNode section) { // V1.2.3300 85static internal object CreateStatic(object parent, object configContext, XmlNode section) { 92foreach (XmlNode child in section.ChildNodes) { 122static internal string RemoveAttribute(XmlNode node, string name) { 123XmlNode attribute = node.Attributes.RemoveNamedItem(name); 137static internal NameValueCollection CreateStatic(NameValueCollection config, Object context, XmlNode section) { 142foreach (XmlNode child in section.ChildNodes) { 163static private void HandleAdd(XmlNode child, NameValueCollection config) { 174static private void HandleRemove(XmlNode child, NameValueCollection config) { 180static private void HandleClear(XmlNode child, NameValueCollection config) {

134virtual public object Create(object parent, object configContext, XmlNode section) { // V1.2.3300 148static internal object CreateStatic(object parent, object configContext, XmlNode section) { 155foreach (XmlNode child in section.ChildNodes) { 177private static void HandleProviders(DataSet config, object configContext, XmlNode section, string sectionName) { 198static internal DataTable CreateStatic(DataTable config, Object context, XmlNode section) { 207foreach (XmlNode child in section.ChildNodes) { 229static private void HandleAdd(XmlNode child, DataTable config) { 244static private void HandleRemove(XmlNode child, DataTable config) { 253static private void HandleClear(XmlNode child, DataTable config) {

20static internal void CheckForChildNodes(XmlNode node) { 25static private void CheckForNonElement(XmlNode node) { 30static internal void CheckForUnrecognizedAttributes(XmlNode node) { 37static internal bool IsIgnorableAlsoCheckForNonElement(XmlNode node) { 45static internal string RemoveAttribute(XmlNode node, string name, bool required, bool allowEmpty) { 46XmlNode attribute = node.Attributes.RemoveNamedItem(name);

1489XmlNode node = xdoc.ReadNode(reader); 1625XmlNode node = xdoc.ReadNode(reader); 1703XmlNode schNode = xdoc.ReadNode(reader); 2022XmlNode node = xdoc.ReadNode(reader); 2477XmlNode node = xdoc.ReadNode(reader);

5275XmlNode node = xdoc.ReadNode(reader); 5510XmlNode node = xdoc.ReadNode(reader); 5572XmlNode schNode = xdoc.ReadNode(reader);;

247internal XmlNode ToNode(XmlDocument dc, Hashtable prefixes, bool inRemoting) {

54for (XmlNode n = schemaRoot.FirstChild; n != null; n = n.NextSibling) { 73XmlNode vn; 74XmlNode vnRoof; 155for (XmlNode n = typeNode.FirstChild; n != null; n = n.NextSibling) { 504for (XmlNode n = typeNode.FirstChild; n != null; n = n.NextSibling) {

93private void AttachRows( DataRow parentRow, XmlNode parentElement ) { 97for (XmlNode n = parentElement.FirstChild; n != null; n = n.NextSibling) { 118private int CountNonNSAttributes (XmlNode node) { 128private string GetValueForTextOnlyColums( XmlNode n ) { 158private string GetInitialTextFromNodes( ref XmlNode n ) { 209for (XmlNode tabNode = e.FirstChild; tabNode != null; tabNode = tabNode.NextSibling) 226private bool FIgnoreNamespace(XmlNode node) { 227XmlNode ownerNode; 340XmlNode n; 450private void LoadRows( DataRow parentRow, XmlNode parentElement ) { 460for (XmlNode n = parentElement.FirstChild; n != null; n = n.NextSibling) { 519XmlNode n = attr.FirstChild; 684XmlNode n; // Need this to pass by reference

703((XmlNode)rootSchema).PrependChild((XmlNode)_import); 766((XmlNode)tNode).PrependChild((XmlNode)_import2); 792((XmlNode)rootSchema).PrependChild((XmlNode)comment); 1021for (XmlNode n = schema.FirstChild; n != null; n = n.NextSibling) { 1059XmlNode type; 1338for (XmlNode n = node.FirstChild; n != null; n = n.NextSibling) {

74internal static bool FEqualIdentity(XmlNode node, String name, String ns) { 740XmlNode[] relations = ((XmlSchemaAppInfo) __items).Markup;

47public object this[XmlNode node] { 403public object GetColumnSchema(XmlNode node, bool fIgnoreNamespace) { 407XmlNode nodeRegion = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode; 438public object GetSchemaForNode(XmlNode node, bool fIgnoreNamespace) {

20internal abstract XmlNode CurrentNode { get; }

18internal DataDocumentXPathNavigator( XmlDataDocument doc, XmlNode node ) { 186XmlNode IHasXmlNode.GetNode() { return _curNode.Node; }

16private XmlNode node; 22internal DataPointer( XmlDataDocument doc, XmlNode node ) { 74private static bool IsFoliated( XmlNode node ) { 91private void MoveTo( XmlNode node ) { 102private void MoveTo( XmlNode node, DataColumn column, bool fOnValue ) { 175XmlNode n = doc.SafeFirstChild( node ); 198XmlNode n = doc.SafeFirstChild( node ); 205XmlNode n = doc.SafeNextSibling( node ); 232XmlNode n = node.ParentNode; 254XmlNode n = ((XmlAttribute)node).OwnerElement; 298XmlNode n = node.Attributes.Item(i); 474bool IXmlDataVirtualNode.IsOnNode( XmlNode nodeToCheck ) { 484internal XmlNode GetNode() { 514void IXmlDataVirtualNode.OnFoliated( XmlNode foliatedNode ) { 528XmlNode n = null; 615XmlNode child = doc.SafeFirstChild(doc);

119for ( XmlNode n = elem.FirstChild; n != null; n = n.NextSibling ) { 129internal DataColumn GetColumnSchemaForNode( XmlBoundElement rowElem, XmlNode node ) { 196internal bool GetRegion( XmlNode node, out XmlBoundElement rowElem ) { 250XmlNode fc = attr.FirstChild; 259XmlNode n = rowElem.FirstChild; 290XmlNode fc = e.FirstChild;

15bool IsOnNode( XmlNode nodeToCheck ); 18void OnFoliated( XmlNode foliatedNode );

25private XmlNode currentNode; 37internal override XmlNode CurrentNode { 44XmlNode nextNode; 75XmlNode nextNode = currentNode.NextSibling; 126XmlNode n = this.CurrentNode.FirstChild; 144private static string GetInitialTextFromNodes( ref XmlNode n ) {

14private XmlNode nodeTop; 15private XmlNode currentNode; 17internal TreeIterator( XmlNode nodeTop ) : base( ((XmlDataDocument)(nodeTop.OwnerDocument)).Mapper ) { 27internal override XmlNode CurrentNode { 34XmlNode nextNode; 54XmlNode nextNode = currentNode.NextSibling;

42public override XmlNode FirstChild { 49internal XmlNode SafeFirstChild { get { return base.FirstChild; } } 51public override XmlNode LastChild { 58public override XmlNode PreviousSibling { 60XmlNode prev = base.PreviousSibling; 72internal XmlNode SafePreviousSibling { get { return base.PreviousSibling; } } 74public override XmlNode NextSibling { 76XmlNode next = base.NextSibling; 88internal XmlNode SafeNextSibling { get { return base.NextSibling; } } 97public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) { 102public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) { 107public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) { 112public override XmlNode AppendChild(XmlNode newChild) { 118XmlNode child = FirstChild; 119XmlNode sibling = null; 185public override XmlNode CloneNode(bool deep) {

110internal void SyncRows( DataRow parentRow, XmlNode node, bool fAddRowsToTable) { 134for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling ) 140internal void SyncTree( XmlNode node) { 170for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling ) 397XmlNode node = rowElem.FirstChild; 399XmlNode next = node.NextSibling; 605XmlNode priorNode = null; 622XmlNode newNode = null; 670private XmlNode GetColumnInsertAfterLocation( DataRow row, DataColumn col, XmlBoundElement rowElement ) { 671XmlNode prev = null; 672XmlNode node = null; 763private XmlNode GetRowInsertBeforeLocation(DataRow row, XmlElement rowElement, XmlNode parentElement) { 785return(XmlNode) null; 800internal bool HasPointers( XmlNode node ) { 855internal XmlNode CloneTree( DataPointer other ) { 865XmlNode newNode; 890private XmlNode CloneTreeInternal( DataPointer other ) { 896XmlNode newNode = CloneNode( other ); 927public override XmlNode CloneNode( bool deep ) { 938XmlNode cloneNode; 954private XmlNode CloneNode( DataPointer dp ) { 991internal static bool IsTextLikeNode( XmlNode n ) { 1163private void LoadRows( XmlBoundElement rowElem, XmlNode node ) { 1185for ( XmlNode child = node.FirstChild; child != null; child = child.NextSibling ) 1393XmlNode elemBefore = GetColumnInsertAfterLocation( row, col, rowElement ); 1502private void OnFoliated( XmlNode node ) { 1642XmlNode node = args.Node; 1643XmlNode oldParent = args.OldParent; 1644XmlNode newParent = args.NewParent; 1691XmlNode node = args.Node; 1692XmlNode oldParent = args.OldParent; 1720private void OnNodeRemovedFromTree( XmlNode node, XmlNode oldParent ) { 1741private void OnNodeRemovedFromFragment( XmlNode node, XmlNode oldParent ) { 2005XmlNode refRow; 2029private void PromoteChild( XmlNode child, XmlNode prevSibling ) { 2047private void PromoteInnerRegions( XmlNode parent ) { 2052XmlNode prevSibling = parent; 2067private void PromoteNonValueChildren( XmlNode parent ) { 2069XmlNode prevSibling = parent; 2070XmlNode child = parent.FirstChild; 2072XmlNode nextSibling = null; 2085private void RemoveInitialTextNodes( XmlNode node ) { 2087XmlNode sibling = node.NextSibling; 2093private void ReplaceInitialChildText( XmlNode parent, string value ) { 2094XmlNode n = parent.FirstChild; 2112internal XmlNode SafeFirstChild( XmlNode n ) { 2121internal XmlNode SafeNextSibling( XmlNode n ) { 2130internal XmlNode SafePreviousSibling( XmlNode n ) { 2363private bool IsConnected( XmlNode node ) { 2392private void OnNodeInsertedInTree( XmlNode node ) { 2425private void OnNodeInsertedInFragment( XmlNode node ) { 2567private void OnNonRowElementInsertedInTree( XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList ) { 2581private void OnNonRowElementInsertedInFragment( XmlNode node, XmlBoundElement rowElement, ArrayList rowElemList ) { 2658protected override XPathNavigator CreateNavigator(XmlNode node) { 2663XmlNode parent = node.ParentNode; 2673XmlNode prevSib = node.PreviousSibling; 2684private void AssertLiveRows( XmlNode node ) { 2703private void AssertNonLiveRows( XmlNode node ) {

18private XmlNode _node; 61private XPathNodeType DecideXPNodeTypeForTextNodes( XmlNode node ) { 83private XPathNodeType ConvertNodeType( XmlNode node ) { 106internal XPathNodePointer( DataDocumentXPathNavigator owner, XmlDataDocument doc, XmlNode node ) 114private XPathNodePointer( DataDocumentXPathNavigator owner, XmlDataDocument doc, XmlNode node, DataColumn c, bool bOnValue, XmlBoundElement parentOfNS ) { 285XmlNode parent = this._node.ParentNode; 288XmlNode n = _doc.SafeNextSibling(this._node); 355XmlNode curNode = this._node; 443private void MoveTo( XmlNode node ) { 454private void MoveTo( XmlNode node, DataColumn column, bool _fOnValue ) { 465private bool IsFoliated( XmlNode node ) { 568XmlNode n = _node.Attributes.GetNamedItem(localName, namespaceURI); 630private bool IsValidChild( XmlNode parent, XmlNode child ) { 654private bool IsValidChild( XmlNode parent, DataColumn c ) { 688XmlNode n = _doc.SafeFirstChild( _node ); 695XmlNode n = _node; 696XmlNode parent = _node.ParentNode; 733XmlNode n = _node; 734XmlNode parent = _node.ParentNode; 768XmlNode parent = null; 792XmlNode n = _doc.SafeFirstChild( parent ); 828XmlNode n = _doc.SafeFirstChild( _node ); 867XmlNode n = _doc.SafeFirstChild( _node ); 899XmlNode n = null; 913private XmlNode GetParent( XmlNode node ) { 927XmlNode node = this._node; 928XmlNode parent = this._node; 966private static XmlNode GetRoot( XmlNode node, ref int depth ) { 969XmlNode curNode = node; 970XmlNode parent = ( ( curNode.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode).OwnerElement ) : ( curNode.ParentNode ) ); 985XmlNode curNode1 = null, curNode2 = null; 1057XmlNode root1 = XPathNodePointer.GetRoot( curNode1, ref depth1 ); 1058XmlNode root2 = XPathNodePointer.GetRoot( curNode2, ref depth2 ); 1079XmlNode parent1 = GetParent(curNode1); 1080XmlNode parent2 = GetParent(curNode2); 1081XmlNode nextNode = null; 1103internal XmlNode Node { 1127bool IXmlDataVirtualNode.IsOnNode( XmlNode nodeToCheck ) { 1139void IXmlDataVirtualNode.OnFoliated( XmlNode foliatedNode ) { 1158XmlNode n = null; 1232XmlNode node = _node; 1269XmlNode node = this._node; 1363XmlNode node = this._node; 1393XmlNode node = null; 1397node = (XmlNode)be; 1411XmlNode node = this._node;

101foreach (XmlNode propertyNode in connectionProperties) 132XmlNode importedElement = outputXmlDoc.ImportNode(xmlElement, true);

435XmlNode node = document.SelectSingleNode("/ds:ReferenceGroup/ds:Metadata/ds:MetadataFile", NamespaceManager); 472foreach (XmlNode p in parameters)

41foreach (XmlNode node in customTypeElement.ElementAsXml.ChildNodes)

72foreach (XmlNode node in customConfigElement.ChildNodes) 79var thumbprintAttribute = childElement.Attributes.GetNamedItem(ConfigurationStrings.Thumbprint); 80var nameAttribute = childElement.Attributes.GetNamedItem(ConfigurationStrings.Name);

47private bool CompareNodes(XmlNode originalNode, XmlNode newNode)

90internal static void OnUnexpectedChildNodeError(XmlElement parent, XmlNode n)

260foreach (XmlNode node in nodeList)

786type = typeof(XmlNode[]); 871else if (type == typeof(XmlElement) || type == typeof(XmlNode[])) 995dataContract = new XmlDataContract(typeof(XmlNode[]));

297IList<XmlNode> xmlChildNodes; 311internal IList<XmlNode> XmlChildNodes

618XmlNode wrapperElement = XmlObjectSerializerReadContext.CreateWrapperXmlElement(dataNode.OwnerDocument,

674typeOfXmlNodeArray = typeof(XmlNode[]);

810appInfo.Markup = new XmlNode[1] { annotationElement }; 815static XmlSchemaAnnotation GetSchemaAnnotation(params XmlNode[] nodes)

1039XmlNode emitDefaultValueAttribute = defaultValueElement.Attributes.GetNamedItem(Globals.EmitDefaultValueAttribute); 1052XmlNode nameAttribute = actualTypeElement.Attributes.GetNamedItem(Globals.ActualTypeNameAttribute); 1056XmlNode nsAttribute = actualTypeElement.Attributes.GetNamedItem(Globals.ActualTypeNamespaceAttribute); 1255foreach (XmlNode xmlNode in appInfo.Markup) 1283foreach (XmlNode xmlNode in appInfo.Markup) 1298XmlNode nameAttribute = typeElement.Attributes.GetNamedItem(Globals.GenericNameAttribute); 1302XmlNode nsAttribute = typeElement.Attributes.GetNamedItem(Globals.GenericNamespaceAttribute); 1311foreach (XmlNode childNode in typeElement.ChildNodes) 1319XmlNode nestedLevelAttribute = argumentElement.Attributes.GetNamedItem(Globals.GenericParameterNestedLevelAttribute); 1333XmlNode typeNestedLevelsAttribute = typeElement.Attributes.GetNamedItem(Globals.GenericParameterNestedLevelAttribute); 1426XmlNode child = xmlElement.FirstChild; 1443XmlNode[] markup = appInfo.Markup;

907IList<XmlNode> xmlChildNodes = null; 931xmlChildNodes = new List<XmlNode>(); 952IList<XmlNode> xmlChildNodes = new List<XmlNode>(); 992XmlNode childNode = Document.ReadNode(xmlReader.UnderlyingReader); 1037internal XmlReaderDelegator CreateReaderOverChildNodes(IList<XmlAttribute> xmlAttributes, IList<XmlNode> xmlChildNodes) 1039XmlNode wrapperElement = CreateWrapperXmlElement(Document, xmlAttributes, xmlChildNodes, null, null, null); 1046internal static XmlNode CreateWrapperXmlElement(XmlDocument document, IList<XmlAttribute> xmlAttributes, IList<XmlNode> xmlChildNodes, string prefix, string localName, string ns) 1050XmlNode wrapperElement = document.CreateElement(prefix, localName, ns);

480XmlNode[] xmlNodes = obj as XmlNode[]; 482foreach (XmlNode xmlNode in xmlNodes) 712IList<XmlNode> xmlChildNodes = dataNode.XmlChildNodes; 715foreach (XmlNode node in xmlChildNodes)

16public static XmlNode[] ReadNodes(XmlReader xmlReader) 21List<XmlNode> nodeList = new List<XmlNode>(); 28XmlNode node = doc.ReadNode(xmlReader); 42XmlNode node = doc.ReadNode(xmlReader); 60public static void WriteNodes(XmlWriter xmlWriter, XmlNode[] nodes)

107foreach (XmlNode node in parent.ChildNodes)

39XmlNode currentNode = oneWayAssertion.ChildNodes[i];

437foreach (XmlNode node in child.ChildNodes) 533foreach (XmlNode node in rst.RequestSecurityTokenXml.ChildNodes)

93static bool Is11Assertion(XmlNode node, string assertion) 98static bool IsElement(XmlNode node, string ns, string assertion) 111static bool IsFeb2005Assertion(XmlNode node, string assertion) 123XmlNode currentNode = SkipToNode(assertionChildren); 176XmlNode currentNode = SkipToNode(nodes); 207static void ProcessWsrm11Policy(MetadataImporter importer, XmlNode node, ReliableSessionBindingElement settings) 242static TimeSpan ReadMillisecondsAttribute(XmlNode wsrmNode, bool convertToTimeSpan) 318static XmlNode SkipToNode(IEnumerator nodes) 322XmlNode currentNode = (XmlNode)nodes.Current; 333static XmlElement ThrowIfNotPolicyElement(XmlNode node, ReliableMessagingVersion reliableMessagingVersion) 452XmlNode policyNode = SkipToNode(policyNodes);

373if ((elem) is System.Xml.XmlNode || elem == null) 375WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true);

61IEnumerable<IEnumerable<XmlElement>> ReadNode(XmlNode node, XmlElement contextAssertion, YieldLimiter yieldLimiter) 141foreach (XmlNode child in element.ChildNodes) 164foreach (XmlNode child in element.ChildNodes) 243internal static NodeType GetNodeType(XmlNode node)

865XmlNode iNode = XmlDoc.ImportNode(assertion, true);

160XmlNode policyId = policyElement.Attributes.GetNamedItem(MetadataStrings.Wsu.Attributes.Id, MetadataStrings.Wsu.NamespaceUri); 198XmlNode policyReference = policyReferenceElement.Attributes.GetNamedItem(MetadataStrings.WSPolicy.Attributes.URI);

1139foreach (XmlNode node in addressingAssertion.ChildNodes)

1016(!isArray && typeof(IEnumerable).IsAssignableFrom(member.MemberType) && member.MemberType != typeof(string) && !typeof(XmlNode).IsAssignableFrom(member.MemberType) && !typeof(IXmlSerializable).IsAssignableFrom(member.MemberType)))

120List<XmlNode> nodesToRemove = new List<XmlNode>(2); 123XmlNode child = (rstrClone.ChildNodes[i]);

424foreach (XmlNode node in secondaryParameter.ChildNodes) 521foreach (XmlNode innerNode in parameter.ChildNodes) 855XmlNode claimType = claimTypeElement.Attributes.GetNamedItem("Uri"); 896foreach (XmlNode node in requestParameter.ChildNodes)

349foreach (XmlNode node in issuedTokenXml.ChildNodes)

317foreach (XmlNode node in assertion.ChildNodes) 425foreach (XmlNode node in assertion.ChildNodes) 2324foreach (XmlNode node in assertion.ChildNodes) 2401foreach (XmlNode node in assertion.ChildNodes) 2406foreach (XmlNode p in node.ChildNodes)

92foreach (XmlNode node in assertion.ChildNodes) 103foreach (XmlNode node in policyElement.ChildNodes)

1419XmlNode skiNode; 1524foreach (XmlNode node in element.ChildNodes)

59XmlNode child = parent.ChildNodes[i]; 91XmlNode child = parent.ChildNodes[i]; 215internal static void OnUnexpectedChildNodeError(XmlElement parent, XmlNode n)

484internal override void ProcessBrowserNode(XmlNode node, BrowserTree browserTree) {

2661XmlNode root = doc.DocumentElement;

24private XmlNode _root; 178XmlNode dependenciesNode = (XmlNode)childEnumerator.Current; 199private ArrayList ReadDependencies(XmlNode parent, string tagName) { 205XmlNode dependencyNode = (XmlNode)childEnumerator.Current;

282internal virtual void ProcessBrowserNode(XmlNode node, BrowserTree browserTree) { 457XmlNode rootNode = doc.DocumentElement; 467foreach (XmlNode node in rootNode.ChildNodes) { 569XmlNode rootNode = doc.DocumentElement; 578foreach (XmlNode node in rootNode.ChildNodes) {

93private XmlNode _node; 100internal BrowserDefinition(XmlNode node) : this(node, false) { 103internal BrowserDefinition(XmlNode node, bool isDefaultBrowser) { 188foreach(XmlNode child in node.ChildNodes) { 339internal XmlNode XmlNode { 351private void DisallowNonMatchAttribute(XmlNode node) { 359private void HandleMissingMatchAndNonMatchError(XmlNode node) { 376internal void ProcessIdentificationNode(XmlNode node, BrowserCapsElementType elementType) { 382foreach(XmlNode child in node.ChildNodes) { 465internal void ProcessCaptureNode(XmlNode node, BrowserCapsElementType elementType) { 468foreach(XmlNode child in node.ChildNodes) { 505internal void ProcessCapabilitiesNode(XmlNode node) { 506foreach(XmlNode child in node.ChildNodes) { 528internal void ProcessControlAdaptersNode(XmlNode node) { 530foreach(XmlNode child in node.ChildNodes) { 557private static Type CheckType(string typeName, Type baseType, XmlNode child) {

31XmlNode node, bool checkAptcaBit, bool ignoreCase) { 89internal static Type GetType(string typeName, XmlNode node) { 93internal static Type GetType(string typeName, XmlNode node, bool ignoreCase) {

11internal GatewayDefinition(XmlNode node) : base(node) {

33private static XmlNode GetAndRemoveAttribute(XmlNode node, string attrib, bool fRequired) { 34XmlNode a = node.Attributes.RemoveNamedItem(attrib); 46private static XmlNode GetAndRemoveStringAttributeInternal(XmlNode node, string attrib, bool fRequired, ref string val) { 47XmlNode a = GetAndRemoveAttribute(node, attrib, fRequired); 55internal static XmlNode GetAndRemoveStringAttribute(XmlNode node, string attrib, ref string val) { 59internal static XmlNode GetAndRemoveRequiredStringAttribute(XmlNode node, string attrib, ref string val) { 63internal static XmlNode GetAndRemoveNonEmptyStringAttribute(XmlNode node, string attrib, ref string val) { 67internal static XmlNode GetAndRemoveRequiredNonEmptyStringAttribute(XmlNode node, string attrib, ref string val) { 71private static XmlNode GetAndRemoveNonEmptyStringAttributeInternal(XmlNode node, string attrib, bool fRequired, ref string val) { 72XmlNode a = GetAndRemoveStringAttributeInternal(node, attrib, fRequired, ref val); 83private static XmlNode GetAndRemoveBooleanAttributeInternal(XmlNode node, string attrib, bool fRequired, ref bool val) { 84XmlNode a = GetAndRemoveAttribute(node, attrib, fRequired); 102internal static XmlNode GetAndRemoveBooleanAttribute(XmlNode node, string attrib, ref bool val) { 106private static XmlNode GetAndRemoveIntegerAttributeInternal(XmlNode node, string attrib, bool fRequired, ref int val) { 107XmlNode a = GetAndRemoveAttribute(node, attrib, fRequired); 128private static XmlNode GetAndRemovePositiveAttributeInternal(XmlNode node, string attrib, bool fRequired, ref int val) { 129XmlNode a = GetAndRemoveIntegerAttributeInternal(node, attrib, fRequired, ref val); 141internal static XmlNode GetAndRemovePositiveIntegerAttribute(XmlNode node, string attrib, ref int val) { 146private static XmlNode GetAndRemoveTypeAttributeInternal(XmlNode node, string attrib, bool fRequired, ref Type val) { 147XmlNode a = GetAndRemoveAttribute(node, attrib, fRequired); 156internal static XmlNode GetAndRemoveTypeAttribute(XmlNode node, string attrib, ref Type val) { 160internal static void CheckForbiddenAttribute(XmlNode node, string attrib) { 169internal static void CheckForUnrecognizedAttributes(XmlNode node) { 183internal static string RemoveAttribute(XmlNode node, string name) { 185XmlNode attribute = node.Attributes.RemoveNamedItem(name); 195internal static string RemoveRequiredAttribute(XmlNode node, string name) { 199internal static string RemoveRequiredAttribute(XmlNode node, string name, bool allowEmpty) { 200XmlNode attribute = node.Attributes.RemoveNamedItem(name); 224internal static void CheckForNonCommentChildNodes(XmlNode node) { 225foreach (XmlNode childNode in node.ChildNodes) { 234internal static void ThrowUnrecognizedElement(XmlNode node) { 241internal static void CheckAssignableType(XmlNode node, Type baseType, Type type) {

45public object Create(object parent, object configurationContext, XmlNode section) { 105static CapabilitiesRule RuleFromElement(ParseState parseState, XmlNode element) { 172static ArrayList RuleListFromElement(ParseState parseState, XmlNode node, bool top) { 175foreach (XmlNode child in node.ChildNodes) { 229static void ProcessFile(ArrayList fileList, XmlNode node) { 232XmlNode attr = HandlerBase.GetAndRemoveRequiredStringAttribute(node, "src", ref filename); 244static void ProcessResult(HttpCapabilitiesDefaultProvider capabilitiesEvaluator, XmlNode node) { 253XmlNode attribute = HandlerBase.GetAndRemoveTypeAttribute(node, "type", ref resultType); 307XmlNode srcAttribute = (XmlNode)pair0.Second; 323XmlNode section; 346e, (XmlNode)pair.Second); 396static void AppendLines(ArrayList setlist, String text, XmlNode node) {

27internal ProtocolsConfiguration(XmlNode section) { 33foreach (XmlNode child in section.ChildNodes) { 79private bool IsIgnorableAlsoCheckForNonElement(XmlNode node) {

45public object Create(Object parent, Object configContextObj, XmlNode section) {

229XmlNode node;

2735internal static void FailIfNoAPTCABit(Type t, XmlNode node) {

602XmlNode elem = doc.DocumentElement.FirstChild; 607XmlNode prop = elem.FirstChild;

28private XmlNode _node; 34public XmlDataSourceNodeDescriptor(XmlNode node) {

43XmlNode root = _owner.GetXmlDocument(); 73foreach (XmlNode node in _nodes) { 85foreach (XmlNode node in _nodes) {

42XmlNode root = _owner.GetXmlDocument(); 46XmlNode node = root.SelectSingleNode(_viewPath);

46foreach (XmlNode node in _nodeList) {

28private XmlNode _item; 35internal XmlHierarchyData(XmlHierarchicalEnumerable parent, XmlNode item) { 44private string CreateRecursivePath(XmlNode node) { 54private string FindNodePosition(XmlNode node) { 121XmlNode parentNode = _item.ParentNode;

165private void AddNodeInternal(SiteMapNode node, SiteMapNode parentNode, XmlNode xmlNode) { 280XmlNode node = null; 281foreach (XmlNode siteMapMode in document.ChildNodes) { 297XmlNode topElement = null; 298foreach (XmlNode subNode in node.ChildNodes) { 362XmlNode xmlNode = (XmlNode)queue.Dequeue(); 640private SiteMapNode GetNodeFromSiteMapFile(XmlNode xmlNode, VirtualPath siteMapFile) { 669private void HandleResourceAttribute(XmlNode xmlNode, ref NameValueCollection collection, 724private SiteMapNode GetNodeFromXmlNode(XmlNode xmlNode, Queue queue) { 808foreach (XmlNode subNode in xmlNode.ChildNodes) {

1434virtual protected void SerializeObject(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1469 XmlNode xmlNode = xmlDocument.CreateElement(elementName); 1601internal void SerializeDataPoint(object objectToSerialize, XmlNode xmlParentNode, XmlDocument xmlDocument) 1604XmlNode xmlNode = xmlDocument.CreateElement(GetObjectName(objectToSerialize)); 1663 virtual protected void SerializeCollection(object objectToSerialize, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1669 XmlNode xmlNode = xmlDocument.CreateElement(elementName); 1695 virtual protected void SerializeProperty(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1815 private void RemoveEmptyChildNodes(XmlNode xmlNode) 1824 XmlNode currentNode = xmlNode.ChildNodes[nodeIndex]; 1995 virtual internal int DeserializeObject(object objectToDeserialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 2036 XmlNode listItemNode = null; 2039 foreach(XmlNode childNode in xmlParentNode.ChildNodes) 2089 foreach(XmlNode childNode in xmlParentNode.ChildNodes)

55typeof(XmlNode[]), 504string child1Name = differentChild1 != null ? ((XmlNode)differentChild1).LocalName : String.Empty; 505string child2Name = differentChild2 != null ? ((XmlNode)differentChild2).LocalName : String.Empty;

186XmlNode child = xmlElement.FirstChild; 260XmlNode nameAttribute = actualTypeElement.Attributes.GetNamedItem(ActualTypeNameAttribute); 265XmlNode nsAttribute = actualTypeElement.Attributes.GetNamedItem(ActualTypeNamespaceAttribute); 277XmlNode[] markup = appInfo.Markup;

17private XmlNode _currentNode = null; 22internal /*public*/ XmlNode Node 35private XmlNode GetAndRemoveAttribute(String attributeName, bool required) 37XmlNode attibuteNode = _currentNode.Attributes.RemoveNamedItem(attributeName); 55XmlNode attributeNode = GetAndRemoveAttribute(attributeName, required);

25XmlNode node) 30protected object Create(Object parent, Object context, XmlNode node) { 49foreach(XmlNode child in node.ChildNodes)

134internal void FixupDeviceConfigInheritance(XmlNode configNode)

119XmlNode filters = FindFilterSection(Document, false); 126foreach(XmlNode childNode in filters.ChildNodes) 157XmlNode filters = FindFilterSection(Document, false); 162private XmlElement FindXmlNode(XmlNode node, string name) { 166foreach (XmlNode child in node.ChildNodes) { 178XmlNode configSection = FindXmlNode(document, "configuration"); 238private XmlNode _xmlNode = null; 258XmlNode xmlNode 361XmlNode filters = _webConfig.FindFilterSection(_webConfig.Document, false);

291internal /*public*/ void FixupInheritance(IndividualDeviceConfig referrer, XmlNode configNode)

26protected Object Create(Object parent, Object context, XmlNode input) 38foreach (XmlNode attribute in attributes) 68foreach(XmlNode nextNode in input) 91foreach(XmlNode currentChild in nextNode.ChildNodes) 212XmlNode input) 244Object IConfigurationSectionHandler.Create(Object parent, Object context, XmlNode input) {

28if (typeof(XmlNode).IsAssignableFrom(ReflectionContext.Method.ReturnType)) {

468XmlNode child = documentation.FirstChild; 470XmlNode sibling = child.NextSibling;

41if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 42WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 51if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 52WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 129if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 130WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 139if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 140WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 185if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 186WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 208if ((elem) is System.Xml.XmlNode || elem == null) { 209WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 319if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 320WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 342if ((elem) is System.Xml.XmlNode || elem == null) { 343WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 394if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 395WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 417if ((elem) is System.Xml.XmlNode || elem == null) { 418WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 471if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 472WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 491if ((elem) is System.Xml.XmlNode || elem == null) { 492WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 613if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 614WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 651if ((elem) is System.Xml.XmlNode || elem == null) { 652WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 740if ((elem) is System.Xml.XmlNode || elem == null) { 741WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 1089if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1090WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1133if ((elem) is System.Xml.XmlNode || elem == null) { 1134WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 1386if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1387WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1396if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1397WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1444if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1445WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1454if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1455WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1521if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1522WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1531if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1532WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1569if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1570WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1579if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1580WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1617if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1618WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1627if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1628WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1664if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1665WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1674if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1675WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1721if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1722WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1731if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1732WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1767if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 1768WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 1777if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 1778WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 1972global::System.Xml.XmlNode[] a = (global::System.Xml.XmlNode[])o.@Markup; 1975global::System.Xml.XmlNode ai = (global::System.Xml.XmlNode)a[ia]; 1979if ((elem) is System.Xml.XmlNode || elem == null) { 1980WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 1986else if (ai is global::System.Xml.XmlNode) { 1987((global::System.Xml.XmlNode)ai).WriteTo(Writer); 2019global::System.Xml.XmlNode[] a = (global::System.Xml.XmlNode[])o.@Markup; 2022global::System.Xml.XmlNode ai = (global::System.Xml.XmlNode)a[ia]; 2026if ((elem) is System.Xml.XmlNode || elem == null) { 2027WriteElementLiteral((System.Xml.XmlNode)elem, @"", null, false, true); 2033else if (ai is global::System.Xml.XmlNode) { 2034((global::System.Xml.XmlNode)ai).WriteTo(Writer); 4086if ((o.@DocumentationElement) is System.Xml.XmlNode || o.@DocumentationElement == null) { 4087WriteElementLiteral((System.Xml.XmlNode)o.@DocumentationElement, @"documentation", @"http://schemas.xmlsoap.org/wsdl/", false, true); 4096if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { 4097WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); 7158global::System.Xml.XmlNode[] a_2 = null; 7177o.@Markup = (global::System.Xml.XmlNode[])ShrinkArray(a_2, ca_2, typeof(global::System.Xml.XmlNode), true); 7186a_2 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_2, ca_2, typeof(global::System.Xml.XmlNode)); a_2[ca_2++] = (global::System.Xml.XmlNode)ReadXmlNode(false); 7192a_2 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_2, ca_2, typeof(global::System.Xml.XmlNode)); a_2[ca_2++] = (global::System.Xml.XmlNode)Document.CreateTextNode(Reader.ReadString()); 7200o.@Markup = (global::System.Xml.XmlNode[])ShrinkArray(a_2, ca_2, typeof(global::System.Xml.XmlNode), true); 7219global::System.Xml.XmlNode[] a_3 = null; 7242o.@Markup = (global::System.Xml.XmlNode[])ShrinkArray(a_3, ca_3, typeof(global::System.Xml.XmlNode), true); 7251a_3 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_3, ca_3, typeof(global::System.Xml.XmlNode)); a_3[ca_3++] = (global::System.Xml.XmlNode)ReadXmlNode(false); 7257a_3 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_3, ca_3, typeof(global::System.Xml.XmlNode)); a_3[ca_3++] = (global::System.Xml.XmlNode)Document.CreateTextNode(Reader.ReadString()); 7265o.@Markup = (global::System.Xml.XmlNode[])ShrinkArray(a_3, ca_3, typeof(global::System.Xml.XmlNode), true);

713XmlNode detail = null;

33System.Xml.XmlNode detail; 138public SoapException(string message, XmlQualifiedName code, string actor, System.Xml.XmlNode detail) : base(message) { 148public SoapException(string message, XmlQualifiedName code, string actor, System.Xml.XmlNode detail, Exception innerException) : base(message, innerException) { 167public SoapException(string message, XmlQualifiedName code, string actor, string role, System.Xml.XmlNode detail, SoapFaultSubCode subCode, Exception innerException) : base(message, innerException) { 179public SoapException(string message, XmlQualifiedName code, string actor, string role, string lang, System.Xml.XmlNode detail, SoapFaultSubCode subCode, Exception innerException) : base(message, innerException) { 224public System.Xml.XmlNode Detail { 301string actor, string role, System.Xml.XmlNode detail,

376foreach (XmlNode referenceNode in referenceNodes) { 383XmlNode transformsNode = reference.SelectSingleNode("ds:Transforms", nsm); 425XmlNode transformsNode = referenceNode.SelectSingleNode("ds:Transforms", nsm); 557XmlNode assemblyIdentityNode = m_manifestDom.SelectSingleNode("asm:assembly/asm:assemblyIdentity", nsm); 815XmlNode signatureNode = manifestDom.SelectSingleNode("asm:assembly/ds:Signature", nsm);

613foreach (XmlNode referenceNode in referenceNodes) 624XmlNode transformsNode = GetSingleNode(reference, "ds:Transforms", nsm); 675XmlNode transformsNode = GetSingleNode(referenceNode, "ds:Transforms", nsm); 1158XmlNode assemblyIdentityNode = GetSingleNode(m_manifestDom, "asm:assembly/asm:assemblyIdentity", nsm); 1451XmlNode signatureNode = GetSingleNode(manifestDom, "asm:assembly/ds:Signature", nsm); 2014private static XmlNode GetSingleNode(XmlNode parentNode,

137private string GetAttributeValue(XmlNode node, string attribute) { 145private int GetAttributeValue(XmlNode node, string attribute, int valueIfNotFound) { 161foreach (XmlNode controlXmlNode in controlXmlFragments) { 183foreach (XmlNode styleXmlNode in controlXmlFragments) {

1434virtual protected void SerializeObject(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1469 XmlNode xmlNode = xmlDocument.CreateElement(elementName); 1601internal void SerializeDataPoint(object objectToSerialize, XmlNode xmlParentNode, XmlDocument xmlDocument) 1604XmlNode xmlNode = xmlDocument.CreateElement(GetObjectName(objectToSerialize)); 1663 virtual protected void SerializeCollection(object objectToSerialize, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1669 XmlNode xmlNode = xmlDocument.CreateElement(elementName); 1695 virtual protected void SerializeProperty(object objectToSerialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 1815 private void RemoveEmptyChildNodes(XmlNode xmlNode) 1824 XmlNode currentNode = xmlNode.ChildNodes[nodeIndex]; 1995 virtual internal int DeserializeObject(object objectToDeserialize, object parent, string elementName, XmlNode xmlParentNode, XmlDocument xmlDocument) 2036 XmlNode listItemNode = null; 2039 foreach(XmlNode childNode in xmlParentNode.ChildNodes) 2089 foreach(XmlNode childNode in xmlParentNode.ChildNodes)

22object IConfigurationSectionHandler.Create(object parent, object configContext, XmlNode section) 31foreach (XmlNode targetFx in section.ChildNodes) 45foreach (XmlNode authorizedTypeNode in targetFx.ChildNodes)

45XmlNode startNode; 46XmlNode currentNode; 50XmlNode[] nodeSequenceToValidate; 88public bool Validate(XmlNode nodeToValidate) { 163XmlNode node = startNode; 242private void ValidateNode(XmlNode node) { 255for (XmlNode child = node.FirstChild; child != null; child = child.NextSibling) { 335for (XmlNode child = elementNode.FirstChild; child != null; child = child.NextSibling) { 444XmlNode currentNode = elementToValidate; 449XmlNode parentNode = currentNode.ParentNode; 492nodeSequenceToValidate = new XmlNode[4]; 495XmlNode[] newNodeSequence = new XmlNode[nodeSequenceToValidate.Length * 2]; 532XmlNode node = nodeSequenceToValidate[i]; 641private void ValidateChildrenTillNextAncestor(XmlNode parentNode, XmlNode childToStopAt) { 642XmlNode child;

57XmlNode start; // context node 61XmlNode write; // current node 62List<XmlNode> fragment; // top level node cache 65XmlNode end; // context for replace 67public DocumentXmlWriter(DocumentXmlWriterType type, XmlNode start, XmlDocument document) { 73fragment = new List<XmlNode>(); 104public XmlNode EndNode { 113XmlNode node = document.CreateXmlDeclaration("1.0", string.Empty, standalone == XmlStandalone.Yes ? "yes" : "no"); 122XmlNode node = document.CreateXmlDeclaration(version, encoding, standalone); 140XmlNode node = document.CreateDocumentType(name, pubid, sysid, subset); 146XmlNode node = document.CreateElement(prefix, localName, ns); 195XmlNode node = document.CreateTextNode(string.Empty); 233XmlNode node = document.CreateTextNode(string.Empty); 242XmlNode node = document.CreateCDataSection(text); 249XmlNode node = document.CreateComment(text); 256XmlNode node = document.CreateProcessingInstruction(name, text); 262XmlNode node = document.CreateEntityReference(name); 275XmlNode node = document.CreateWhitespace(text); 283XmlNode node = document.CreateTextNode(text); 314XmlNode parent = start.ParentNode; 378XmlNode parent = start.ParentNode; 391XmlNode fragment0 = fragment[0]; 415void AddAttribute(XmlAttribute attr, XmlNode parent) { 428void AddChild(XmlNode node, XmlNode parent) { 443XmlNode parent = start.ParentNode;

19private XmlNode source; // navigator position 23public DocumentXPathNavigator(XmlDocument document, XmlNode node) { 44XmlNode node = source; 45XmlNode end; 176XmlNode nextSibling = NextSibling(source); 306XmlNode node = source; 589XmlNode sibling = NextSibling(source); 601XmlNode parent = ParentNode(sibling); 614XmlNode sibling = PreviousSibling(source); 629XmlNode parent = ParentNode(sibling); 648XmlNode parent = ParentNode(source); 652XmlNode sibling = FirstChild(parent); 665XmlNode child; 695XmlNode parent = ParentNode(source); 714XmlNode parent = source.ParentNode; 757XmlNode child = FirstChild(source); 778XmlNode child = FirstChild(source); 797XmlNode pastFollowing = null; 814XmlNode following = source; 822XmlNode firstChild = following.FirstChild; 828XmlNode nextSibling = following.NextSibling; 834XmlNode parent = following.ParentNode; 857XmlNode pastFollowing = null; 878XmlNode following = source; 894XmlNode firstChild = following.FirstChild; 900XmlNode nextSibling = following.NextSibling; 906XmlNode parent = following.ParentNode; 927XmlNode sibling = NextSibling(source); 945XmlNode sibling = NextSibling(source); 974XmlNode child; 1053private static XmlNode OwnerNode(XmlNode node) { 1054XmlNode parent = node.ParentNode; 1065private static int GetDepth(XmlNode node) { 1067XmlNode owner = OwnerNode(node); 1077private XmlNodeOrder Compare( XmlNode node1, XmlNode node2 ) { 1109XmlNode nextNode = node1.NextSibling; 1139XmlNode node1 = this.source; 1140XmlNode node2 = that.source; 1142XmlNode parent1 = OwnerNode(node1); 1143XmlNode parent2 = OwnerNode(node2); 1194XmlNode IHasXmlNode.GetNode() { return source; } 1270XmlNode node = source; 1338XmlNode node = this.source; 1339XmlNode end = that.source; 1387XmlNode node = this.source; 1388XmlNode end = that.source; 1397XmlNode parent = OwnerNode(attribute); 1429XmlNode parent = OwnerNode(node); 1438XmlNode node = source; 1439XmlNode end = node; 1447XmlNode parent = OwnerNode(attribute); 1489internal static void DeleteToFollowingSibling(XmlNode node, XmlNode end) { 1490XmlNode parent = node.ParentNode; 1500XmlNode temp = node; 1507private static XmlNamespaceManager GetNamespaceManager(XmlNode node, XmlDocument document) { 1533internal void ResetPosition(XmlNode node) { 1579XmlNode text = PreviousText(source); 1586private XmlNode ParentNode(XmlNode node) { 1587XmlNode parent = node.ParentNode; 1595private XmlNode ParentNodeTail(XmlNode parent) { 1603private XmlNode FirstChild(XmlNode node) { 1604XmlNode child = node.FirstChild; 1612private XmlNode FirstChildTail(XmlNode child) { 1620private XmlNode NextSibling(XmlNode node) { 1621XmlNode sibling = node.NextSibling; 1629private XmlNode NextSiblingTail(XmlNode node, XmlNode sibling) { 1645private XmlNode PreviousSibling(XmlNode node) { 1646XmlNode sibling = node.PreviousSibling; 1654private XmlNode PreviousSiblingTail(XmlNode node, XmlNode sibling) { 1670private XmlNode PreviousText(XmlNode node) { 1671XmlNode text = node.PreviousText; 1679private XmlNode PreviousTextTail(XmlNode node, XmlNode text) { 1686XmlNode sibling = node.PreviousSibling; 1712internal static bool IsFollowingSibling(XmlNode left, XmlNode right) { 1725private static bool IsDescendant(XmlNode top, XmlNode bottom) { 1727XmlNode parent = bottom.ParentNode; 1746private static bool IsValidChild(XmlNode parent, XmlNode child) { 1776private XmlNode TextStart(XmlNode node) { 1777XmlNode start; 1788private XmlNode TextEnd(XmlNode node) { 1789XmlNode end; 1831protected abstract bool Match( XmlNode node ); 1864XmlNode node = (XmlNode)nav.UnderlyingObject; 1876Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1885protected override bool Match( XmlNode node ) { 1904XmlNode node = (XmlNode)nav.UnderlyingObject; 1918Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1929protected override bool Match( XmlNode node ) { 1950XmlNode node = (XmlNode)nav.UnderlyingObject; 1965Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1983protected override bool Match( XmlNode node ) { 2006XmlNode node = (XmlNode)nav.UnderlyingObject;

47public override XmlNode CloneNode(bool deep) { 57public override XmlNode ParentNode { 142internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc) { 189public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) { 190XmlNode node; 202public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) { 203XmlNode node; 215public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) { 216XmlNode node; 228public override XmlNode RemoveChild(XmlNode oldChild) { 229XmlNode node; 241public override XmlNode PrependChild(XmlNode newChild) { 242XmlNode node; 254public override XmlNode AppendChild(XmlNode newChild) { 255XmlNode node; 294for (XmlNode node = FirstChild; node != null; node = node.NextSibling) { 307internal override void SetParent(XmlNode node) {

16internal XmlAttributeCollection( XmlNode parent ): base( parent ) { 101public override XmlNode SetNamedItem(XmlNode node) { 110XmlNode oldNode = base.RemoveNodeAt( offset ); 253array[index] = (XmlAttribute)(((XmlNode)nodes[i]).CloneNode(true)); 256internal override XmlNode AddNode( XmlNode node ) { 259XmlNode retNode = base.AddNode( node ); 265internal override XmlNode InsertNodeAt( int i, XmlNode node ) { 266XmlNode retNode = base.InsertNodeAt(i, node); 271internal override XmlNode RemoveNodeAt( int i ) { 273XmlNode retNode = base.RemoveNodeAt( i ); 362XmlNode retNode = base.AddNode( node );

41public override XmlNode ParentNode { 50XmlNode parent = parentNode.parentNode; 62public override XmlNode CloneNode(bool deep) { 89public override XmlNode PreviousText {

46XmlNode parent = ParentNode; 84XmlNode parent = ParentNode; 101XmlNode parent = ParentNode; 127XmlNode parent = ParentNode; 154XmlNode parent = ParentNode; 170internal bool DecideXPNodeTypeForTextNodes(XmlNode node, ref XPathNodeType xnt) {

12internal XmlNode container; 13internal XmlNode child; 16internal XmlChildEnumerator( XmlNode container ) { 49internal XmlNode Current {

11private XmlNode container; 13public XmlChildNodes( XmlNode container ) { 17public override XmlNode Item( int i ) { 21for (XmlNode n = container.FirstChild; n != null; n = n.NextSibling, i--) { 31for (XmlNode n = container.FirstChild; n != null; n = n.NextSibling) {

33public override XmlNode CloneNode(bool deep) {

133public override XmlNode CloneNode(bool deep) {

247public override XmlNode CloneNode( bool deep ) { 261public override XmlNode ParentNode { 391private bool HasNodeTypeInPrevSiblings( XmlNodeType nt, XmlNode refNode ) { 395XmlNode node = null; 410private bool HasNodeTypeInNextSiblings( XmlNodeType nt, XmlNode refNode ) { 411XmlNode node = refNode; 420internal override bool CanInsertBefore( XmlNode newChild, XmlNode refChild ) { 457internal override bool CanInsertAfter( XmlNode newChild, XmlNode refChild ) { 622internal protected virtual XPathNavigator CreateNavigator(XmlNode node) { 624XmlNode parent; 693private XmlNode NormalizeText( XmlNode n ) { 694XmlNode retnode = null; 700XmlNode intnode = retnode; 782public virtual XmlNode ImportNode( XmlNode node, bool deep ) { 786private XmlNode ImportNodeInternal( XmlNode node, bool deep ) { 787XmlNode newNode = null; 855private void ImportAttributes( XmlNode fromElem, XmlNode toElem ) { 863private void ImportChildren( XmlNode fromNode, XmlNode toNode, bool deep ) { 865for ( XmlNode n = fromNode.FirstChild; n != null; n = n.NextSibling ) { 928public virtual XmlNode CreateNode( XmlNodeType type, string prefix, string name, string namespaceURI ) { 982public virtual XmlNode CreateNode( string nodeTypeString, string name, string namespaceURI ) { 988public virtual XmlNode CreateNode( XmlNodeType type, string name, string namespaceURI ) { 995public virtual XmlNode ReadNode( XmlReader reader ) { 996XmlNode node = null; 1203XmlNode n = this.FirstChild; 1239foreach( XmlNode n in this ) { 1248public void Validate(ValidationEventHandler validationEventHandler, XmlNode nodeToValidate) { 1320internal override XmlNodeChangedEventArgs GetEventArgs(XmlNode node, XmlNode oldParent, XmlNode newParent, string oldValue, string newValue, XmlNodeChangedAction action) { 1343internal XmlNodeChangedEventArgs GetInsertEventArgsForLoad( XmlNode node, XmlNode newParent ) { 1481internal override XmlNode AppendChildForLoad( XmlNode newChild, XmlDocument doc ) {

74public override XmlNode ParentNode { 101public override XmlNode CloneNode(bool deep) { 133XmlNode firstNode = FirstChild; 142internal override bool CanInsertAfter( XmlNode newChild, XmlNode refChild ) { 154internal override bool CanInsertBefore( XmlNode newChild, XmlNode refChild ) { 169foreach( XmlNode n in this ) {

57public override XmlNode CloneNode(bool deep) {

47public override XmlNode CloneNode(bool deep) { 97public override XmlNode ParentNode { 115internal override XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc) { 384XmlNode root = e; 385XmlNode n = e; 440for (XmlNode node = FirstChild; node != null; node = node.NextSibling) { 446public virtual XmlNode RemoveAttributeAt(int i) { 513public override XmlNode NextSibling { 522internal override void SetParent(XmlNode node) {

20XmlNode rootNode; 23XmlNode curElem; // if sets to rootNode, means the starting point for a new search round 30private XmlElementList( XmlNode parent) { 66internal XmlElementList( XmlNode parent, string name ): this( parent ) { 76internal XmlElementList( XmlNode parent, string localName, string namespaceURI ): this( parent ) { 97private XmlNode NextElemInPreOrder( XmlNode curNode ) { 100XmlNode retNode = curNode.FirstChild; 121private XmlNode PrevElemInPreOrder( XmlNode curNode ) { 124XmlNode retNode = curNode.PreviousSibling; 141private bool IsMatch ( XmlNode curNode ) { 159private XmlNode GetMatchingNode( XmlNode n, bool bNext ) { 161XmlNode node = n; 171private XmlNode GetNthMatchingNode( XmlNode n, bool bNext, int nCount ) { 173XmlNode node = n; 183public XmlNode GetNextNode( XmlNode n ) { 186XmlNode node = ( n == null ) ? rootNode : n; 190public override XmlNode Item(int index) { 202XmlNode node; 218XmlNode node = rootNode; 255XmlNode curElem;

32public override XmlNode CloneNode(bool deep) {

75public override XmlNode CloneNode(bool deep) { 96internal override void SetParent( XmlNode node ) { 106internal override void SetParentForLoad( XmlNode node ) { 142foreach( XmlNode n in this ) {

22public override XmlNode PreviousSibling { 24XmlNode parent = ParentNode; 26XmlNode node = parent.FirstChild; 28XmlNode nextSibling = node.NextSibling; 41public override XmlNode NextSibling { 43XmlNode parent = ParentNode;

55XmlNode node = null; 63internal XmlNode ReadCurrentNode(XmlDocument doc, XmlReader reader) { 77XmlNode n = LoadNode(true); 88private XmlNode LoadNode(bool skipOverWhitespace) { 90XmlNode parent = null; 94XmlNode node = null; 236XmlNode node; 283private void LoadAttributeValue( XmlNode parent, bool direct ) { 286XmlNode node; 320XmlNode node = direct ? LoadNodeDirect() : LoadNode(false); 403private XmlNode LoadNodeDirect() { 405XmlNode parent = null; 407XmlNode node = null; 600private XmlParserContext GetContext ( XmlNode node ) { 656internal XmlNamespaceManager ParsePartialContent( XmlNode parentNode, string innerxmltext, XmlNodeType nt) { 669XmlNode node = null; 675XmlNode node = null; 740XmlNode child = elem.FirstChild;

13internal XmlNode parent; 16internal XmlNamedNodeMap(XmlNode parent) 22public virtual XmlNode GetNamedItem(String name) { 25return (XmlNode)nodes[offset]; 30public virtual XmlNode SetNamedItem(XmlNode node) { 45public virtual XmlNode RemoveNamedItem(String name) { 61public virtual XmlNode Item(int index) { 65return (XmlNode)nodes[index]; 76public virtual XmlNode GetNamedItem(String localName, String namespaceURI) { 79return (XmlNode)nodes[offset]; 84public virtual XmlNode RemoveNamedItem(String localName, String namespaceURI) { 99XmlNode node = (XmlNode) nodes[i]; 111XmlNode node = (XmlNode) nodes[i]; 120internal virtual XmlNode AddNode( XmlNode node ) { 121XmlNode oldParent; 141internal virtual XmlNode AddNodeForLoad(XmlNode node, XmlDocument doc) { 154internal virtual XmlNode RemoveNodeAt( int i ) { 155XmlNode oldNode = (XmlNode)nodes[i]; 172internal XmlNode ReplaceNodeAt( int i, XmlNode node ) { 173XmlNode oldNode = RemoveNodeAt( i ); 178internal virtual XmlNode InsertNodeAt( int i, XmlNode node ) { 179XmlNode oldParent;

22internal XmlNode parentNode; //this pointer is reused to save the userdata information, need to prevent internal user access the pointer directly. 44public XmlNode SelectSingleNode( string xpath ) { 51public XmlNode SelectSingleNode( string xpath, XmlNamespaceManager nsmgr ) { 101public virtual XmlNode ParentNode { 132public virtual XmlNode PreviousSibling { 137public virtual XmlNode NextSibling { 158public virtual XmlNode FirstChild { 169public virtual XmlNode LastChild { 182internal bool AncestorNode(XmlNode node) { 183XmlNode n = this.ParentNode; 197XmlNode parent = ParentNode; 204public virtual XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) { 233XmlNode first = newChild.FirstChild; 234XmlNode node = first; 303public virtual XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) { 332XmlNode last = refChild; 333XmlNode first = newChild.FirstChild; 334XmlNode node = first; 336XmlNode next = node.NextSibling; 406public virtual XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) { 407XmlNode nextNode = oldChild.NextSibling; 409XmlNode node = InsertBefore( newChild, nextNode ); 414public virtual XmlNode RemoveChild(XmlNode oldChild) { 487public virtual XmlNode PrependChild(XmlNode newChild) { 492public virtual XmlNode AppendChild(XmlNode newChild) { 512XmlNode first = newChild.FirstChild; 513XmlNode node = first; 515XmlNode next = node.NextSibling; 564internal virtual XmlNode AppendChildForLoad(XmlNode newChild, XmlDocument doc) { 601internal virtual bool CanInsertBefore( XmlNode newChild, XmlNode refChild ) { 605internal virtual bool CanInsertAfter( XmlNode newChild, XmlNode refChild ) { 615public abstract XmlNode CloneNode(bool deep); 617internal virtual void CopyChildren( XmlDocument doc, XmlNode container, bool deep ) { 618for (XmlNode child = container.FirstChild; child != null; child = child.NextSibling) { 631XmlNode firstChildTextLikeNode = null; 633for ( XmlNode crtChild = this.FirstChild; crtChild != null; ) { 634XmlNode nextChild = crtChild.NextSibling; 640XmlNode winner = NormalizeWinner( firstChildTextLikeNode, crtChild ); 670private XmlNode NormalizeWinner( XmlNode firstNode, XmlNode secondNode ) { 731internal static bool HasReadOnlyParent( XmlNode n ) { 751public virtual XmlNode Clone() { 770for (XmlNode child = FirstChild; child != null; child = child.NextSibling) { 786XmlNode fc = FirstChild; 806XmlNode firstChild = FirstChild; 863XmlNode curNode = this.ParentNode; //save one while loop since if going to here, the nodetype of this node can't be document, entity and entityref 889XmlNode child = FirstChild; 890XmlNode sibling = null; 922XmlNode node = this; 987XmlNode node = this; 1039for (XmlNode n = FirstChild; n != null; n = n.NextSibling) { 1052for (XmlNode n = FirstChild; n != null; n = n.NextSibling) { 1060internal virtual void SetParent( XmlNode node ) { 1069internal virtual void SetParentForLoad( XmlNode node ) { 1085internal virtual XmlNode FindChild( XmlNodeType type ) { 1086for (XmlNode child = FirstChild; child != null; child = child.NextSibling) { 1094internal virtual XmlNodeChangedEventArgs GetEventArgs( XmlNode node, XmlNode oldParent, XmlNode newParent, string oldValue, string newValue, XmlNodeChangedAction action ) { 1118XmlNode node = this; 1142XmlNode node = this; 1178public virtual XmlNode PreviousText { 1184internal static void NestTextNodes(XmlNode prevNode, XmlNode nextNode) { 1191internal static void UnnestTextNodes(XmlNode prevNode, XmlNode nextNode) { 1202private XmlNode node; 1204public DebuggerDisplayXmlNodeProxy(XmlNode node) {

11private XmlNode node; 12private XmlNode oldParent; 13private XmlNode newParent; 17public XmlNodeChangedEventArgs( XmlNode node, XmlNode oldParent, XmlNode newParent, string oldValue, string newValue, XmlNodeChangedAction action ) { 28public XmlNode Node { get { return node; } } 30public XmlNode OldParent { get { return oldParent; } } 32public XmlNode NewParent { get { return newParent; } }

15public abstract XmlNode Item(int index); 26public virtual XmlNode this[int i] { get { return Item(i);}}

20XmlNode curNode; 21XmlNode elemNode; 22XmlNode logNode; 72public XmlNodeReaderNavigator( XmlNode node ) { 155internal XmlNode OwnerElementNode { 607curNode = (XmlNode) attr; 615curNode = (XmlNode) attr; 671XmlNode parent = curNode.ParentNode; 682XmlNode firstChild = curNode.FirstChild; 692private bool MoveToNextSibling( XmlNode node ) { 693XmlNode nextSibling = node.NextSibling; 753XmlNode node = curNode; 805XmlNode node = curNode; 844XmlNode node = curNode; 899XmlNode firstChild = curNode.FirstChild; 909XmlNode nextSibling = null; 922XmlNode parentNode = curNode.ParentNode; 969public XmlNodeReader ( XmlNode node ) {

40public override XmlNode CloneNode(bool deep) {

56XmlNode parent = ParentNode; 79public override XmlNode CloneNode(bool deep) {

43public override XmlNode ParentNode { 52XmlNode parent = parentNode.parentNode; 64public override XmlNode CloneNode(bool deep) { 106public override XmlNode PreviousText {

44public override XmlNode ParentNode { 53XmlNode parent = parentNode.parentNode; 65public override XmlNode CloneNode(bool deep) { 77XmlNode parent = parentNode; 90XmlNode parentNode = this.ParentNode; 128public override XmlNode PreviousText {

26public override XmlNode CloneNode(bool deep) { 42public override XmlNode InsertBefore(XmlNode newChild, XmlNode refChild) { 43XmlNode node = base.InsertBefore( newChild, refChild ); 48public override XmlNode InsertAfter(XmlNode newChild, XmlNode refChild) { 49XmlNode node = base.InsertAfter( newChild, refChild ); 54public override XmlNode ReplaceChild(XmlNode newChild, XmlNode oldChild) { 55XmlNode node = base.ReplaceChild( newChild, oldChild ); 60public override XmlNode RemoveChild(XmlNode oldChild) { 61XmlNode node = base.RemoveChild(oldChild); 66public override XmlNode AppendChild(XmlNode newChild) { 67XmlNode node = base.AppendChild(newChild);

43public override XmlNode ParentNode { 52XmlNode parent = parentNode.parentNode; 77public override XmlNode CloneNode(bool deep) { 106public override XmlNode PreviousText {

15List<XmlNode> list; 21this.list = new List<XmlNode>(); 36private XmlNode GetNode(XPathNavigator n) { 45XmlNode n = GetNode(nodeIterator.Current); 58public override XmlNode Item(int index) {

12XmlNode GetNode();

38XmlNode parentNode; 213XmlNode[] markup = new XmlNode[list.Count]; 236XmlNode currentNode = null;

14internal abstract void ProcessMarkup(XmlNode[] markup);

527internal override void ProcessMarkup(XmlNode[] markup) {

19XmlNode[] markup; 36public XmlNode[] Markup {

21XmlNode[] markup; 49public XmlNode[] Markup {

668private XmlNode[] markup; 754internal override void ProcessMarkup(XmlNode[] markup) { 2083builder.markup = new XmlNode[] {}; 2104builder.markup = new XmlNode[] {};

151XmlNode xmlNode; 156internal XmlNodeEventArgs(XmlNode xmlNode, int lineNumber, int linePosition, object o) {

431XmlNode[] a = (XmlNode[])o.@Markup; 434XmlNode ai = (XmlNode)a[ia]; 447XmlNode[] a = (XmlNode[])o.@Markup; 450XmlNode ai = (XmlNode)a[ia];

534else if (type == typeof(XmlNode[])) { 776else if (typeof(XmlNode).IsAssignableFrom(type)) {

1458Type targetType = typeof(IXmlSerializable).IsAssignableFrom(arrayElementType) ? arrayElementType : typeof(XmlNode).IsAssignableFrom(arrayElementType) ? arrayElementType : typeof(XmlElement); 1670Type targetType = typeof(IXmlSerializable).IsAssignableFrom(accessorType) ? accessorType : typeof(XmlNode).IsAssignableFrom(accessorType) ? accessorType : typeof(XmlElement);

1051appinfo.Markup = new XmlNode[] {e};

1108textMapping.TypeDesc = Scope.GetTypeDesc(typeof(XmlNode)); 1126mapping.TypeDesc = Scope.GetTypeDesc(makeElement ? typeof(XmlElement) : typeof(XmlNode)); 1304mapping.TypeDesc = Scope.GetTypeDesc(mixed ? typeof(XmlNode) : typeof(XmlElement)); 1417XmlNode[] nodes = ((XmlSchemaAppInfo)o).Markup; 1419foreach(XmlNode node in nodes) {

863XmlNode n = ReadXmlNode(wrapped); 879protected XmlNode ReadXmlNode(bool wrapped) { 880XmlNode node = null; 1193void UnknownNode(XmlNode unknownNode, object o, string qnames) { 1780XmlNode unknownNode = null; 1839XmlNode xmlNode = Document.ReadNode(r); 1853XmlNode[] childNodes = (XmlNode[])xmlNodeList.ToArray(typeof(XmlNode));

208else if (type == typeof(XmlNode[])) { 318else if (typeof(XmlNode[]).IsAssignableFrom(t)){ 324XmlNode[] xmlNodes = (XmlNode[])o; 663protected void WriteElementEncoded(XmlNode node, string name, string ns, bool isNullable, bool any) { 672protected void WriteElementLiteral(XmlNode node, string name, string ns, bool isNullable, bool any) { 680private void WriteElement(XmlNode node, string name, string ns, bool isNullable, bool any) { 807protected void WriteXmlAttribute(XmlNode node) { 812protected void WriteXmlAttribute(XmlNode node, object container) { 1180if (Convert.GetTypeCode(o) == TypeCode.Object && !(o is Guid) && (t != typeof(XmlQualifiedName)) && !(o is XmlNode[]) && (t != typeof(byte[]))) { 2962Writer.Write(typeof(XmlNode).FullName); 2969WriteElementCall("WriteElementLiteral", typeof(XmlNode), source, name, ns, element.IsNullable, element.Any);

1332new Type[] { typeof(XmlNode), typeof(Object) }, 1650MethodInfo XmlNode_get_Name = typeof(XmlNode).GetMethod( 1657MethodInfo XmlNode_get_NamespaceURI = typeof(XmlNode).GetMethod( 1726MethodInfo XmlNode_get_Name = typeof(XmlNode).GetMethod( 1733MethodInfo XmlNode_get_NamespaceURI = typeof(XmlNode).GetMethod( 1967ilg.IsInst(typeof(XmlNode)); 1978WriteElementCall("WriteElementLiteral", typeof(XmlNode), source, name, ns, element.IsNullable, element.Any);

183XmlNode local = nodeList[0] as XmlElement; 187XmlNode temp = local;

689XmlNode node = nodeList[0];

482internal static XmlNode GenerateManifest( 498XmlNode manifest = xDoc.CreateNode(XmlNodeType.Element, 545XmlNode manifest) 642private static XmlNode GenerateRelationshipSigningReference( 688XmlNode relationshipNode = xDoc.CreateElement(opcNamespacePrefix, XTable.Get(XTable.ID.RelationshipReferenceTagName), opcNamespace); 697XmlNode relationshipNode = xDoc.CreateElement(opcNamespacePrefix, XTable.Get(XTable.ID.RelationshipsGroupReferenceTagName), opcNamespace); 747private static XmlNode GeneratePartSigningReference( 794private static XmlNode GenerateDigestMethod( 806private static XmlNode GenerateDigestValueNode(XmlDocument xDoc, HashAlgorithm hashAlgorithm, Stream s, String transformName)