C# XPathNode类代码示例

        /// <summary>
        /// Return chain of in-scope namespace nodes for nodes of type Element.  Nodes in the chain might not
        /// have this element as their parent.  Since the xmlns:xml namespace node is always in scope, this
        /// method will never return 0 if the specified node is an element.
        /// </summary>
        public static int GetInScopeNamespaces(XPathNode[] pageElem, int idxElem, out XPathNode[] pageNmsp)
        {
            XPathDocument doc;

            // Only elements have namespace nodes
            if (pageElem[idxElem].NodeType == XPathNodeType.Element)
            {
                doc = pageElem[idxElem].Document;

                // Walk ancestors, looking for an ancestor that has at least one namespace declaration
                while (!pageElem[idxElem].HasNamespaceDecls)
                {
                    idxElem = pageElem[idxElem].GetParent(out pageElem);
                    if (idxElem == 0)
                    {
                        // There are no namespace nodes declared on ancestors, so return xmlns:xml node
                        return doc.GetXmlNamespaceNode(out pageNmsp);
                    }
                }
                // Return chain of in-scope namespace nodes
                return doc.LookupNamespaces(pageElem, idxElem, out pageNmsp);
            }
            pageNmsp = null;
            return 0;
        }

 public XPathDocumentNavigator(XPathNode[] pageCurrent, int idxCurrent, XPathNode[] pageParent, int idxParent)
 {
     this.pageCurrent = pageCurrent;
     this.pageParent = pageParent;
     this.idxCurrent = idxCurrent;
     this.idxParent = idxParent;
 }

        //-----------------------------------------------
        // Constructors
        //-----------------------------------------------

        /// <summary>
        /// Create a new navigator positioned on the specified current node.  If the current node is a namespace or a collapsed
        /// text node, then the parent is a virtualized parent (may be different than .Parent on the current node).
        /// </summary>
        public XPathDocumentNavigator(XPathNode[] pageCurrent, int idxCurrent, XPathNode[] pageParent, int idxParent) {
            Debug.Assert(pageCurrent != null && idxCurrent != 0);
            Debug.Assert((pageParent == null) == (idxParent == 0));
            this.pageCurrent = pageCurrent;
            this.pageParent = pageParent;
            this.idxCurrent = idxCurrent;
            this.idxParent = idxParent;
        }

 /// <summary>
 /// Return chain of namespace nodes.  If specified node has no local namespaces, then 0 will be
 /// returned.  Otherwise, the first node in the chain is guaranteed to be a local namespace (its
 /// parent is this node).  Subsequent nodes may not have the same node as parent, so the caller will
 /// need to test the parent in order to terminate a search that processes only local namespaces.
 /// </summary>
 public static int GetLocalNamespaces(XPathNode[] pageElem, int idxElem, out XPathNode[] pageNmsp) {
     if (pageElem[idxElem].HasNamespaceDecls) {
         // Only elements have namespace nodes
         Debug.Assert(pageElem[idxElem].NodeType == XPathNodeType.Element);
         return pageElem[idxElem].Document.LookupNamespaces(pageElem, idxElem, out pageNmsp);
     }
     pageNmsp = null;
     return 0;
 }

        /// <summary>
        /// Return the first attribute of the specified node.  If no attribute exist, do not
        /// set pageNode or idxNode and return false.
        /// </summary>
        public static bool GetFirstAttribute(ref XPathNode[] pageNode, ref int idxNode) {
            Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");

            if (pageNode[idxNode].HasAttribute) {
                GetChild(ref pageNode, ref idxNode);
                Debug.Assert(pageNode[idxNode].NodeType == XPathNodeType.Attribute);
                return true;
            }
            return false;
        }

        /// <summary>
        /// Return the next attribute sibling of the specified node.  If the node is not itself an
        /// attribute, or if there are no siblings, then do not set pageNode or idxNode and return false.
        /// </summary>
        public static bool GetNextAttribute(ref XPathNode[] pageNode, ref int idxNode) {
            XPathNode[] page;
            int idx;
            Debug.Assert(pageNode != null && idxNode != 0, "Cannot pass null argument(s)");

            idx = pageNode[idxNode].GetSibling(out page);
            if (idx != 0 && page[idx].NodeType == XPathNodeType.Attribute) {
                pageNode = page;
                idxNode = idx;
                return true;
            }
            return false;
        }

 public XPathNodeInfoAtom Create(string localName, string namespaceUri, string prefix, string baseUri, XPathNode[] pageParent, XPathNode[] pageSibling, XPathNode[] pageSimilar, XPathDocument doc, int lineNumBase, int linePosBase)
 {
     XPathNodeInfoAtom infoCached;
     if (this.infoCached == null)
     {
         infoCached = new XPathNodeInfoAtom(localName, namespaceUri, prefix, baseUri, pageParent, pageSibling, pageSimilar, doc, lineNumBase, linePosBase);
     }
     else
     {
         infoCached = this.infoCached;
         this.infoCached = infoCached.Next;
         infoCached.Init(localName, namespaceUri, prefix, baseUri, pageParent, pageSibling, pageSimilar, doc, lineNumBase, linePosBase);
     }
     return this.Atomize(infoCached);
 }

 private int GetFollowingEnd(XPathDocumentNavigator end, bool useParentOfVirtual, out XPathNode[] pageEnd)
 {
     if ((end != null) && (this.pageCurrent[this.idxCurrent].Document == end.pageCurrent[end.idxCurrent].Document))
     {
         if (end.idxParent == 0)
         {
             pageEnd = end.pageCurrent;
             return end.idxCurrent;
         }
         pageEnd = end.pageParent;
         if (!useParentOfVirtual)
         {
             return (end.idxParent + 1);
         }
         return end.idxParent;
     }
     pageEnd = null;
     return 0;
 }

 public void Init(string localName, string namespaceUri, string prefix, string baseUri, XPathNode[] pageParent, XPathNode[] pageSibling, XPathNode[] pageSimilar, XPathDocument doc, int lineNumBase, int linePosBase)
 {
     this.localName = localName;
     this.namespaceUri = namespaceUri;
     this.prefix = prefix;
     this.baseUri = baseUri;
     this.pageParent = pageParent;
     this.pageSibling = pageSibling;
     this.pageSimilar = pageSimilar;
     this.doc = doc;
     this.lineNumBase = lineNumBase;
     this.linePosBase = linePosBase;
     this.next = null;
     this.pageInfo = null;
     this.hashCode = 0;
     this.localNameHash = 0;
     for (int i = 0; i < this.localName.Length; i++)
     {
         this.localNameHash += (this.localNameHash << 7) ^ this.localName[i];
     }
 }

 internal void SetRootNode(XPathNode[] pageRoot, int idxRoot)
 {
     this.pageRoot = pageRoot;
     this.idxRoot = idxRoot;
 }

 internal void SetCollapsedTextNode(XPathNode[] pageText, int idxText)
 {
     this.pageText = pageText;
     this.idxText = idxText;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 public XPathNodePageInfo(XPathNode[] pagePrev, int pageNum) {
     this.pagePrev = pagePrev;
     this.pageNum = pageNum;
     this.nodeCount = 1;         // Every node page contains PageInfo at 0th position
 }

        /// <summary>
        /// "end" is positioned on a node which terminates a following scan.  Return the page and index of "end" if it
        /// is positioned to a non-virtual node.  If "end" is positioned to a virtual node:
        ///    1. If useParentOfVirtual is true, then return the page and index of the virtual node's parent
        ///    2. If useParentOfVirtual is false, then return the page and index of the virtual node's parent + 1.
        /// </summary>
        private int GetFollowingEnd(XPathDocumentNavigator end, bool useParentOfVirtual, out XPathNode[] pageEnd)
        {
            // If ending navigator is positioned to a node in another document, then return null
            if (end != null && _pageCurrent[_idxCurrent].Document == end._pageCurrent[end._idxCurrent].Document)
            {
                // If the ending navigator is not positioned on a virtual node, then return its current node
                if (end._idxParent == 0)
                {
                    pageEnd = end._pageCurrent;
                    return end._idxCurrent;
                }

                // If the ending navigator is positioned on an attribute, namespace, or virtual text node, then use the
                // next physical node instead, as the results will be the same.
                pageEnd = end._pageParent;
                return (useParentOfVirtual) ? end._idxParent : end._idxParent + 1;
            }

            // No following, so set pageEnd to null and return an index of 0
            pageEnd = null;
            return 0;
        }

 internal void SetXmlNamespaceNode(XPathNode[] pageXmlNmsp, int idxXmlNmsp)
 {
     this.pageXmlNmsp = pageXmlNmsp;
     this.idxXmlNmsp = idxXmlNmsp;
 }

        /// <summary>
        /// Return the page and index of the first child (attribute or content) of the specified node.
        /// </summary>
        private static void GetChild(ref XPathNode[] pageNode, ref int idxNode) {
            Debug.Assert(pageNode[idxNode].HasAttribute || pageNode[idxNode].HasContentChild, "Caller must check HasAttribute/HasContentChild on parent before calling GetChild.");
            Debug.Assert(pageNode[idxNode].HasAttribute || !pageNode[idxNode].HasCollapsedText, "Text child is virtualized and therefore is not present in the physical node page.");

            if (++idxNode >= pageNode.Length) {
                // Child is first node on next page
                pageNode = pageNode[0].PageInfo.NextPage;
                idxNode = 1;
            }
            // Else child is next node on this page
        }