using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
[XmlRoot("productCatalog")]
class ProductCatalog {
[XmlElement("catalogName")]
public string CatalogName;
[XmlElement(ElementName = "expiryDate", DataType = "date")]
public DateTime ExpiryDate;
[XmlArray("products")]
[XmlArrayItem("product")]
public Product[] Products;
public ProductCatalog() { }
public ProductCatalog(string catalogName, DateTime expiryDate) {
this.CatalogName = catalogName;
this.ExpiryDate = expiryDate;
}
}
public class Product {
[XmlElement("productName")]
public string ProductName;
[XmlElement("productPrice")]
public decimal ProductPrice;
[XmlElement("inStock")]
public bool InStock;
[XmlAttributeAttribute(AttributeName = "id", DataType = "integer")]
public string Id;
public Product() {}
public Product(string productName, decimal productPrice) {
this.ProductName = productName;
this.ProductPrice = productPrice;
}
}
public class MainClass {
private static void Main() {
ProductCatalog catalog = new ProductCatalog("New Catalog", DateTime.Now.AddYears(1));
Product[] products = new Product[2];
products[0] = new Product("Product 1", 42.99m);
products[1] = new Product("Product 2", 202.99m);
catalog.Products = products;
XmlSerializer serializer = new XmlSerializer(typeof(ProductCatalog));
FileStream fs = new FileStream("ProductCatalog.xml", FileMode.Create);
serializer.Serialize(fs, catalog);
fs.Close();
catalog = null;
fs = new FileStream("ProductCatalog.xml", FileMode.Open);
catalog = (ProductCatalog)serializer.Deserialize(fs);
serializer.Serialize(Console.Out, catalog);
}
}
Author: coder
Set Xml Attribute when serilzation
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
public class MainClass {
public static void Main() {
Product pd = new Product();
pd.ProductID = 200;
pd.CategoryID = 100;
pd.Discontinued = false;
pd.ProductName = "Serialize Objects";
pd.QuantityPerUnit = "6";
pd.ReorderLevel = 1;
pd.SupplierID = 1;
pd.UnitPrice = 1000;
pd.UnitsInStock = 10;
pd.UnitsOnOrder = 0;
TextWriter tr = new StreamWriter("serialprod.xml");
XmlSerializer sr = new XmlSerializer(typeof(Product));
sr.Serialize(tr, pd);
tr.Close();
}
}
[System.Xml.Serialization.XmlRootAttribute()]
public class Product {
private int prodId;
private string prodName;
private int suppId;
private int catId;
private string qtyPerUnit;
private Decimal unitPrice;
private short unitsInStock;
private short unitsOnOrder;
private short reorderLvl;
private bool discont;
private int disc;
//added the Discount attribute
[XmlAttributeAttribute(AttributeName = "Discount")]
public int Discount {
get { return disc; }
set { disc = value; }
}
[XmlElementAttribute()]
public int ProductID {
get { return prodId; }
set { prodId = value; }
}
[XmlElementAttribute()]
public string ProductName {
get { return prodName; }
set { prodName = value; }
}
[XmlElementAttribute()]
public int SupplierID {
get { return suppId; }
set { suppId = value; }
}
[XmlElementAttribute()]
public int CategoryID {
get { return catId; }
set { catId = value; }
}
[XmlElementAttribute()]
public string QuantityPerUnit {
get { return qtyPerUnit; }
set { qtyPerUnit = value; }
}
[XmlElementAttribute()]
public Decimal UnitPrice {
get { return unitPrice; }
set { unitPrice = value; }
}
[XmlElementAttribute()]
public short UnitsInStock {
get { return unitsInStock; }
set { unitsInStock = value; }
}
[XmlElementAttribute()]
public short UnitsOnOrder {
get { return unitsOnOrder; }
set { unitsOnOrder = value; }
}
[XmlElementAttribute()]
public short ReorderLevel {
get { return reorderLvl; }
set { reorderLvl = value; }
}
[XmlElementAttribute()]
public bool Discontinued {
get { return discont; }
set { discont = value; }
}
}
public class Inventory {
private Product[] stuff;
public Inventory() { }
[XmlArrayItem("Prod", typeof(Product)),
XmlArrayItem("Book", typeof(BookProduct))]
public Product[] InventoryItems {
get { return stuff; }
set { stuff = value; }
}
}
public class BookProduct : Product {
private string isbnNum;
public BookProduct() { }
public string ISBN {
get { return isbnNum; }
set { isbnNum = value; }
}
}
Use XmlSerializer
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
public class MainClass { //new products object
public static void Main() {
Product newPd;
FileStream f = new FileStream("serialprod.xml", FileMode.Open);
XmlSerializer newSr = new XmlSerializer(typeof(Product));
newPd = (Product)newSr.Deserialize(f);
f.Close();
}
}
[System.Xml.Serialization.XmlRootAttribute()]
public class Product {
private int prodId;
private string prodName;
private int suppId;
private int catId;
private string qtyPerUnit;
private Decimal unitPrice;
private short unitsInStock;
private short unitsOnOrder;
private short reorderLvl;
private bool discont;
private int disc;
[XmlAttributeAttribute(AttributeName = "Discount")]
public int Discount {
get { return disc; }
set { disc = value; }
}
[XmlElementAttribute()]
public int ProductID {
get { return prodId; }
set { prodId = value; }
}
[XmlElementAttribute()]
public string ProductName {
get { return prodName; }
set { prodName = value; }
}
[XmlElementAttribute()]
public int SupplierID {
get { return suppId; }
set { suppId = value; }
}
[XmlElementAttribute()]
public int CategoryID {
get { return catId; }
set { catId = value; }
}
[XmlElementAttribute()]
public string QuantityPerUnit {
get { return qtyPerUnit; }
set { qtyPerUnit = value; }
}
[XmlElementAttribute()]
public Decimal UnitPrice {
get { return unitPrice; }
set { unitPrice = value; }
}
[XmlElementAttribute()]
public short UnitsInStock {
get { return unitsInStock; }
set { unitsInStock = value; }
}
[XmlElementAttribute()]
public short UnitsOnOrder {
get { return unitsOnOrder; }
set { unitsOnOrder = value; }
}
[XmlElementAttribute()]
public short ReorderLevel {
get { return reorderLvl; }
set { reorderLvl = value; }
}
[XmlElementAttribute()]
public bool Discontinued {
get { return discont; }
set { discont = value; }
}
}
public class Inventory {
private Product[] stuff;
public Inventory() { }
[XmlArrayItem("Prod", typeof(Product)),
XmlArrayItem("Book", typeof(BookProduct))]
public Product[] InventoryItems {
get { return stuff; }
set { stuff = value; }
}
}
public class BookProduct : Product {
private string isbnNum;
public BookProduct() { }
public string ISBN {
get { return isbnNum; }
set { isbnNum = value; }
}
}
Serialize List of Objects
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;
using System.Collections;
[Serializable]
public class Radio {
public bool hasTweeters;
public bool hasSubWoofers;
public double[] stationPresets;
[NonSerialized]
public string radioID = "002";
}
[Serializable]
public class Car {
public Radio theRadio = new Radio();
public bool isHatchBack;
}
[Serializable, XmlRoot(Namespace = "http://www.yoursite.com")]
public class MyCar : Car {
public MyCar(bool SkyWorthy, bool SeaWorthy) {
canFly = SkyWorthy;
canSubmerge = SeaWorthy;
}
public MyCar() { }
[XmlAttribute]
public bool canFly;
[XmlAttribute]
public bool canSubmerge;
}
class Program {
static void Main(string[] args) {
MyCar jbc = new MyCar();
jbc.canFly = true;
jbc.canSubmerge = false;
jbc.theRadio.stationPresets = new double[] { 89.3, 105.1, 97.1 };
jbc.theRadio.hasTweeters = true;
BinaryFormatter binFormat = new BinaryFormatter();
Stream fStream = new FileStream("CarData.dat",FileMode.Create, FileAccess.Write, FileShare.None);
binFormat.Serialize(fStream, jbc);
fStream.Close();
fStream = File.OpenRead("CarData.dat");
MyCar carFromDisk =(MyCar)binFormat.Deserialize(fStream);
fStream.Close();
SoapFormatter soapForamt = new SoapFormatter();
fStream = new FileStream("CarData.soap",FileMode.Create, FileAccess.Write, FileShare.None);
soapForamt.Serialize(fStream, jbc);
fStream.Close();
XmlSerializer xmlForamt = new XmlSerializer(typeof(MyCar),new Type[] { typeof(Radio), typeof(Car) });
fStream = new FileStream("CarData.xml",FileMode.Create, FileAccess.Write, FileShare.None);
xmlForamt.Serialize(fStream, jbc);
fStream.Close();
ArrayList myCars = new ArrayList();
myCars.Add(new MyCar(true, true));
myCars.Add(new MyCar(true, false));
myCars.Add(new MyCar(false, true));
myCars.Add(new MyCar(false, false));
fStream = new FileStream("CarCollection.xml",FileMode.Create, FileAccess.Write, FileShare.None);
xmlForamt = new XmlSerializer(typeof(ArrayList),new Type[] { typeof(MyCar), typeof(Car), typeof(Radio) });
xmlForamt.Serialize(fStream, myCars);
fStream.Close();
}
}
Convert a stream of text lines separated with newline sequences into an XML build result.
//CruiseControl is open source software and is developed and maintained by a group of dedicated volunteers.
//CruiseControl is distributed under a BSD-style license.
//http://cruisecontrol.sourceforge.net/
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
namespace ThoughtWorks.CruiseControl.Core.Util
{
/// <summary>
/// Class with handy stirng routines
/// </summary>
public class StringUtil
{
/// <summary>
/// Convert a stream of text lines separated with newline sequences into an XML build result.
/// </summary>
/// <param name="input">the text stream</param>
/// <param name="msgLevel">the message level, if any. Values are "Error" and "Warning".</param>
/// <returns>the build result string</returns>
/// <remarks>If there are any non-blank lines in the input, they are each wrapped in a
/// <code>&lt;message&gt;</code> element and the entire set is wrapped in a
/// <code>&lt;buildresults&gt;</code> element and returned. Each line of the input is encoded
/// as XML CDATA rules require. If the input is empty or contains only whitspace, an
/// empty string is returned.
/// Note: If we can't manage to understand the input, we just return it unchanged.
/// </remarks>
public static string MakeBuildResult(string input, string msgLevel)
{
StringBuilder sb = new StringBuilder();
// Pattern for capturing a line of text, exclusive of the line-ending sequence.
// A "line" is an non-empty unbounded sequence of characters followed by some
// kind of line-ending sequence (CR, LF, or any combination thereof) or
// end-of-string.
Regex linePattern = new Regex(@"([^
]+)");
MatchCollection lines = linePattern.Matches(input);
if (lines.Count > 0)
{
sb.Append(Environment.NewLine);
sb.Append("<buildresults>");
sb.Append(Environment.NewLine);
foreach (Match line in lines)
{
sb.Append(" <message");
if (msgLevel != string.Empty)
sb.AppendFormat(" level="{0}"", msgLevel);
sb.Append(">");
sb.Append(line.ToString());
sb.Append("</message>");
sb.Append(Environment.NewLine);
}
sb.Append("</buildresults>");
sb.Append(Environment.NewLine);
}
else
sb.Append(input); // All of that stuff failed, just return our input
return sb.ToString();
}
}
}
Gets an appropriate System.Xml.XmlReader implementation for the supplied System.IO.Stream
#region License
/*
* Copyright 2002-2004 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
#region Imports
using System;
using System.Configuration;
using System.Xml;
using System.IO;
using System.Xml.Schema;
#endregion
namespace Spring.Util
{
/// <summary>
/// XML utility methods.
/// </summary>
/// <author>Aleksandar Seovic</author>
public class XmlUtils
{
#if !NET_2_0
/// <summary>
/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <param name="schemas">XML schemas that should be used for validation.</param>
/// <param name="eventHandler">Validation event handler.</param>
/// <returns>
/// A validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateValidatingReader(Stream stream, XmlSchemaCollection schemas, ValidationEventHandler eventHandler)
{
return CreateValidatingReader(stream, new XmlUrlResolver(), schemas, eventHandler);
}
/// <summary>
/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <param name="xmlResolver"><see cref="XmlResolver"/> to be used for resolving external references</param>
/// <param name="schemas">XML schemas that should be used for validation.</param>
/// <param name="eventHandler">Validation event handler.</param>
/// <returns>
/// A validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateValidatingReader(Stream stream, XmlResolver xmlResolver, XmlSchemaCollection schemas, ValidationEventHandler eventHandler)
{
XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader(stream));
reader.XmlResolver = xmlResolver;
reader.Schemas.Add(schemas);
reader.ValidationType = ValidationType.Schema;
if (eventHandler != null)
{
reader.ValidationEventHandler += eventHandler;
}
return reader;
}
#else
/// <summary>
/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <param name="schemas">XML schemas that should be used for validation.</param>
/// <param name="eventHandler">Validation event handler.</param>
/// <returns>
/// A validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateValidatingReader(Stream stream, XmlSchemaSet schemas, ValidationEventHandler eventHandler)
{
return CreateValidatingReader(stream, new XmlUrlResolver(), schemas, eventHandler);
}
/// <summary>
/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <param name="xmlResolver"><see cref="XmlResolver"/> to be used for resolving external references</param>
/// <param name="schemas">XML schemas that should be used for validation.</param>
/// <param name="eventHandler">Validation event handler.</param>
/// <returns>
/// A validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateValidatingReader(Stream stream, XmlResolver xmlResolver, XmlSchemaSet schemas, ValidationEventHandler eventHandler)
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas.XmlResolver = xmlResolver;
settings.Schemas.Add(schemas);
settings.ValidationType = ValidationType.Schema;
if (eventHandler != null)
{
settings.ValidationEventHandler += eventHandler;
}
return XmlReader.Create(stream, settings);
}
#endif
#if !NET_2_0
/// <summary>
/// Gets an <see cref="System.Xml.XmlTextReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <returns>
/// A non-validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateReader(Stream stream)
{
return new XmlTextReader(stream);
}
#else
/// <summary>
/// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation
/// for the supplied <see cref="System.IO.Stream"/>.
/// </summary>
/// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param>
/// <returns>
/// A non-validating <see cref="System.Xml.XmlReader"/> implementation.
/// </returns>
public static XmlReader CreateReader(Stream stream)
{
return XmlReader.Create(stream);
}
#endif
}
}
Remove empty tags in the Xml string
#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>
/// Remove empty tags in the Xml string
/// </summary>
/// <param name="sXML"></param>
/// <returns></returns>
/// <remarks>Thanks to http://dotnet.editme.com/codeCleanXML</remarks>
/// -----------------------------------------------------------
public static string RemoveEmptyTags(string sXML)
{
System.Text.StringBuilder sb = new StringBuilder();
sb.Append("<?xml version="1.0" encoding="UTF-8"?>");
sb.Append("<xsl:stylesheet ");
sb.Append(" version="1.0" ");
sb.Append(" xmlns:msxsl="urn:schemas-microsoft-com:xslt"");
sb.Append(" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">");
sb.Append(" <xsl:output method="xml" version="1.0" encoding="UTF-8"/>");
sb.Append(" <!-- Whenever you match any node or any attribute -->");
sb.Append(" <xsl:template match="node()|@*">");
sb.Append(" <!-- Copy the current node -->");
sb.Append(" <xsl:if test="normalize-space(.) != '' or normalize-space(./@*) != '' ">");
sb.Append(" <xsl:copy>");
sb.Append(" <!-- Including any attributes it has and any child nodes -->");
sb.Append(" <xsl:apply-templates select="@*|node()"/>");
sb.Append(" </xsl:copy>");
sb.Append(" </xsl:if>");
sb.Append(" </xsl:template>");
sb.Append("</xsl:stylesheet>");
return transXMLStringThroughXSLTString(sXML, sb.ToString());
}
private static string transXMLStringThroughXSLTString(string sXML, string sXSLT)
{
//This is the logic of the application.
XslCompiledTransform objTransform = new XslCompiledTransform();
StringReader xmlStream = new StringReader(sXML);
XmlReader xmlReader = new XmlTextReader(xmlStream);
StringReader stream = new StringReader(sXSLT);
XmlReader xmlReaderXslt = new XmlTextReader(stream);
objTransform.Load(xmlReaderXslt, null, null);
StringWriter objStream = new StringWriter();
objTransform.Transform(xmlReader, null, objStream);
return objStream.ToString().Replace(@"encoding=""utf-16""?>", @"encoding=""utf-8""?>");
}
}
}