C# XmlNodeType类代码示例

        private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType)
        {
            XmlNode parent = xmlDocument.DocumentElement;
            XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
            XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);

            string original = parent.InnerXml;
            string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
                : ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
                : (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));

            // insert new child
            var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
            insertDelegate(parent, newChild, refChild);

            // verify
            Assert.Equal(3, parent.ChildNodes.Count);
            Assert.Equal(expected, parent.InnerXml);

            TestHelper.Verify(parent, refChild, newChild);
            TestHelper.VerifySiblings(refChild, newChild, insertType);

            if (insertType == InsertType.Prepend || insertType == InsertType.Append)
                TestHelper.Verify(refChild, newChild, insertType);

            // delete new child
            parent.RemoveChild(newChild);
            Assert.Equal(2, parent.ChildNodes.Count);
            TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
            Assert.Equal(original, parent.InnerXml);
        }

        private static void VerifyOwnerOfGivenType(XmlNodeType nodeType)
        {
            var xmlDocument = new XmlDocument();
            var node = xmlDocument.CreateNode(nodeType, "test", string.Empty);

            Assert.Equal(xmlDocument, node.OwnerDocument);
        }

        /// <summary>
        /// Adds a new node to the curret XML document. A node is added to XDocument, and another one is added to the XmlTreeNode list that is used by the DevExpress TreeList to visually represent the XML document
        /// </summary>
        /// <param name="parrentId"></param>
        /// <param name="type"></param>
        public void AddNode(int parrentId, XmlNodeType type)
        {
            List<XmlTreeNode> treeNodes = _dataSource.GetXmlTreeNodes();

            XmlTreeNode parent = treeNodes.Where(i => i.Id == parrentId).FirstOrDefault();
            XElement parentElement = (XElement)parent.XObject;

            // The default name and value of the new node
            string name = "Name" + treeNodes.Count;
            string value = "Value";

            // Creates the XObject representing the new node in the XML document
            XObject newNodeXObject;
            if (type == XmlNodeType.Element)
            {
                newNodeXObject = new XElement(name, value);
                // When an element becomes a parent, it is no longer allowed to have a value. XDocument does not support parent elements with values
                if (parentElement.Elements().Count() == 0)
                    parentElement.SetValue("");
            }
            else
                newNodeXObject = new XAttribute(name, value);
            parentElement.Add(newNodeXObject);

            //// Creates the XmlTreeNode that is added to the list of XmlTreeNodes used by the DevExpress TreeList to visually represented the XML document
            //XmlTreeNode node = new XmlTreeNode() { Id = highestId + 1, ParentId = parrentId, IsParrent = false, Name = "Name" + treeNodes.Count, Value = "Value", Type = type, Parrent = (XElement)parent.XObject, XObject = newNodeXObject };
            //treeNodes.Add(node);
        }

 //
 // Constructors
 //
 public CXmlBase(string strPrefix, string strName, string strLocalName, XmlNodeType NodeType, string strNamespace)
 {
     _strPrefix = strPrefix;
     _strName = strName;
     _strLocalName = strLocalName;
     _nType = NodeType;
     _strNamespace = strNamespace;
 }

 protected XPathNavigatorReader(XPathNavigator navToRead)
 {
     // Need clone that can be moved independently of original navigator
     _navToRead = navToRead;
     _nav = XmlEmptyNavigator.Singleton;
     _state = State.Initial;
     _depth = 0;
     _nodeType = XPathNavigatorReader.ToXmlNodeType(_nav.NodeType);
 }

 public void PositionOnNodeType2(XmlNodeType nodeType)
 {
     while (DataReader.Read() && DataReader.NodeType != nodeType)
     {
     }
     if (DataReader.EOF)
     {
         throw new CTestFailedException("Couldn't find XmlNodeType " + nodeType);
     }
 }

        private static void InsertTestBase(string xml, InsertType insertType, XmlNodeType nodeType)
        {
            string[] expected = new string[2];

            var xmlDocument = new XmlDocument { PreserveWhitespace = true };
            xmlDocument.LoadXml(xml);

            XmlNode parent = xmlDocument.DocumentElement;
            XmlNode firstChild = parent.FirstChild;
            XmlNode lastChild = parent.LastChild;
            XmlNode refChild = parent.FirstChild.NextSibling;
            XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);

            expected[0] = parent.InnerXml;
            expected[1] = (insertType == InsertType.InsertBefore)
                ? (firstChild.OuterXml + newChild.OuterXml + refChild.OuterXml + lastChild.OuterXml)
                : (firstChild.OuterXml + refChild.OuterXml + newChild.OuterXml + lastChild.OuterXml);

            // insertion
            var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
            insertDelegate(parent, newChild, refChild);

            // verify
            Assert.Equal(4, parent.ChildNodes.Count);
            Assert.Equal(expected[1], parent.InnerXml);

            TestHelper.Verify(parent, refChild, newChild);
            TestHelper.Verify(parent, firstChild, lastChild);
            TestHelper.VerifySiblings(refChild, newChild, insertType);

            if (insertType == InsertType.InsertBefore)
            {
                TestHelper.VerifySiblings(firstChild, newChild, InsertType.Append);
                TestHelper.VerifySiblings(newChild, refChild, InsertType.Append);
                TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
            }
            else
            {
                TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
                TestHelper.VerifySiblings(refChild, newChild, InsertType.Append);
                TestHelper.VerifySiblings(newChild, lastChild, InsertType.Append);
            }

            // delete the newChild
            parent.RemoveChild(newChild);

            // verify
            Assert.Equal(3, parent.ChildNodes.Count);
            Assert.Equal(expected[0], parent.InnerXml);

            TestHelper.Verify(parent, firstChild, lastChild);
            TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
            TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
        }

        private void VerifyNextNode(XmlNodeType nt, string name, string value)
        {
            while (DataReader.NodeType == XmlNodeType.Whitespace ||
                    DataReader.NodeType == XmlNodeType.SignificantWhitespace)
            {
                // skip all whitespace nodes
                // if EOF is reached NodeType=None
                DataReader.Read();
            }

            CError.Compare(DataReader.VerifyNode(nt, name, value), "VerifyNextNode");
        }

        public XsltInput(XmlReader reader, Compiler compiler, KeywordsTable atoms) {
            Debug.Assert(reader != null);
            Debug.Assert(atoms != null);
            EnsureExpandEntities(reader);
            IXmlLineInfo xmlLineInfo = reader as IXmlLineInfo;

            this.atoms          = atoms;
            this.reader         = reader;
            this.reatomize      = reader.NameTable != atoms.NameTable;
            this.readerLineInfo = (xmlLineInfo != null && xmlLineInfo.HasLineInfo()) ? xmlLineInfo : null;
            this.topLevelReader = reader.ReadState == ReadState.Initial;
            this.scopeManager   = new CompilerScopeManager<VarPar>(atoms);
            this.compiler       = compiler;
            this.nodeType       = XmlNodeType.Document;
        }

        protected void TestOnNopNodeType(XmlNodeType nt)
        {
            ReloadSource();

            PositionOnNodeType(nt);
            string name = DataReader.Name;
            string value = DataReader.Value;
            CError.WriteLine("Name=" + name);
            CError.WriteLine("Value=" + value);
            if (CheckCanReadBinaryContent()) return;

            byte[] buffer = new byte[1];
            int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1);
            CError.Compare(nBytes, 0, "nBytes");
            CError.Compare(DataReader.VerifyNode(nt, name, value), "vn");
            CError.WriteLine("Succeeded:{0}", nt);
        }

        private static void OneTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
        {
            var insertDelegate = TestHelper.CreateInsertFrontOrEnd(insertType);
            var xmlDocument = new XmlDocument { PreserveWhitespace = true };
            xmlDocument.LoadXml(xml);

            var parent = xmlDocument.DocumentElement;
            var child = parent.FirstChild;
            var newChild = TestHelper.CreateNode(xmlDocument, nodeType);
            var expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + child.OuterXml) : (child.OuterXml + newChild.OuterXml);

            // insert new child
            insertDelegate(parent, newChild);

            // verify
            Assert.Equal(2, parent.ChildNodes.Count);
            Assert.Equal(expected, parent.InnerXml);

            TestHelper.Verify(parent, child, newChild);
            TestHelper.Verify(child, newChild, insertType);

            // delete new child
            parent.RemoveChild(newChild);

            // verify
            Assert.Equal(1, parent.ChildNodes.Count);

            // Verify single child
            Assert.NotNull(parent);
            Assert.NotNull(child);

            Assert.Equal(child, parent.FirstChild);
            Assert.Equal(child, parent.LastChild);
            Assert.Null(child.NextSibling);
            Assert.Null(child.PreviousSibling);

            // delete the last child
            parent.RemoveChild(child);

            // verify
            Assert.Equal(0, parent.ChildNodes.Count);
            Assert.Null(parent.FirstChild);
            Assert.Null(parent.LastChild);
            Assert.False(parent.HasChildNodes);
        }

 protected void TestOnInvalidNodeType(XmlNodeType nt)
 {
     ReloadSource();
     PositionOnNodeType(nt);
     if (CheckCanReadBinaryContent()) return;
     try
     {
         byte[] buffer = new byte[1];
         int nBytes = DataReader.ReadContentAsBase64(buffer, 0, 1);
     }
     catch (InvalidOperationException ioe)
     {
         if (ioe.ToString().IndexOf(nt.ToString()) < 0)
             CError.Compare(false, "Call threw wrong invalid operation exception on " + nt);
         else
             return;
     }
     CError.Compare(false, "Call succeeded on " + nt);
 }

        protected void TestInvalidNodeType(XmlNodeType nt)
        {
            ReloadSource();

            PositionOnNodeType(nt);
            string name = DataReader.Name;
            string value = DataReader.Value;

            byte[] buffer = new byte[1];
            if (CheckCanReadBinaryContent()) return;

            try
            {
                int nBytes = DataReader.ReadContentAsBinHex(buffer, 0, 1);
            }
            catch (InvalidOperationException)
            {
                return;
            }
            CError.Compare(false, "Invalid OP exception not thrown on wrong nodetype");
        }

        private static void OneTextNode_OneNonTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType, bool deleteFirst)
        {
            var xmlDocument = new XmlDocument { PreserveWhitespace = true };
            xmlDocument.LoadXml(xml);

            XmlNode parent = xmlDocument.DocumentElement;
            XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
            XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
            XmlNode nodeToRemove = (deleteFirst) ? parent.FirstChild : parent.LastChild;

            // populate the expected result, where expected[0] is the expected result after insertion, and expected[1] is the expected result after deletion
            string[] expected = new string[2];
            expected[0] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
                : ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
                : (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
            if (deleteFirst)
                expected[1] = (insertType == InsertType.Append) ? (parent.LastChild.OuterXml + newChild.OuterXml) : (newChild.OuterXml + parent.LastChild.OuterXml);
            else
                expected[1] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.FirstChild.OuterXml) : (parent.FirstChild.OuterXml + newChild.OuterXml);

            // insert new child
            var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
            insertDelegate(parent, newChild, refChild);

            // verify
            Assert.Equal(3, parent.ChildNodes.Count);
            Assert.Equal(expected[0], parent.InnerXml);

            TestHelper.Verify(parent, refChild, newChild);
            TestHelper.VerifySiblings(refChild, newChild, insertType);

            if (insertType == InsertType.Prepend || insertType == InsertType.Append)
                TestHelper.Verify(refChild, newChild, insertType);

            // delete new child
            parent.RemoveChild(nodeToRemove);
            Assert.Equal(2, parent.ChildNodes.Count);
            TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
            Assert.Equal(expected[1], parent.InnerXml);
        }

        public static XmlNode CreateNode(XmlDocument doc, XmlNodeType nodeType)
        {
            Assert.NotNull(doc);

            switch (nodeType)
            {
                case XmlNodeType.CDATA:
                    return doc.CreateCDataSection(@"&lt; &amp; <tag> < ! > & </tag> 	 ");
                case XmlNodeType.Comment:
                    return doc.CreateComment(@"comment");
                case XmlNodeType.Element:
                    return doc.CreateElement("E");
                case XmlNodeType.Text:
                    return doc.CreateTextNode("text");
                case XmlNodeType.Whitespace:
                    return doc.CreateWhitespace(@"	  ");
                case XmlNodeType.SignificantWhitespace:
                    return doc.CreateSignificantWhitespace("	");
                default:
                    throw new ArgumentException("Wrong XmlNodeType: '" + nodeType + "'");
            }
        }