using System;
using System.Xml;
using System.IO;
using System.Text;

class MainClass {
    private static void Main() {
        FileStream fs = new FileStream("products.xml", FileMode.Create);

        XmlWriter w = XmlWriter.Create(fs);

        w.WriteStartDocument();
        w.WriteStartElement("products");

        w.WriteStartElement ("product");
        w.WriteAttributeString("id", "1001");
        w.WriteElementString("productName", "Gourmet Coffee");
        w.WriteElementString("productPrice", "0.99");
        w.WriteEndElement();

        w.WriteStartElement("product");
        w.WriteAttributeString("id", "1002");
        w.WriteElementString("productName", "Tea Pot");
        w.WriteElementString("productPrice", "12.99");
        w.WriteEndElement();

        w.WriteEndElement();
        w.WriteEndDocument();
        w.Flush();
        fs.Close();

    }
}

           
          

   
 
#region License and Copyright
/*
 * Dotnet Commons Xml
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 */
#endregion

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.Serialization;

//using Dotnet.Commons.Reflection;

namespace Dotnet.Commons.Xml
{
  
  ///  
  /// <summary>
  /// This utility class contains wrapper functions that help to ease the handling and 
    /// manipulation of Xml documents, such as adding an element, adding an attribute
    /// to an element, copying and cloning of nodes, etc.
  ///
  /// </summary>
  /// 
    
  public abstract class XmlUtils
  {
    /// -----------------------------------------------------------
    /// <summary>
    /// Pretty Print XML
    /// </summary>
    /// <param name="xml"></param>
    /// <returns>Pretty print xml string</returns>
    /// <remarks> Thanks to http://dotnet.editme.com/codePrettyPrintXML</remarks>
    /// -----------------------------------------------------------
    public static string PrettyPrint(string xml)
    {
      XmlDocument xmlDom   = new XmlDocument();

      // Load the XmlDocument with the XML.
      xmlDom.LoadXml(xml);

      return PrettyPrint(xmlDom);
    }


    /// -----------------------------------------------------------
    /// <summary>
        /// Print Print an <see cref="XmlDocument"/>
    /// </summary>
    /// <param name="xmlDom"></param>
    /// <returns></returns>
    /// -----------------------------------------------------------
    public static string PrettyPrint(XmlDocument xmlDom)
    {
            return PrettyPrint(xmlDom, true);
    }


        /// <summary>
        /// Print Print an <see cref="XmlNode"/>
        /// </summary>
        /// <param name="xmlNode"></param>
        /// <returns></returns>
        public static string PrettyPrint(XmlNode xmlNode)
        {
            return PrettyPrint(xmlNode, false);
        }


        /// <summary>
        /// Pretty Print an <see cref="XmlDocument"/> or an <see cref="XmlNode"/>
        /// </summary>
        /// <param name="xmlObj"></param>
        /// <param name="isXmlDoc"></param>
        /// <returns></returns>
        public static string PrettyPrint(object xmlObj, bool isXmlDoc)
        {

            if (!(xmlObj is XmlDocument || xmlObj is XmlDataDocument ||
                xmlObj is XmlNode || xmlObj is XmlElement))
                throw new ArgumentException("xmlObj must be either an XmlDocument, XmlDataDocument, XmlNode or an XmlElement object");

            String prettyXml = "";

            MemoryStream memStream = new MemoryStream();
            XmlTextWriter xmlTextWriter = new XmlTextWriter(memStream, Encoding.Unicode);

            try
            {
                xmlTextWriter.Formatting = Formatting.Indented;
                xmlTextWriter.Indentation = 4;
                xmlTextWriter.QuoteChar = &#039;&#039;&#039;;


                // Write the XML into a formatting XmlTextWriter
                if (xmlObj is XmlDocument)
                    ((XmlDocument)xmlObj).WriteContentTo(xmlTextWriter);
                else if (xmlObj is XmlDataDocument)
                    ((XmlDataDocument)xmlObj).WriteContentTo(xmlTextWriter);
                else
                    ((XmlNode)xmlObj).ParentNode.WriteContentTo(xmlTextWriter);

                
                xmlTextWriter.Flush();
                memStream.Flush();

                // Have to rewind the MemoryStream in order to read
                // its contents.
                memStream.Position = 0;

                // Read MemoryStream contents into a StreamReader.
                StreamReader streamReader = new StreamReader(memStream);

                // Extract the text from the StreamReader.
                String sFormattedXML = streamReader.ReadToEnd();

                prettyXml = sFormattedXML;
            }
            catch
            {
            }

            memStream.Close();
            xmlTextWriter.Close();

            return prettyXml;
        }
    }
}

   
     

   
 

