Solution
Use the System.Xml.Serialization.XmlSerializer class to transfer data from your object to XML, and vice versa. You can also mark up your class code with attributes to customize its XML representation.
The only requirements for using XmlSerializer are as follows:
-
The XmlSerializer only serializes properties and public variables.
-
The classes you want to serialize must include a default zero-argument constructor. The XmlSerializer uses this constructor when creating the new object during deserialization.
-
All class properties must be readable and writable. This is because XmlSerializer uses the property get accessor to retrieve information, and the property set accessor to restore the data after deserialization.
To use XML serialization, you must first mark up your data objects with attributes that indicate the desired XML mapping. These attributes are found in the System.Xml.Serialization namespace and include the following:
-
XmlRoot Specifies the name of the root element of the XML file. By default, XmlSerializer will use the name of the class. This attribute can be applied to the class declaration.
-
XmlElement Indicates the element name to use for a property or public variable. By default, XmlSerializer will use the name of the property or public variable.
-
XmlAttribute Indicates that a property or public variable should be serialized as an attribute, not an element, and specifies the attribute name.
-
XmlEnum Configures the text that should be used when serializing enumerated values. If you don't use XmlEnum, the name of the enumerated constant will be used.
-
XmlIgnore Indicates that a property or public variable should not be serialized.
For example, consider the product catalog first shown in recipe 5.1. You can represent this XML document using ProductCatalog and Product objects. Here's the class code that you might use:
using System;
using System.Xml.Serialization;
[XmlRoot("productCatalog")]
public class ProductCatalog {
[XmlElement("catalogName")]
public string CatalogName;
// Use the date data type (and ignore the time portion in the
// serialized XML).
[XmlElement(ElementName="expiryDate", DataType="date")]
public DateTime ExpiryDate;
// Configure the name of the tag that holds all products,
// and the name of the product tag itself.
[XmlArray("products")]
[XmlArrayItem("product")]
public Product[] Products;
public ProductCatalog() {
// Default constructor for deserialization.
}
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() {
// Default constructor for serialization.
}
public Product(string productName, decimal productPrice) {
this.ProductName = productName;
this.ProductPrice = productPrice;
}
}Notice that these classes use the XML serialization attributes to rename element names (using Pascal casing in the class member names, and camel casing in the XML tag names), indicate data types that aren't obvious, and specify how <product> elements will be nested in the <productCatalog>.
Using these custom classes and the XmlSerializer object, you can translate XML into objects and vice versa. Here's the code you would need to create a new ProductCatalog object, serialize the results to an XML document, deserialize the document back to an object, and then display the XML document.
using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
public class SerializeXml {
private static void Main() {
// Create the product catalog.
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;
// Serialize the order to a file.
XmlSerializer serializer = new XmlSerializer(typeof(ProductCatalog));
FileStream fs = new FileStream("ProductCatalog.xml", FileMode.Create);
serializer.Serialize(fs, catalog);
fs.Close();
catalog = null;
// Deserialize the order from the file.
fs = new FileStream("ProductCatalog.xml", FileMode.Open);
catalog = (ProductCatalog)serializer.Deserialize(fs);
// Serialize the order to the Console window.
serializer.Serialize(Console.Out, catalog);
Console.ReadLine();
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Solution
Use the XML Schema Definition Tool (xsd.exe) command-line utility included with the .NET Framework.
Specify the name of your assembly as a command- line argument, and add the /t:[TypeName]
parameter to indicate the types you want to convert.
The xsd.exe utility is included with the .NET Framework. If you've installed Microsoft Visual Studio .NET,
you'll find it in a directory like C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin.
The xsd.exe utility can generate schema documents from compiled assemblies. You simply need to supply the
filename and indicate the class that represents the XML document with the /t:[TypeName] parameter.
For example, consider the ProductCatalog and Product classes shown in recipe 5.9.（即XML 三） You could create the
XML schema for a product catalog with the following command line:
xsd Recipe5-09.exe /t:ProductCatalog
You need to specify only the ProductCatalog class on the command line because this class represents the actual
XML document. The generated schema in this example will represent a complete product catalog,
with contained product items. It will be given the default filename schema0.xsd.
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Solution
Use the xsd.exe command-line utility included with the .NET Framework. Specify the name of your schema file
as a command-line argument, and add the /c parameter to indicate that you want to generate class code.
To generate source code from a schema, you simply need to supply the filename of the schema document
and add the /c parameter to indicate that you want to generate the required classes. For example,
consider the schema shown in recipe 5.8. （上面所产生的xsd）You can generate C# code for this schema with the following command-line:
xsd ProductCatalog.xsd /c
This will generate one file (ProductCatalog.cs) with two classes: product and productCalalog. These classes
are similar to the ones created in recipe 5.9,（上面所写的constom object中） except for the fact that the class member names match the
XML document exactly.