/*
Copyright (c) 2010 <a href="http://www.gutgames.com">James Craig</a>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.*/
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Text;
using System.Xml.Serialization;
namespace Utilities
{
/// <summary>
/// Utility class for managing files
/// </summary>
public static class FileManager
{
/// <summary>
/// Gets a files' contents
/// </summary>
/// <param name="FileName">File name</param>
/// <returns>a string containing the file's contents</returns>
public static string GetFileContents(string FileName)
{
try
{
return GetFileContents(FileName, 5000);
}
catch { throw; }
}
/// <summary>
/// Gets a files' contents
/// </summary>
/// <param name="FileName">File name</param>
/// <param name="TimeOut">Amount of time in ms to wait for the file</param>
/// <returns>a string containing the file's contents</returns>
public static string GetFileContents(string FileName, int TimeOut)
{
StreamReader Reader = null;
int StartTime = System.Environment.TickCount;
try
{
bool Opened = false;
while (!Opened)
{
try
{
if (System.Environment.TickCount - StartTime >= TimeOut)
throw new System.IO.IOException("File opening timed out");
Reader = File.OpenText(FileName);
Opened = true;
}
catch (System.IO.IOException e)
{
throw e;
}
}
string Contents = Reader.ReadToEnd();
Reader.Close();
return Contents;
}
catch
{
return "";
}
finally
{
if (Reader != null)
{
Reader.Close();
Reader.Dispose();
}
}
}
}
/// <summary>
/// Helps with serializing an object to XML and back again.
/// </summary>
public static class Serialization
{
/// <summary>
/// Takes an XML file and exports the Object it holds
/// </summary>
/// <param name="FileName">File name to use</param>
/// <param name="Object">Object to export to</param>
public static void XMLToObject<T>(string FileName, out T Object)
{
if (string.IsNullOrEmpty(FileName))
{
throw new ArgumentException("File name can not be null/empty");
}
try
{
string FileContent = FileManager.GetFileContents(FileName);
Object = XMLToObject<T>(FileContent);
}
catch { throw; }
}
/// <summary>
/// Converts an XML string to an object
/// </summary>
/// <typeparam name="T">Object type</typeparam>
/// <param name="XML">XML string</param>
/// <returns>The object of the specified type</returns>
public static T XMLToObject<T>(string XML)
{
if (string.IsNullOrEmpty(XML))
{
throw new ArgumentException("XML can not be null/empty");
}
try
{
using (MemoryStream Stream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(XML)))
{
XmlSerializer Serializer = new XmlSerializer(typeof(T));
return (T)Serializer.Deserialize(Stream);
}
}
catch { throw; }
}
}
}
XML-RPC
XmlRootAttribute
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() {
XmlAttributes attrs = new XmlAttributes();
attrs.XmlElements.Add(new XmlElementAttribute("Book", typeof(BookProduct)));
attrs.XmlElements.Add(new XmlElementAttribute("Product", typeof(Product)));
XmlAttributeOverrides attrOver = new XmlAttributeOverrides();
attrOver.Add(typeof(Inventory), "InventoryItems", attrs);
Product newProd = new Product();
BookProduct newBook = new BookProduct();
newProd.ProductID = 100;
newProd.ProductName = "Product";
newProd.SupplierID = 10;
newBook.ProductID = 101;
newBook.ProductName = "New Product";
newBook.SupplierID = 10;
newBook.ISBN = "123456789";
Product[] addProd = { newProd, newBook };
Inventory inv = new Inventory();
inv.InventoryItems = addProd;
TextWriter tr = new StreamWriter("inventory.xml");
XmlSerializer sr = new XmlSerializer(typeof(Inventory), attrOver);
sr.Serialize(tr, inv);
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;
[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 XML Serialization with Custom Objects
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);
}
}
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();
}
}
}