using System;
using System.Windows.Forms;
using System.Xml;

public class XmlTreeDisplay : System.Windows.Forms.Form{
    private System.Windows.Forms.TreeView treeXml = new TreeView();

    public XmlTreeDisplay() {
        treeXml.Nodes.Clear();
        this.Controls.Add(treeXml);
        // Load the XML Document
        XmlDocument doc = new XmlDocument();
        try {
            doc.Load("books.xml");
        }catch (Exception err) {

            MessageBox.Show(err.Message);
            return;
        }

        ConvertXmlNodeToTreeNode(doc, treeXml.Nodes);
        treeXml.Nodes[0].ExpandAll();
    }

    private void ConvertXmlNodeToTreeNode(XmlNode xmlNode, 
      TreeNodeCollection treeNodes) {

        TreeNode newTreeNode = treeNodes.Add(xmlNode.Name);

        switch (xmlNode.NodeType) {
            case XmlNodeType.ProcessingInstruction:
            case XmlNodeType.XmlDeclaration:
                newTreeNode.Text = "<?" + xmlNode.Name + " " + 
                  xmlNode.Value + "?>";
                break;
            case XmlNodeType.Element:
                newTreeNode.Text = "<" + xmlNode.Name + ">";
                break;
            case XmlNodeType.Attribute:
                newTreeNode.Text = "ATTRIBUTE: " + xmlNode.Name;
                break;
            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
                newTreeNode.Text = xmlNode.Value;
                break;
            case XmlNodeType.Comment:
                newTreeNode.Text = "<!--" + xmlNode.Value + "-->";
                break;
        }

        if (xmlNode.Attributes != null) {
            foreach (XmlAttribute attribute in xmlNode.Attributes) {
                ConvertXmlNodeToTreeNode(attribute, newTreeNode.Nodes);
            }
        }
        foreach (XmlNode childNode in xmlNode.ChildNodes) {
            ConvertXmlNodeToTreeNode(childNode, newTreeNode.Nodes);
        }
    }
    public static void Main(){
       Application.Run(new XmlTreeDisplay());
    }
}
/*
<books>
  <A property="a">
    <B>text</B>
    <C>textg</C>
    <D>99999</D>
  </A>
</books>
*/

           
         
     

   

using System;
using System.Xml;           
using System.Xml.Xsl;       
using System.Xml.XPath;     
using System.IO;            

  public class XSLDemo
  {
    [STAThread]
    static void Main(string[] args)
    {
      XslTransform xslt = new XslTransform();
      xslt.Load("XSLTemplate.xsl");
      XPathDocument xDoc = new XPathDocument("Books.xml");
      XmlTextWriter writer = new XmlTextWriter("Books.html", null);
      xslt.Transform(xDoc, null, writer, new XmlUrlResolver());
      writer.Close();
      StreamReader stream = new StreamReader("Books.html");
      Console.Write(stream.ReadToEnd());
    }
  }
/*
<books>
  <book category="A">
    <title>title</title>
    <author>Tom</author>
    <price>19.95</price>
  </book>
  <book category="B">
    <title>title 2</title>
    <author>Jack</author>
    <price>9.95</price>
  </book>
</books>
*/

