C# XmlTextWriter.WriteNode方法代碼示例

        // Creates XmlDocument from html content and return it with rootitem "<root>".
        public static XmlDocument ParseHtml(string sContent)
        {
            StringReader sr = new StringReader("<root>" + sContent + "</root>");
            SgmlReader reader = new SgmlReader();
            reader.WhitespaceHandling = WhitespaceHandling.All;
            reader.CaseFolding = Sgml.CaseFolding.ToLower;
            reader.InputStream = sr;

            StringWriter sw = new StringWriter();
            XmlTextWriter w = new XmlTextWriter(sw);
            w.Formatting = Formatting.Indented;
            w.WriteStartDocument();
            reader.Read();
            while (!reader.EOF)
            {
                w.WriteNode(reader, true);
            }
            w.Flush();
            w.Close();

            sw.Flush();

            // create document
            XmlDocument doc = new XmlDocument();
            doc.PreserveWhitespace = true;
            doc.XmlResolver = null;
            doc.LoadXml(sw.ToString());

            reader.Close();

            return doc;
        }

 public static string GetWellFormedHTML(string html, string xpathNavPath)
 {
     // StreamReader sReader = null;
     StringWriter sw = null;
     SgmlReader reader = null;
     XmlTextWriter writer = null;
     try
     {
         //  if (uri == String.Empty) uri = "http://www.XMLforASP.NET";
         // HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
         //  HttpWebResponse res = (HttpWebResponse)req.GetResponse();
         //  sReader = new StreamReader(res.GetResponseStream());
         reader = new SgmlReader();
         reader.DocType = "HTML";
         reader.InputStream = new StringReader(html);
         sw = new StringWriter();
         writer = new XmlTextWriter(sw);
         writer.Formatting = Formatting.Indented;
         //writer.WriteStartElement("Test");
         while (reader.Read())
         {
             if (reader.NodeType != XmlNodeType.Whitespace)
             {
                 writer.WriteNode(reader, true);
             }
         }
         //writer.WriteEndElement();
         if (xpathNavPath == null)
         {
             string sr = sw.ToString();
             sr = sr.Replace("\r", "\n");
             sr = sr.Replace("\n\n", "\n");
             return sr;
         }
         else
         { //Filter out nodes from HTML
             StringBuilder sb = new StringBuilder();
             XPathDocument doc = new XPathDocument(new StringReader(sw.ToString()));
             XPathNavigator nav = doc.CreateNavigator();
             XPathNodeIterator nodes = nav.Select(xpathNavPath);
             while (nodes.MoveNext())
             {
                 sb.Append(nodes.Current.Value + "\n");
             }
             string sr = sb.ToString();
             sr = sr.Replace("\r", "\n");
             sr = sr.Replace("\n\n", "\n");
             return sr;
         }
     }
     catch (Exception exp)
     {
         writer.Close();
         reader.Close();
         sw.Close();
         // sReader.Close();
         return exp.Message;
     }
 }

        /// <summary>
        /// Executes the command logics.
        /// </summary>
        public override void Invoke()
        {
            //print request xml
            var doc = new XmlDocument();
            var stringWriter = new StringWriter();

            //get your document
            try
            {
                doc.LoadXml(this.document.Text);
            }
            catch (Exception)
            {
                return;
            }

            //create reader and writer
            var xmlReader = new XmlNodeReader(doc);

            //set formatting options
            var xmlWriter = new XmlTextWriter(stringWriter)
                                {
                                    Formatting = Formatting.Indented,
                                    Indentation = 3,
                                    IndentChar = ' '
                                };

            //write the document formatted
            xmlWriter.WriteNode(xmlReader, true);

            this.document.Text = stringWriter.ToString();
        }

		public void TransformingTest() 
		{
			XslTransform tx = new XslTransform();
			tx.Load(new XmlTextReader(
				Globals.GetResource(this.GetType().Namespace + ".test.xsl")));

			XmlReader xtr = new XmlTransformingReader(
				new XmlTextReader(
				Globals.GetResource(this.GetType().Namespace + ".input.xml")),
				tx);

			//That's it, now let's dump out XmlTransformingReader to see what it returns
			StringWriter sw = new StringWriter();
			XmlTextWriter w = new XmlTextWriter(sw);
			w.Formatting = Formatting.Indented;
			w.WriteNode(xtr, false);
			xtr.Close();
			w.Close();

			Assert.AreEqual(sw.ToString(), @"<parts>
  <item SKU=""1001"" name=""Lawnmower"" price=""299.99"" />
  <item SKU=""1001"" name=""Electric drill"" price=""99.99"" />
  <item SKU=""1001"" name=""Hairdrier"" price=""39.99"" />
</parts>");
		}

 public static string GenerateIndentedOuterXml(string xmlContent)
 {
     StringWriter buffer = new StringWriter();
     XmlTextWriter writer = new XmlTextWriter(buffer);
     writer.Formatting = Formatting.Indented;
     writer.WriteNode(new XmlTextReader(new StringReader(xmlContent)), false);
     return buffer.ToString();
 }

        private static void CreateSubdirectoryXML(XmlTextWriter writer, DirectoryInfo dir)
        {
            string xml = new XElement("dir", new XAttribute("name", dir.Name)).ToString();
            XmlReader reader = XmlReader.Create(new StringReader(xml));
            writer.WriteNode(reader, true);

            foreach (var file in dir.GetFiles())
            {
                xml = new XElement("file", new XAttribute("name", file.Name)).ToString();
                reader = XmlReader.Create(new StringReader(xml));
                writer.WriteNode(reader, true);
            }

            var subdirectories = dir.GetDirectories().ToList().OrderBy(d => d.Name);
            foreach (var subDir in subdirectories)
            {
                CreateSubdirectoryXML(writer, subDir);
            }
        }

 /// <summary>
 /// Indents the specifide XML string.
 /// </summary>
 public static string Indent(this string xml)
 {
     var reder = new XmlTextReader(new StringReader(xml));
     var sw = new StringWriter();
     var xmlTextWriter = new XmlTextWriter(sw) {Formatting = Formatting.Indented};
     while (reder.Read())
         xmlTextWriter.WriteNode(reder, false);
     xmlTextWriter.Close();
     reder.Close();
     return sw.ToString();
 }

        private static string GetTokenFormatted()
        {
            var sb = new StringBuilder();
            XmlTextWriter w = new XmlTextWriter(new StringWriter(sb));
            w.Formatting = Formatting.Indented;
            w.IndentChar = '\t';

            XmlReader reader = XmlReader.Create(new FileStream(Path.Combine(Application.StartupPath, "token.xml"), FileMode.Open));
            w.WriteNode(reader, true);
            w.Flush();
            return sb.ToString();
        }

 public void SaveDocument(XmlDocument xmlDocument, string xmlFileName)
 {
     if (xmlDocument == null) throw new ArgumentNullException("xmlDocument");
     if (string.IsNullOrEmpty(xmlFileName)) throw new ArgumentNullException("xmlFileName");
     using (var xmlTextReader = new XmlTextReader(xmlDocument.OuterXml, XmlNodeType.Document, new XmlParserContext(null, null, null, XmlSpace.None)))
     {
         using (var xmlTextWriter = new XmlTextWriter(xmlFileName, Encoding.UTF8))
         {
             xmlTextWriter.Formatting = Formatting.Indented;
             xmlTextWriter.WriteNode(xmlTextReader, true);
             xmlTextWriter.Flush();
         }
     }
 }

        static void Main(string[] args)
        {
            bool showHelp = false;
            bool suppressOutput = false;

            var options = new OptionSet {
                { "s", v => suppressOutput = true },
                { "h|?|help", v => showHelp = true }
            };

            string filename = options.Parse(args).FirstOrDefault() ?? string.Empty;

            if (args.Length == 0 || showHelp)
            {
                PrintHelp();
                return;
            }

            if(!File.Exists(filename))
            {
                Console.Error.WriteLine("File {0} does not exist", filename);
                return;
            }

            XmlReader reader;
            TextWriter outputStream;

            if (suppressOutput)
            {
                // Suppress output
                reader = GetReader(filename);
                outputStream = TextWriter.Null;
            }
            else
            {
                reader = GetReader(filename);

                // Console.Out is a StreamWriter which flushes it's
                // buffer after every call to write. This is due to
                // setting AutoFlush to true. (according to the docs)

                // 256 should be the default buffer size
                Console.OpenStandardOutput(256);

                outputStream = Console.Out;
            }

            var writer = new XmlTextWriter(outputStream) {Formatting = Formatting.Indented};
            writer.WriteNode(reader, false);
        }

        public override void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, object data)
        {
            // Get ActivityId from the eventCache.
            // ActivityId is an internal property. Using reflection to get its value
            string activityID = "";

            if (eventCache != null)
            {
                PropertyInfo propInfo = null;
                Type objType = eventCache.GetType();
                propInfo = objType.GetProperty("ActivityId", BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic);
                if (propInfo != null)
                {
                    object value = propInfo.GetValue(eventCache, null);
                    if (value != null)
                        activityID = value.ToString();
                }
            }

            Process p = Process.GetProcessById(eventCache.ProcessId);
            // Header message that is added by this listener
            string msgHeader = string.Format("<HeaderAddedByListener time=\"{0}\" ActivityId=\"{1}\" ProcessId=\"{2}\">", eventCache.DateTime.ToString(), activityID, p.ProcessName);

            // Read the message received from wcf
            XPathNavigator xPathNavigator = data as XPathNavigator;
            if (xPathNavigator == null)
            {
                return;
            }

            XmlTextWriter xmlWriter;
            StringBuilder msgReceived = new StringBuilder();
            xmlWriter = new XmlTextWriter(new System.IO.StringWriter(msgReceived, CultureInfo.CurrentCulture));

            xPathNavigator.MoveToRoot();
            xmlWriter.WriteNode(xPathNavigator, false);

            // Broadcast the msg
            string msgToSend = string.Format("{0}{1}</HeaderAddedByListener>", msgHeader, msgReceived.ToString());
            GlobalHost.ConnectionManager.GetConnectionContext<ListenerConnection>().Connection.Broadcast(msgToSend);

            //base.TraceData(eventCache, source, eventType, id, data);

            if (xmlWriter != null)
            {
                xmlWriter.Close();
            }
            xmlWriter = null;
            msgReceived = null;
        }

		public static void XPathNodeIteratorToConsole(XPathNodeIterator iterator)
		{
			Console.WriteLine(new string('-', 50));
			XmlTextWriter tw = new XmlTextWriter(Console.Out);
			tw.Formatting = Formatting.Indented;

			while (iterator.MoveNext())
			{
				tw.WriteNode(new Mvp.Xml.Common.XPath.XPathNavigatorReader(iterator.Current), false);
			}

			tw.Flush();
			Console.WriteLine();
			Console.WriteLine(new string('-', 50));
		}

        //[STAThread]
        public static string Format(string s)
        {
            var stringWriter = new StringWriter();
            var doc = new XmlDocument();

            //get your document
            doc.LoadXml(s);

            //create reader and writer
            var xmlReader = new XmlNodeReader(doc);
            var xmlWriter = new XmlTextWriter(stringWriter) {Formatting = Formatting.Indented, Indentation = 2, IndentChar = ' '};

            //set formatting options

            //write the document formatted
            xmlWriter.WriteNode(xmlReader, true);
            return stringWriter.ToString();
        }

        internal static void Convert(String htmlFile, String xhtmlFile)
        {
            using (SgmlReader reader = new SgmlReader()) {
                reader.DocType = "HTML";
                reader.WhitespaceHandling = WhitespaceHandling.None;

                using (StreamReader r = new StreamReader(htmlFile)) {
                    reader.InputStream = r;

                    using (XmlTextWriter writer = new XmlTextWriter(xhtmlFile, Encoding.UTF8)) {
                        writer.Formatting = Formatting.Indented;

                        reader.Read ();
                        while (!reader.EOF) {
                            writer.WriteNode (reader, true);
                        }
                    }
                }
            }
        }

		public void TestRss()
		{
			string theWord = "XML";
			XPathDocument doc = new XPathDocument("../../Common/XPathIteratorReaderTests/rss.xml");
			XPathNodeIterator it = doc.CreateNavigator().Select(
				"/rss/channel/item[contains(title,'" + theWord + "')]");

			XPathIteratorReader reader = new XPathIteratorReader(it);
			reader.MoveToContent();
			string xml = reader.ReadOuterXml();

			using (StreamWriter sw = new StreamWriter(@"c:\subset.xml", false))
			{
				XmlTextWriter tw = new XmlTextWriter(sw);
				tw.WriteNode(new XPathIteratorReader(it), false);
				tw.Close();
			}

			Assert.IsTrue(xml != String.Empty);
		}