protected void Page_Load(object sender, EventArgs e)
    {
        var pathSVGIcons = Server.MapPath("~/Composite/images/icons/svg/");

        XNamespace svgNamespace = @"http://www.w3.org/2000/svg";

        var svgSprite = XElement.Parse(svgBlank);

        var defs = svgSprite.Descendants(svgNamespace + "defs").First();

        foreach (var file in Directory.GetFiles(pathSVGIcons))
        {
            var id = Path.GetFileNameWithoutExtension(file);
            var svgElement = XElement.Load(file);

            var taggetGroup = svgElement.Descendants(svgNamespace + "g").FirstOrDefault(el => (string) el.Attribute("id") == id);

            if (taggetGroup != null)
            {
                defs.Add(taggetGroup);
            }
        }

           var settings = new XmlWriterSettings {OmitXmlDeclaration = true};

        using (XmlWriter xw = XmlWriter.Create(PathUtil.Resolve("~/Composite/images/sprite.svg"), settings))
        {
            svgSprite.Save(xw);
        }
    }

    // Use this for initialization
    void Start()
    {
        playerData = new PlayerData1("PkerkidHD", 10.0f);

        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings()
        {
            Indent = true,
            IndentChars = "\t",
            NewLineOnAttributes = true
        };

        using (XmlWriter xml = XmlWriter.Create("PlayerData.xml", xmlWriterSettings)) {

            //ROOT
            xml.WriteStartDocument();
            xml.WriteStartElement("PlayerData");

            xml.WriteStartElement("Player");
            xml.WriteElementString("PlayerName", playerData.PlayerName);
            xml.WriteElementString("Money", playerData.Money.ToString());
            xml.WriteEndElement();

            // End.
            xml.WriteEndElement();
            xml.WriteEndDocument();
            xml.Flush();
        }

        Debug.Log ("DONE");
    }

 protected void Page_Load(object sender, EventArgs e)
 {
     if (!IsPostBack)
     {
         DateTime dt = new DateTime();
         XmlWriterSettings xws = new XmlWriterSettings();
         xws.Indent = true;
         xws.IndentChars=("  ");
         xws.ConformanceLevel = ConformanceLevel.Fragment;
         XmlWriter xwr = XmlWriter.Create(Server.MapPath("stu.xml"), xws);
         try
         {
             xwr.WriteStartElement("userinfo");
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name","zhangsan");
             xwr.WriteEndElement();
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name", "Jim john");
             xwr.WriteEndElement();
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name", "Marry");
             xwr.WriteEndElement();
             xwr.WriteEndElement();
             xwr.Flush();
             xwr.Close();
         }
         catch (Exception ex)
             {
             xwr.Close();
                 TextBox2.Text=ex.Message.ToString();
             }
     }
     mydom.Load(Server.MapPath("cat1.xml"));
 }

    public static string Transform(string xsltFile, string xml, XsltArgumentList xslArg)
    {
        string result = "";
        try {

        XslCompiledTransform xslt = new XslCompiledTransform();
        xslt.Load(xsltFile);
        // XmlWriterSettings.OmitXmlDeclaration

        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(new StringReader(xml));

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        settings.OmitXmlDeclaration = true;
        settings.NewLineOnAttributes = true;

        using (StringWriter sw = new StringWriter()) {
        using (XmlWriter writer = XmlWriter.Create(sw, settings)) {
            xslt.Transform(xmlDoc, xslArg, writer);
        }
        sw.Flush();
        result = sw.ToString();
          }
        } catch (Exception ex) {
        Console.WriteLine(ex.ToString());
        }
        return result;
    }

 internal static string ToXml(this object item)
 {
     if (item == null)
         return null;
     try
     {
         using (var stream = new StringWriter())
         {
             var settings = new XmlWriterSettings();
             settings.Indent = false;
             settings.OmitXmlDeclaration = true;
             using (var writer = XmlWriter.Create(stream, settings))
             {
                 var serializer = new XmlSerializer(item.GetType());
                 var emptyNamepsaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
                 serializer.Serialize(writer, item, emptyNamepsaces);
                 return stream.ToString();
             }
         }
     }
     catch
     {
         throw;
     }
 }

 public static void Main(string[] args)
 {
     AtomXmlReader reader = new AtomXmlReader();
     reader.DocumentTypeDetected += delegate(object sender, DocumentTypeDetectedEventArgs e) {
       if (!e.DocumentType.IsAssignableFrom(typeof(AtomEntry))) {
     e.HaltFurtherProcess = true;
       }
     };
     try {
       if (args.Length == 0) {
     Stream input = Console.OpenStandardInput();
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.Indent = true;
     reader.ReadDocument(input).WriteDocument(Console.Out, settings);
       }
       else {
     foreach (string feedLocation in args) {
       XmlWriterSettings settings = new XmlWriterSettings();
       settings.Indent = true;
       reader.ReadDocument(feedLocation).WriteDocument(Console.Out, settings);
       break;
     }
       }
     }
     catch (ArgumentException e) {
       Console.Error.WriteLine(e.Message);
     }
 }

    // Use this for initialization
    void Start()
    {
        cardList.Add(new CreatureCard());
        cardList.Add(new CreatureCard("アリスに化けたマミゾウ"));
        XmlSerializer xmls = new XmlSerializer(typeof(List<CreatureCard>));

        XmlWriterSettings settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true };
        using (var stream = File.OpenWrite("cardList.xml"))
        {
            using (var xmlWriter = XmlWriter.Create(stream, settings))
            {
                xmls.Serialize(xmlWriter, cardList);
            }
        }

        Type[] extraTypes = { typeof(Land), typeof(LiveableLand) };
        xmls = new XmlSerializer(typeof(Map),extraTypes);
        using (var stream = File.OpenWrite("map.xml"))
        {
            using (var xmlWriter = XmlWriter.Create(stream, settings))
            {
                xmls.Serialize(xmlWriter, map);
            }
        }
    }

	void Awake(){
		player1HandPosition = GameObject.Find ("Canvas/Player1Hand");
		CL = GameObject.Find ("CardLoader").GetComponent<CardLoader>();
		using (XmlReader reader = XmlReader.Create (new StreamReader (Application.persistentDataPath + "/Decks/DeckList.xml"))) {
			XmlWriterSettings ws = new XmlWriterSettings ();
			ws.Indent = true;
			while (reader.Read ()) {
				switch (reader.NodeType) {
				case XmlNodeType.Element:
					switch (reader.Name) {
					case "Deck":
						deckName = reader.GetAttribute ("Name");
						//Debug.Log (deckName);
						break;
					}
					break;
				case XmlNodeType.Text:
					//Debug.Log (reader.Value);
					line = reader.Value;
					break;
				}
			}
		}
		player1Deck = line.Split (',').ToList<string> ();
		player1Deck.RemoveAt (player1Deck.Count - 1); // Remove the blank string at the end of the list of cards
		RandomizeDeck(player1Deck);
		DrawStartingHands (player1Deck);
		//Debug.Log (player1Deck.Count);
		DisplayHand(player1HandPosition, player1Hand);

	}

		public XmlWriterTraceListener (TextWriter writer, string name)
			: base (writer, name)
			{
			XmlWriterSettings settings = new XmlWriterSettings ();
			settings.OmitXmlDeclaration = true;
			w = XmlWriter.Create (writer, settings);
			}

	public void SaveGame(string savePath){
		//Create a folder for saves incase it does not already exist
		string saveFolder = Directory.GetCurrentDirectory () + "/Saves";
		if (!Directory.Exists (saveFolder))
			Directory.CreateDirectory (saveFolder);

		//Setup Xml writer and file-stream
		XmlWriterSettings ws = new XmlWriterSettings ();
		ws.Indent = true;
		ws.Encoding = Encoding.UTF8;
		//Setup the writer and ouptut
		using (FileStream fs = new FileStream (saveFolder + '/' + savePath + ".xml", FileMode.Create)) {
			using (XmlWriter writer = XmlWriter.Create (fs, ws)) {
				//Write start of document
				writer.WriteStartDocument ();
				writer.WriteStartElement ("Save");

				//Add things to save here!
				_player.GetComponent<Wizard> ().Save (writer);
				SaveEnemies (writer);

				writer.WriteEndElement ();
				writer.WriteEndDocument ();
			}
		}
	}

        public static void DisposeFlushesAndDisposesOutputStream()
        {
            bool[] asyncValues = { false, true };
            bool[] closeOutputValues = { false, true };
            bool[] indentValues = { false, true };
            bool[] omitXmlDeclarationValues = { false, true };
            bool[] writeEndDocumentOnCloseValues = { false, true };
            foreach (var async in asyncValues)
                foreach (var closeOutput in closeOutputValues)
                    foreach (var indent in indentValues)
                        foreach (var omitXmlDeclaration in omitXmlDeclarationValues)
                            foreach (var writeEndDocumentOnClose in writeEndDocumentOnCloseValues)
                            {
                                using (MemoryStream ms = new MemoryStream())
                                {
                                    XmlWriterSettings settings = new XmlWriterSettings();
                                    // UTF8 without BOM
                                    settings.Encoding = new UTF8Encoding(false);
                                    settings.Async = async;
                                    settings.CloseOutput = closeOutput;
                                    settings.Indent = indent;
                                    settings.OmitXmlDeclaration = omitXmlDeclaration;
                                    settings.WriteEndDocumentOnClose = writeEndDocumentOnClose;
                                    XmlWriter writer = XmlWriter.Create(ms, settings);
                                    writer.WriteStartDocument();
                                    writer.WriteStartElement("root");
                                    writer.WriteStartElement("test");
                                    writer.WriteString("abc");
                                    // !!! intentionally not closing both elements
                                    // !!! writer.WriteEndElement();
                                    // !!! writer.WriteEndElement();
                                    writer.Dispose();

                                    if (closeOutput)
                                    {
                                        bool failed = true;
                                        try
                                        {
                                            ms.WriteByte(123);
                                        }
                                        catch (ObjectDisposedException) { failed = false; }
                                        if (failed)
                                        {
                                            throw new Exception("Failed!");
                                        }
                                    }
                                    else
                                    {
                                        string output = ReadAsString(ms);
                                        Assert.True(output.Contains("<test>abc"));
                                        Assert.NotEqual(output.Contains("<?xml version"), omitXmlDeclaration);
                                        Assert.Equal(output.Contains("  "), indent);
                                        Assert.Equal(output.Contains("</test>"), writeEndDocumentOnClose);
                                    }

                                    // should not throw
                                    writer.Dispose();
                                }
                            }
        }

        //[Variation(id=2, Desc="Default value of OmitXmlDeclaration")]
        public int default_2()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            CError.Compare(wSettings.OmitXmlDeclaration, false, "Incorrect default value of OmitXmlDeclaration");

            return TEST_PASS;
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        public XmlQueryStaticData(XmlWriterSettings defaultWriterSettings, IList<WhitespaceRule> whitespaceRules, StaticDataManager staticData)
        {
            Debug.Assert(defaultWriterSettings != null && staticData != null);
            _defaultWriterSettings = defaultWriterSettings;
            _whitespaceRules = whitespaceRules;
            _names = staticData.Names;
            _prefixMappingsList = staticData.PrefixMappingsList;
            _filters = staticData.NameFilters;
            _types = staticData.XmlTypes;
            _collations = staticData.Collations;
            _globalNames = staticData.GlobalNames;
            _earlyBound = staticData.EarlyBound;

#if DEBUG
            // Round-trip check
            byte[] data;
            Type[] ebTypes;
            this.GetObjectData(out data, out ebTypes);
            XmlQueryStaticData copy = new XmlQueryStaticData(data, ebTypes);

            _defaultWriterSettings = copy._defaultWriterSettings;
            _whitespaceRules = copy._whitespaceRules;
            _names = copy._names;
            _prefixMappingsList = copy._prefixMappingsList;
            _filters = copy._filters;
            _types = copy._types;
            _collations = copy._collations;
            _globalNames = copy._globalNames;
            _earlyBound = copy._earlyBound;
#endif
        }

	public static void SaveXmlLevel(ABLevel level) {

		StringBuilder output = new StringBuilder();
		XmlWriterSettings ws = new XmlWriterSettings();
		ws.Indent = true;

		using (XmlWriter writer = XmlWriter.Create(output, ws))
		{
			writer.WriteStartElement("Level");

			writer.WriteStartElement("BirdsAmount");
			writer.WriteValue(level.birdsAmount);
			writer.WriteEndElement();

			writer.WriteStartElement("GameObjects");

			foreach(ABGameObject abObj in level.gameObjects)
			{
				writer.WriteStartElement("GameObject");
				writer.WriteAttributeString("label", abObj.Label.ToString());
				writer.WriteAttributeString("x", abObj.Position.x.ToString());
				writer.WriteAttributeString("y", abObj.Position.y.ToString());
				writer.WriteEndElement();
			}
		}

		int levelsAmountInResources = LoadAllLevels().Length;

		StreamWriter streamWriter = new StreamWriter("Assets/Resources/GeneratedLevels/genetic-level-" + (levelsAmountInResources + 1) + ".xml");
		streamWriter.WriteLine(output.ToString());
		streamWriter.Close();
	}

        public static void WriteWithEncoding()
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.OmitXmlDeclaration = true;
            settings.ConformanceLevel = ConformanceLevel.Fragment;
            settings.CloseOutput = false;
            settings.Encoding = Encoding.GetEncoding("Windows-1252");
            MemoryStream strm = new MemoryStream();

            using (XmlWriter writer = XmlWriter.Create(strm, settings))
            {
                writer.WriteElementString("orderID", "1-456-ab\u0661");
                writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
                writer.Flush();
            }

            strm.Seek(0, SeekOrigin.Begin);
            byte[] bytes = new byte[strm.Length];
            int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
            string s = settings.Encoding.GetString(bytes, 0, bytesCount);

            Assert.Equal("<orderID>1-456-ab&#x661;</orderID><orderID>2-36-00a&#x10000;&#x10401;</orderID>", s);
        }

 private static XmlWriter CreateUtf8Writer()
 {
     MemoryStream output = new MemoryStream();
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.Encoding = Encoding.UTF8;
     return XmlWriter.Create(output, settings);
 }

    void XmlTest()
    {
        XElement root = new XElement ("root");
        for (int i = 0; i < 3; i ++) {
            XElement item = new XElement ("item");
            item.Add (new XAttribute ("1item" + i.ToString (), i));
            item.Add (new XAttribute ("2item" + i.ToString (), i));
            item.Add (new XAttribute ("3item" + i.ToString (), i));
        }
        using (FileStream fs = new FileStream( Application.dataPath + "/test.xml",FileMode.Create)) {
            XmlWriterSettings setting = new XmlWriterSettings ();
            setting.Indent = true;
            setting.IndentChars = "\t";
            setting.NewLineChars = "\n";
            setting.Encoding = Encoding.UTF8;
            using (XmlWriter xw = XmlWriter.Create(fs, setting)) {
                root.WriteTo (xw);
            }
        }

        //		using(FileStream fs = new FileStream( FILE_DIR + "/" + "ServerConfig/terrainEditorConfig.xml", FileMode.Create ) )
        //		{
        //			XmlWriterSettings setting = new XmlWriterSettings();
        //			setting.Indent = true;
        //			setting.IndentChars = "\t";
        //			setting.NewLineChars = "\n";
        //			setting.Encoding = Encoding.UTF8;
        //			using (XmlWriter xw = XmlWriter.Create(fs, setting))
        //			{
        //				root.WriteTo(xw);
        //			}
        //		}
        //	}
    }

        public static void XmlWriterConvertsSurrogatePairToEntity()
        {
            MemoryStream ms = new MemoryStream();
            XmlWriterSettings settings = new XmlWriterSettings();

            // Code page: 367
            settings.Encoding = Encoding.GetEncoding("us-ascii");

            string problematicString = "ABCDEF" + s_ExampleSurrogate + "GHI";
            string problematicStringAfterFallback = "ABCDEF" + ExampleSurrogateEntity + "GHI";

            using (XmlWriter writer = XmlWriter.Create(ms, settings))
            {
                writer.WriteStartDocument();
                writer.WriteElementString("test", problematicString);
                writer.Flush();
            }

            ms.Position = 0;
            StreamReader sr = new StreamReader(ms);
            string output = sr.ReadToEnd();

            string expectedOutput = "<?xml version=\"1.0\" encoding=\"us-ascii\"?><test>" + problematicStringAfterFallback + "</test>";
            Assert.Equal(expectedOutput, output);
        }

	private bool parseXMLFile(IsolatedStorageFileStream xmlFile)
	{
		values.Clear();

		string key = "";

		// Create an XmlReader
		using (XmlReader reader = XmlReader.Create(xmlFile)) {
			XmlWriterSettings ws = new XmlWriterSettings();
			ws.Indent = false;
				// Parse the file and display each of the nodes.
				while (reader.Read()) {
					switch (reader.NodeType) {
						case XmlNodeType.Element:
							key = reader.Name;
							break;
						case XmlNodeType.Text:
							values.Add(key, reader.Value);
							break;
						case XmlNodeType.XmlDeclaration:
						case XmlNodeType.ProcessingInstruction:
							break;
						case XmlNodeType.Comment:
							break;
						case XmlNodeType.EndElement:
							break;
					}
				}
		}
		return true;
	}

    public override string Serialize()
    {
        MemoryStream memoryStream = new MemoryStream();
        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
        xmlWriterSettings.Encoding = new UTF8Encoding(false);
        xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document;
        xmlWriterSettings.Indent = true;

        using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
        {
            xmlWriter.WriteStartElement("behavior");

                xmlWriter.WriteStartElement("name");
                    xmlWriter.WriteString(gameObject.name);
                xmlWriter.WriteEndElement(); // End of Name node

                xmlWriter.WriteStartElement("finiteStateMachine");
                    foreach (FSMNodeWithTransitions node in readNodes)
                    {
                        xmlWriter.WriteStartElement("state");
                        xmlWriter.WriteAttributeString("node", node.NodeName);

                        /*
                        if (firstNode) {
                            writer.WriteAttributeString("type", "initial-final");
                            firstNode = false;
                        } else {
                            writer.WriteAttributeString("type", "final");
                        }
                        */

                        foreach (FSMTransition transition in node.Transitions)
                        {
                            xmlWriter.WriteStartElement("transition");
                                //xmlWriter.WriteAttributeString("action", transition.ActionName + transition.Argument);
                                xmlWriter.WriteAttributeString("action", transition.ActionName);

                                /*
                                writer.WriteStartElement("invocation-parameter");
                                writer.WriteAttributeString("value", transition.Argument);
                                writer.WriteEndElement(); // End of Invocation-Parametere node
                                */

                                xmlWriter.WriteStartElement("target");
                                    xmlWriter.WriteString(transition.Argument);
                                xmlWriter.WriteEndElement(); // End of Target node

                            xmlWriter.WriteEndElement(); //End of Transition node
                        }

                        xmlWriter.WriteEndElement(); // End of State node
                    }
                xmlWriter.WriteEndElement(); // End of FiniteStateMachine node

            xmlWriter.WriteEndElement(); // End of Behavior node
        }

        return Encoding.UTF8.GetString(memoryStream.ToArray());
    }