/*
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match = "/" >

<html>
<head><title>A list of books</title></head>
<style>
.headerClass { background-color=#ffeedd; }
</style>
<body>
<B>List of books</B>
<table border="1">
<tr>
  <td class="headerClass">Title</td>
  <td class="headerClass">Author</td>
  <td class="headerClass">Price</td>
</tr>
<xsl:for-each select="//books/book">
<tr>
  <td><xsl:value-of select="title"/></td>
  <td><xsl:value-of select="author"/></td>
  <td><xsl:value-of select="price"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>

</xsl:template>
</xsl:stylesheet>

*/

           
          

   

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy

Publisher: Sybex;
ISBN: 0782129110
*/


/*
  Example20_3.cs illustrates the XslTransform class
*/

using System;
using System.Xml;
using System.Xml.Xsl;
using System.IO;

public class Example20_3 
{

    public static void Main() 
    {

        // use an XmlTextReader to open an XML document
        XmlTextReader xtr = new XmlTextReader("Cust3.xml");
        xtr.WhitespaceHandling = WhitespaceHandling.None;

        // load the file into an XmlDocuent
        XmlDocument xd = new XmlDocument();
        xd.Load(xtr);
        
        // load an XSLT file
        XslTransform xslt = new XslTransform();
        xslt.Load("Cust.xsl");

        // perform the transformation in memory
        MemoryStream stm = new MemoryStream();
        xslt.Transform(xd, null, stm);

        // and dump the results
        stm.Position = 1;
        StreamReader sr = new StreamReader(stm);
        Console.Write(sr.ReadToEnd());

        // close the reader
        xtr.Close();
    }

}

//File:Cust3.xml
/*
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="Cust.xsl"?>
<NewDataSet>
    <Customers>
        <CustomerID>ALFKI</CustomerID>
        <CompanyName>Alfreds Futterkiste</CompanyName>
        <ContactName>Maria Anders</ContactName>
        <ContactTitle>Sales Representative</ContactTitle>
        <Address>Obere Str. 57</Address>
        <City>Berlin</City>
        <PostalCode>12209</PostalCode>
        <Country>Germany</Country>
        <Phone>030-0074321</Phone>
        <Fax>030-0076545</Fax>
    </Customers>
    <Customers>
        <CustomerID>BONAP</CustomerID>
        <CompanyName>A Company</CompanyName>
        <ContactName>Laurence Lebihan</ContactName>
        <ContactTitle>Owner</ContactTitle>
        <Address>12, rue des Bouchers</Address>
        <City>Marseille</City>
        <PostalCode>13008</PostalCode>
        <Country>France</Country>
        <Phone>91.24.45.40</Phone>
        <Fax>91.24.45.41</Fax>
    </Customers>
</NewDataSet>

*/

//File:Cust.xsl
/*
<?xml version="1.0" encoding="UTF-8"?>
<html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<body>
    <xsl:for-each select="/NewDataSet/Customers">
        <p><h2>Customer</h2>
         <br><b><xsl:value-of select="CustomerID"/></b></br>
         <br><xsl:value-of select="CompanyName"/></br>
         <br><xsl:value-of select="ContactName"/></br></p>
    </xsl:for-each>
</body>
</html>


*/

           
          

   

using System;
using System.Xml.Xsl;

public class Transform {
  public static void Main(string [] args) {
    string source = args[0];
    string stylesheet = args[1];
    string destination = args[2];

    XslTransform transform = new XslTransform();
    transform.Load(stylesheet);
    // for .NET v 1.0
    //transform.Transform(source, destination);
    // for .NET v 1.1
    transform.Transform(source, destination, null);
  }
}


           
          

   


using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Xml.Xsl;


public class TransformXml {
    private static void Main() {
        XslTransform transform = new XslTransform();
            
        // Load the XSL stylesheet.
        transform.Load("orders.xslt");
            
        // Transform orders.xml into orders.html using orders.xslt.
        transform.Transform("orders.xml", "orders.html", null);
    }
}