C# XmlTextWriter.WriteProcessingInstruction方法代码示例

 public override void Serialize(XmlTextWriter xtw)
 {            
     xtw.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
     xtw.WriteStartElement("xCal", "iCalendar", "urn:ietf:params:xml:ns:xcal");
     base.Serialize(xtw);
     xtw.WriteEndElement();
 }

        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "application/opensearchdescription+xml";

            using (XmlTextWriter writer = new XmlTextWriter(context.Response.OutputStream, System.Text.Encoding.UTF8))
            {
                //get the details from host object
                Host host = HostCache.GetHost(HostHelper.GetHostAndPort(context.Request.Url));

                writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\"");

                writer.WriteStartElement("OpenSearchDescription", "http://a9.com/-/spec/opensearch/1.1/");
                writer.WriteElementString("ShortName", host.SiteTitle);
                writer.WriteElementString("Description", host.SiteDescription);
                writer.WriteElementString("Contact", host.Email);

                writer.WriteStartElement("Image");
                writer.WriteAttributeString("height", "16");
                writer.WriteAttributeString("weight", "16");
                writer.WriteAttributeString("type", "image/x-icon");
                writer.WriteString(string.Format("{0}/favicon.ico", host.RootUrl));
                writer.WriteEndElement();

                writer.WriteStartElement("Url");
                writer.WriteAttributeString("type", "text/html");
                writer.WriteAttributeString("method", "GET");
                writer.WriteAttributeString("template", string.Format("{0}/search?q={{searchTerms}}&user=False&page={{startPage?}}", host.RootUrl));
                writer.WriteEndElement();

                writer.Flush();
            }
        }

        static public bool SimpleDumper(string XMLFileName, Type type)
        {
            using (XmlTextWriter writer = new XmlTextWriter(XMLFileName, null))
            {
                Type[] types = { typeof(EffectInstanceDice) };// asm.GetTypes().Where(entry => entry.Namespace != null && entry.GetConstructor(System.Type.EmptyTypes) != null && entry.Namespace.StartsWith("BiM.Protocol.Data")).ToArray<Type>();
                try
                {
                    writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"");

                    XmlSerializer d2oSerializer = new XmlSerializer(type, types);
                    writer.WriteStartElement(type.Name + "_root");
                    // write
                    //using (var stream = File.Create(XMLFileName))
                    {
                        foreach (object obj in ObjectDataManager.Instance.EnumerateObjects(type))
                        {
                            d2oSerializer.Serialize(writer, obj); // your instance
                        }
                    }
                    writer.WriteEndElement();
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex.Message);
                }

            }
            // Open a file for reading
            cleanXML(XMLFileName, false);
            return true;
        }

 public GlobalXMLManipulatorWriter(string fileName, bool scrabled)
     : base(null)
 {
     try
     {
         if (scrabled)
         {
             Exception exception = new Exception("Incorrect file!");
             throw exception;
         }
         this._xmlDoc = new XmlDocument();
         this._fileName = fileName;
         XmlTextWriter writer = new XmlTextWriter(this._fileName, Encoding.UTF8) {
             Formatting = Formatting.Indented
         };
         writer.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
         writer.Close();
         this._xmlDoc.Load(this._fileName);
         XmlNode documentElement = this._xmlDoc.DocumentElement;
         base._parentNode = base._iteratorNode = (XmlElement) documentElement;
         if (base._parentNode != null)
         {
             base.isInitialized = true;
         }
     }
     catch (Exception exception2)
     {
         GlobalXMLManipulator._log.Error("Invalid File to load! GlobalXMLManipulatorWriter()\n" + exception2.Message);
     }
 }

		public override void SaveSettings()
		{
            if (!this.writeable)
                throw new InvalidOperationException("Attempted to write to a non-writeable Settings Storage");

			string dirPath = Path.GetDirectoryName( filePath );
			if ( !Directory.Exists( dirPath ) )
				Directory.CreateDirectory( dirPath );

			XmlTextWriter writer = new XmlTextWriter(  filePath, System.Text.Encoding.UTF8 );
			writer.Formatting = Formatting.Indented;

			writer.WriteProcessingInstruction( "xml", "version=\"1.0\"" );
			writer.WriteStartElement( "NUnitSettings" );
			writer.WriteStartElement( "Settings" );

			ArrayList keys = new ArrayList( settings.Keys );
			keys.Sort();

			foreach( string name in keys )
			{
				object val = settings[name];
				if ( val != null )
				{
					writer.WriteStartElement( "Setting");
					writer.WriteAttributeString( "name", name );
					writer.WriteAttributeString( "value", val.ToString() );
					writer.WriteEndElement();
				}
			}

			writer.WriteEndElement();
			writer.WriteEndElement();
			writer.Close();
		}

        public override string ToString()
        {
            string doc;

            using (var sw = new StringWriter()) {
                using (var writer = new XmlTextWriter(sw)) {
                    writer.Formatting = Formatting.Indented;
                    //writer.WriteStartDocument();
                    writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
                    writer.WriteStartElement("D", "multistatus", "DAV:");
                    for (int i = 0; i < _nameSpaceList.Count; i++) {
                        string tag = string.Format("ns{0}", i);
                        writer.WriteAttributeString("xmlns", tag, null, _nameSpaceList[i]);
                    }

                    foreach (var oneResponse in _ar) {
                        oneResponse.Xml(writer);
                    }
                    writer.WriteEndElement();
                    //writer.WriteEndDocument();
                    writer.Flush();
                    writer.Close();
                    doc = sw.ToString();
                    writer.Flush();
                    writer.Close();
                }
                sw.Flush();
                sw.Close();
            }
            return doc;
        }

        public override string Serialize(Node node, Type typeAttr)
        {
            XpcaProxy proxy = new XpcaProxy(node);
            StringWriter sw = new StringWriter();

            using(XmlWriter xmlWriter = new XmlTextWriter(sw))
            {
                xmlWriter.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\"");
                xmlWriter.WriteStartElement("root");
                foreach (KeyValuePair<string, PropertyInfo> property in proxy.GetPropertiesFor(typeAttr)) {

                    object value = proxy[property.Key];
                    if (value != null) {
                        xmlWriter.WriteStartElement(property.Key);
                        if(value is IEnumerable<object>) {
                            foreach (object obj in (value as IEnumerable<object>)) {
                                xmlWriter.WriteStartElement("item");
                                XmlWriteValue(xmlWriter, obj);
                                xmlWriter.WriteEndElement();
                            }

                        }
                        else {
                            XmlWriteValue(xmlWriter, value);
                        }
                        xmlWriter.WriteEndElement();
                    }
                }
                xmlWriter.WriteEndElement();
            }

            return sw.ToString();
        }

        public XmlWriter()
        {
            string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + @"/Table1.xml";

            XmlDocument xmlDoc = new XmlDocument();

            try
            {
                xmlDoc.Load(filename);
            }
            catch (System.IO.FileNotFoundException ex)
            {
                Console.WriteLine(ex);
                XmlTextWriter xmlWriter = new XmlTextWriter(filename, System.Text.Encoding.UTF8);
                xmlWriter.Formatting = Formatting.Indented;
                xmlWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
                xmlWriter.WriteStartElement("Table");
                xmlWriter.WriteStartElement("Players");
                xmlWriter.WriteEndElement();
                xmlWriter.WriteStartElement("Dealer");
                xmlWriter.WriteStartElement("DealerCards");
                xmlWriter.WriteEndElement();
                xmlWriter.WriteEndElement();
                xmlWriter.Close();
                xmlDoc.Load(filename);
            }
        }

 public void writeOptions()
 {
     Directory.CreateDirectory(OPTIONS_PATH);
     XmlDocument xmlDoc = new XmlDocument();
     try
     {
         xmlDoc.Load(OPTIONS_FILE);
     }
     catch (System.IO.FileNotFoundException)
     {
         //if file is not found, create a new xml file
         XmlTextWriter xmlWriter = new XmlTextWriter(OPTIONS_FILE, System.Text.Encoding.UTF8);
         xmlWriter.Formatting = Formatting.Indented;
         xmlWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
         xmlWriter.WriteStartElement("root");
         //If WriteProcessingInstruction is used as above,
         //Do not use WriteEndElement() here
         //xmlWriter.WriteEndElement();
         //it will cause the <Root> to be &ltRoot />
         xmlWriter.Close();
         xmlDoc.Load(OPTIONS_FILE);
     }
     XmlNode root = xmlDoc.DocumentElement;
     root.AppendChild(asXML(root));
     xmlDoc.Save(OPTIONS_FILE);
 }

		/// <summary>
		/// This function retuns list of states for a given country as XML Document in a string 
		/// and this value is used in client side java script to populate state combo box.
		/// Functionality: Transform the CountriesAndStates xml string into another XML string having the single country 
		/// and states under that country. 
		/// </summary>
		public string GetStatesXMLString(string countryName)
		{
			//Creates a XslTransform object and load the CountriesAndStates.xsl file
			XslTransform transformToCountryNode = new XslTransform();
			transformToCountryNode.Load(new XPathDocument(HttpContext.Current.Server.MapPath("~/xmlxsl/CountriesAndStates.xsl")).CreateNavigator(), new XmlUrlResolver());
			//TransformToCountryNode.Load(new XPathDocument(HttpContext.Current.Server.MapPath("~/xmlxsl/CountriesAndStates.xsl")).CreateNavigator(), new XmlUrlResolver(), this.GetType().Assembly.Evidence);

			//Creating the XSLT parameter country-name and setting the value
			XsltArgumentList xslArgs = new XsltArgumentList();
			xslArgs.AddParam("country-name", "", countryName);
				
			// Memory stream to store the result of XSL transform 
			MemoryStream countryNodeMemoryStream = new MemoryStream(); 
			XmlTextWriter countryNodeXmlTextWriter = new XmlTextWriter(countryNodeMemoryStream, Encoding.UTF8); 
			countryNodeXmlTextWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");

			//transforming the current XML string to get the state XML string
			transformToCountryNode.Transform(xPathDoc, xslArgs,  countryNodeXmlTextWriter);
			//TransformToCountryNode.Transform(XPathDoc, XslArgs,  CountryNodeXmlTextWriter, null);

			//reading the XML string using StreamReader and return the same
			countryNodeXmlTextWriter.Flush(); 
			countryNodeMemoryStream.Position = 0; 
			StreamReader countryNodeStreamReader = new StreamReader(countryNodeMemoryStream); 
			return  countryNodeStreamReader.ReadToEnd(); 
		}

        public XmlFile(FileInfo file, bool create, string root_name) {
            this.File = file;
            file.Refresh();
            if (!file.Exists) {
				if(create) {
                	XmlTextWriter write_here = new XmlTextWriter(file.FullName, System.Text.Encoding.UTF8);
                	write_here.Formatting = Formatting.Indented;
                	write_here.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
					//write_here.WriteStartElement(root_name);
					//write_here.WriteEndElement();
					write_here.Close();
				} else {
					throw new FileNotFoundException("XMl file not found",file.FullName);
				}
            }
            XmlReader parse_me = XmlReader.Create(file.FullName, xml_settings);
            try {
                this.Load(parse_me);
            } catch (Exception ex) {
                IXmlLineInfo info = parse_me as IXmlLineInfo;
                throw new XmlException(file.FullName + Environment.NewLine + Environment.NewLine + "Line: " + info.LineNumber + " Column: " + info.LinePosition, ex);
            } finally {
                parse_me.Close();
            }
        }

		public void Save (System.IO.Stream stream)
		{
			try {
				XmlTextWriter text;
				RdfXmlWriter writer;
                                XmlDocument rdfdoc = new XmlDocument();

                                // first, construct the rdf guts, semweb style
                                writer = new XmpWriter (rdfdoc);
				//writer.Namespaces.Parent = MetadataStore.Namespaces;
				writer.Write (store);
				writer.Close ();
			       
                                // now construct the xmp wrapper packet
				text = new XmlTextWriter (stream, System.Text.Encoding.UTF8);
 				text.Formatting = Formatting.Indented;
                        
                                text.WriteProcessingInstruction ("xpacket", "begin=\"\ufeff\" id=\"W5M0MpCehiHzreSzNTczkc9d\"");
                                text.WriteStartElement ("x:xmpmeta");
                                text.WriteAttributeString ("xmlns", "x", null, "adobe:ns:meta/");

				((XmlElement)rdfdoc.ChildNodes[1]).RemoveAttribute ("xml:base");
				rdfdoc.ChildNodes[1].WriteTo (text);

                                // now close off the xmp packet
                                text.WriteEndElement ();
                                text.WriteProcessingInstruction ("xpacket", "end=\"r\"");
				text.Close ();
				
			} catch (System.Exception e) {
				//System.Console.WriteLine (e);
			}
		}

        /// <summary>
        /// 
        /// </summary>
        protected override void WriteHeader()
        {
            writer = base.GetXmlTextWriter();
            writer.Formatting = Formatting.Indented;

            writer.WriteProcessingInstruction("xml", "version=\"1.0\"");
            writer.WriteProcessingInstruction("zpl", "version=\"1.0\"");
            writer.WriteStartElement("smil");

            writer.WriteStartElement("head");
            writer.WriteElementString("title", base.name + " Playlist");
            writer.WriteElementString("generator", App.NameVersion);
            writer.WriteEndElement(); // head

            writer.WriteStartElement("body");
            writer.WriteStartElement("seq");
        }

 protected override bool createConfig(string file_name) {
     XmlTextWriter write_here = new XmlTextWriter(file_name, System.Text.Encoding.UTF8);
     write_here.Formatting = Formatting.Indented;
     write_here.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
     write_here.WriteStartElement("settings");
     write_here.Close();
     return true;
 }

 protected internal override bool OnNext()
 {
     string text = this._fileNameTextBox.Text;
     if (text.Length == 0)
     {
         MessageBox.Show(base.WizardForm, "You must specify a filename", "Export Snippets", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
         return false;
     }
     if (text.IndexOfAny(Path.InvalidPathChars) != -1)
     {
         MessageBox.Show(base.WizardForm, "The specified filename contains invalid characters.", "Export Snippets", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
         return false;
     }
     ListSnippetsWizardPanel snippetList = ((ExportSnippetsWizard) base.WizardForm).SnippetList;
     FileStream stream = null;
     bool flag = false;
     try
     {
         if (Path.GetExtension(text).Length == 0)
         {
             text = text + ".snippets";
         }
         stream = new FileStream(text, FileMode.Create, FileAccess.Write, FileShare.Write);
         XmlTextWriter writer = new XmlTextWriter(new StreamWriter(stream, Encoding.UTF8));
         writer.Formatting = Formatting.Indented;
         writer.Indentation = 4;
         writer.IndentChar = ' ';
         writer.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
         writer.WriteStartElement("Snippets");
         foreach (SnippetToolboxDataItem item in snippetList.CheckedToolboxDataItems)
         {
             writer.WriteStartElement("Snippet");
             if (item.InternalDisplayName.Length > 0)
             {
                 writer.WriteAttributeString("name", item.InternalDisplayName);
             }
             writer.WriteString(item.ToolboxData);
             writer.WriteEndElement();
         }
         writer.WriteEndElement();
         writer.Flush();
         writer.Close();
     }
     catch
     {
         MessageBox.Show(base.WizardForm, "The specified file could not be written.", "Export Snippets", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
         flag = true;
     }
     finally
     {
         if (stream != null)
         {
             stream.Close();
         }
     }
     return !flag;
 }