Beispielcode für die XML-Serialisierung gemeinsam nutzen

Serialisierung besteht darin, Objekt in eine Form umzuwandeln, die für die Übertragung verwendet werden kann, z Beispiel: Sie können ein Objekt serialisieren und es mithilfe von HTTP auf der Client- und Serverseite über die Deserialisierung weiterleiten, um den Stream in ein Objekt umzuwandeln.

 XML Serialisierung (XML-Serialisierung) serialisiert nur öffentliche Felder und Eigenschaften. XML-Serialisierung enthält keine Informationen vom Typ . Da XML über einen hervorragenden Mechanismus zur Beschreibung von Daten und Bewertungsbeziehungen verfügt, eignet es sich zum Speichern der Serialisierungsinformationen von Objekt. Hinweis: Die XML-Serialisierung konvertiert keine Methoden, Indexer und Felder oder schreibgeschützte Eigenschaften (außer schreibgeschützte Sammlungen, einschließlich öffentlicher). und privat, verwenden Sie
BinaryFormatter
anstelle der XML-Serialisierung. Das Folgende ist ein Beispiel für die Verwendung der XML-Serialisierung:
Serializing DataSet


------------------------------------------------

XmlElement serialisieren und XmlNode

private void SerializeDataSet(string filename){
    XmlSerializer ser = new XmlSerializer(typeof(DataSet));
        
    // Creates a DataSet; adds a table, column, and ten rows.
    DataSet ds = new DataSet("myDataSet");
    DataTable t = new DataTable("table1");
    DataColumn c = new DataColumn("thing");
    t.Columns.Add(c);
    ds.Tables.Add(t);
    DataRow r;
    for(int i = 0; i<10;i++){
        r = t.NewRow();
        r[0] = "Thing " + i;
        t.Rows.Add(r);
    }
    TextWriter writer = new StreamWriter(filename);
    ser.Serialize(writer, ds);
    writer.Close();
}

--------------------------------- - ------------

private void SerializeElement(string filename){
    XmlSerializer ser = new XmlSerializer(typeof(XmlElement));
    XmlElement myElement= 
    new XmlDocument().CreateElement("MyElement", "ns");
    myElement.InnerText = "Hello World";
    TextWriter writer = new StreamWriter(filename);
    ser.Serialize(writer, myElement);
    writer.Close();
}

private void SerializeNode(string filename){
    XmlSerializer ser = new XmlSerializer(typeof(XmlNode));
    XmlNode myNode= new XmlDocument().
    CreateNode(XmlNodeType.Element, "MyNode", "ns");
    myNode.InnerText = "Hello Node";
    TextWriter writer = new StreamWriter(filename);
    ser.Serialize(writer, myNode);
    writer.Close();
}

Serialisierung enthält Klassen, die komplexe Objekte (Object) zurückgeben (

Klasse
)
Wenn ein Feld oder eine Eigenschaft ein komplexes Objekt zurückgibt (z. B. array oder eine Klasseninstanz), konvertiert XmlSerializer es in ein im Haupt-XML-Dokument verschachteltes Element. Wie folgt gibt die erste Klasse eine Instanz von zurück zweite Klasse.

Das serialisierte Ausgabe-XML ähnelt dem folgenden

public class PurchaseOrder
{
    public Address MyAddress;
}
public class Address
{
    public string FirstName;
}

-- ------------ ----------------------------

Objektwarteschlange serialisieren

<PurchaseOrder>
    <Address>
        <FirstName>George</FirstName>
    </Address>
</PurchaseOrder>

Sie können Felder serialisieren die Objektwarteschlangen zurückgeben

Ausgabe serialisieren Das XML ähnelt dem folgenden

public class PurchaseOrder
{
    public Item [] ItemsOrders
}
public class Item
{
    public string ItemID
    public decimal ItemPrice
}

------------- --------------------- --------------- -------

Serialisierungsimplementierung von ICollection

<PurchaseOrder xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xmlns:xsd="http://www.w3.org/20001/XMLSchema">
    <Items>
        <Item>
            <ItemID>aaa111</ItemID>
            <ItemPrice>34.22</ItemPrice>
        <Item>
        <Item>
            <ItemID>bbb222</ItemID>
            <ItemPrice>2.89</ItemPrice>
        <Item>
    </Items>
</PurchaseOrder>

Für Klassen mit Schnittstelle

können Sie gleichzeitig die ICollection-Schnittstelle implementieren Erstellen Sie eine Sammlungsklasse und verwenden Sie
XmlSerializer
, um Instanzen der Klasse zu serialisieren. Hinweis Wenn eine Klasse die ICollection-Schnittstelle implementiert, wird nur die in der Klasse enthaltene Sammlung und alle anderen Felder serialisiert und der Klasse hinzugefügte Eigenschaften werden nicht serialisiert. Die zu serialisierende Klasse muss die Methode Add und die Eigenschaft Item (C#-Indexer) enthalten.
Hinweis: Wenn wir serialisierte, stark typisierte Sammlungsklassen entwerfen und verwenden, müssen wir Folgendes beachten:

using System;
using System.IO;
using System.Collections;
using System.Xml.Serialization;
public class Test{
    static void Main(){
        Test t = new Test();
        t.SerializeCollection("coll.xml");
    }
    private void SerializeCollection(string filename){
        Employees Emps = new Employees();
        // Note that only the collection is serialized--not the 
        // CollectionName or any other public property of the class.
        Emps.CollectionName = "Employees";
        Employee John100 = new Employee("John", "100xxx");
        Emps.Add(John100);
        XmlSerializer x = new XmlSerializer(typeof(Employees));
        TextWriter writer = new StreamWriter(filename);
        x.Serialize(writer, Emps);
    }
}
public class Employees:ICollection{
    public string CollectionName;
    private ArrayList empArray = new ArrayList();
    //所要求要求的Item性质(property)(C#的索引器(indexer))
    public Employee this[int index]{
        get{return (Employee) empArray[index];}
    }
    
    public void CopyTo(Array a, int index){
        empArray.CopyTo(a, index);
    }
    public int Count{
        get{return empArray.Count;}
    }
    public object SyncRoot{
        get{return this;}
    }
    public bool IsSynchronized{
        get{return false;}
    }
    public IEnumerator GetEnumerator(){
        return empArray.GetEnumerator();
    }
    //所要求的Add方法,它只能有一个参数,并且此参数的类型必须为Item性质(property)(C#的索引器(indexer))所返回的类型
    public void Add(Employee newEmployee){
        empArray.Add(newEmployee);
    }
}
public class Employee{
    public string EmpName;
    public string EmpID;
    public Employee(){}
    public Employee(string empName, string empID){
        EmpName = empName;
        EmpID = empID;
    }
}

Aufgrund der Einschränkungen der Regeln können Sie die Klasse wird in ein Array des in Ihrer Klasse enthaltenen Sammlungstyps serialisiert, was bedeutet, dass, wenn Sie zusätzliche Eigenschaften hinzufügen, diese bei der Serialisierung nicht einbezogen werden. Zum Beispiel:

Hier

Kundenkonten werden serialisiert, aber es wird in eine Sammlung von KontoObjekte Name, Adresse und andere Felder werden nicht serialisiert:

这里时MSDN对它的介绍:

XmlSerializer can process classes that implement IEnumerable or ICollection differently if they meet certain requirements. A class that implements IEnumerable must implement a public Add method that takes a single parameter. The Add method's parameter must be consistent (polymorphic) with the type returned from the IEnumerator.Current property returned from the GetEnumerator method. A class that implements ICollection in addition to IEnumerable (such as CollectionBase) must have a public Item indexed property (an indexer in C#) that takes an integer, and it must have a public Count property of type integer. The parameter passed to the Add method must be the same type as that returned from the Item property, or one of that type's bases. For classes implementing ICollection, values to be serialized will be retrieved from the indexed Item property rather than by calling GetEnumerator. Also note that public fields and properties will not be serialized, with the exception of public fields that return another collection class (one that implements ICollection).

  使用XML串行化属性(Attributes)(如:XmlArray,XmlArrayItem)来串行化集合类!

串行化包含数组(Arrays)的数据

using System;
using System.Collections;
using System.Xml.Serialization;
 /// <summary>
 /// Summary description for Cars.
 /// </summary>
    [XmlRoot("carsCollection")]
    public class CarsArray {
        private Car[] _CarsList = null;

        public CarsArray() {}    
    
        public CarsArray(int size) {
            _CarsList = new Car[size];
        }

        [XmlArray("carsArray")]
        [XmlArrayItem("car")]
        public Car[] CarsCollection {
            get {
                return _CarsList;
            }
            set {
                _CarsList = value;
            }
        }

        public Car this[int index] {
            get {
                if (index <= _CarsList.GetUpperBound(0) || index > -1)
                    return (Car)_CarsList[index];
                else
                    throw new IndexOutOfRangeException("Invalid index value passed.");
            }
            set {
                if (index <= _CarsList.GetUpperBound(0) || index > -1)
                    _CarsList[index] = value;
                else
                    throw new IndexOutOfRangeException("Invalid index value passed.");

            }
        }

    }

结果为:

<?xml version="1.0" encoding="utf-16"?>
<carsCollection xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <carsArray>
    <car>
      <license>1234</license>
      <color>Black</color>
    </car>
    <car>
      <license>4321</license>
      <color>Blue</color>
    </car>
  </carsArray>
</carsCollection>

• 串行化ArrayLists
  
  

• using System;
  using System.Collections;
  using System.Xml.Serialization;
  
      /// <summary>
      /// Summary description for Cars.
      /// </summary>
      [XmlRoot("carsCollection")]
      public class CarsArrayList {
          private ArrayList _CarsList = new ArrayList();
  
          public CarsArrayList() {}        
  
          [XmlArray("carsArrayList")]
          [XmlArrayItem("car",typeof(Car))]
          public ArrayList CarsCollection {
              get {
                  return _CarsList;
              }
              set {
                  _CarsList = value;
              }
          }
  
          public Car this[int index] {
              get {
                  return (Car)_CarsList[index];
              }
              set {
                  if (index > _CarsList.Count-1)
                      _CarsList.Add(value);
                  else
                      _CarsList[index] = value;
              }
          }
  
      }

结果为:

<?xml version="1.0" encoding="utf-16"?>
<carsCollection xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <carsArrayList>
    <car>
      <license>1234</license>
      <color>Black</color>
    </car>
    <car>
      <license>4321</license>
      <color>Blue</color>
    </car>
  </carsArrayList>
</carsCollection>

------------------------------------------------------------------

购买订单示例

    例子很简单,也很完整,它使用CreatePO来创建 PurchaseOrder, Address,和 OrderedItem类,并串行化它们.ReadPo实现反串行化.

    可以将附加的特性用于类和属性.你必须引用System.Xml.Serialization名字空间来用这些特性.

特性	用途
[XmlIgnore]	当公有的属性或字段不包括在串行化的XML结构中时。
[XmlRoot]	用来识别作为XML文件根元素的类或结构。你可以用它来把一个元素名设置为根元素。
[XmlElement]	当公有的属性或字段可以作为一个元素被串行化到XML结构中时。
[XmlAttribute]	当公有的属性或字段可以作为一个特性被串行化到XML结构中时。
[XmlArray]	当公有的属性或字段可以作为一个元素数组被串行化到XML结构中时。当一组对象用在一个类中时，这个特性很有用。
[XmlArrayItem]	用来识别可以放到一个串行化数组中的类型。

    再次提醒大家注意,只能串行化公共(public)类和公共(public)字段(fields)和性质(property).

using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
// The XmlRootAttribute allows you to set an alternate name 
// (PurchaseOrder) for the XML element and its namespace. By 
// default, the XmlSerializer uses the class name. The attribute 
// also allows you to set the XML namespace for the element. Lastly,
// the attribute sets the IsNullable property, which specifies whether 
// the xsi:null attribute appears if the class instance is set to 
// a null reference.
[XmlRootAttribute("PurchaseOrder", Namespace="http://www.cpandl.com", 
IsNullable = false)]
public class PurchaseOrder
{
    public Address ShipTo;
    public string OrderDate; 
    // The XmlArrayAttribute changes the XML element name
    // from the default of "OrderedItems" to "Items".
    [XmlArrayAttribute("Items")]
    public OrderedItem[] OrderedItems;
    public decimal SubTotal;
    public decimal ShipCost;
    public decimal TotalCost;   
}
    
public class Address
{
    // The XmlAttribute instructs the XmlSerializer to serialize the Name
    // field as an XML attribute instead of an XML element (the default
    // behavior).
    [XmlAttribute]
    public string Name;
    public string Line1;
    // Setting the IsNullable property to false instructs the 
    // XmlSerializer that the XML attribute will not appear if 
    // the City field is set to a null reference.
    [XmlElementAttribute(IsNullable = false)]
    public string City;
    public string State;
    public string Zip;
}
    
public class OrderedItem
{
    public string ItemName;
    public string Description;
    public decimal UnitPrice;
    public int Quantity;
    public decimal LineTotal;
    // Calculate is a custom method that calculates the price per item
    // and stores the value in a field.
    public void Calculate()
    {
        LineTotal = UnitPrice * Quantity;
    }
}
    
public class Test
{
    public static void Main()
    {
        // Read and write purchase orders.
        Test t = new Test();
        t.CreatePO("po.xml");
        t.ReadPO("po.xml");
    }
    private void CreatePO(string filename)
    {
        // Creates an instance of the XmlSerializer class;
        // specifies the type of object to serialize.
        XmlSerializer serializer = 
        new XmlSerializer(typeof(PurchaseOrder));
        TextWriter writer = new StreamWriter(filename);
        PurchaseOrder po=new PurchaseOrder();
         
        // Creates an address to ship and bill to.
        Address billAddress = new Address();
        billAddress.Name = "Teresa Atkinson";
        billAddress.Line1 = "1 Main St.";
        billAddress.City = "AnyTown";
        billAddress.State = "WA";
        billAddress.Zip = "00000";
        // Sets ShipTo and BillTo to the same addressee.
        po.ShipTo = billAddress;
        po.OrderDate = System.DateTime.Now.ToLongDateString();
    
        // Creates an OrderedItem.
        OrderedItem i1 = new OrderedItem();
        i1.ItemName = "Widget S";
        i1.Description = "Small widget";
        i1.UnitPrice = (decimal) 5.23;
        i1.Quantity = 3;
        i1.Calculate();
    
        // Inserts the item into the array.
        OrderedItem [] items = {i1};
        po.OrderedItems = items;
        // Calculate the total cost.
        decimal subTotal = new decimal();
        foreach(OrderedItem oi in items)
        {
            subTotal += oi.LineTotal;
        }
        po.SubTotal = subTotal;
        po.ShipCost = (decimal) 12.51; 
        po.TotalCost = po.SubTotal + po.ShipCost; 
        // Serializes the purchase order, and closes the TextWriter.
        serializer.Serialize(writer, po);
        writer.Close();
    }
    
    protected void ReadPO(string filename)
    {
        // Creates an instance of the XmlSerializer class;
        // specifies the type of object to be deserialized.
        XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
        // If the XML document has been altered with unknown 
        // nodes or attributes, handles them with the 
        // UnknownNode and UnknownAttribute events.
        //在并行的xml当中可能存在意外的xml节点,如果不处理这些意外的xml 的节
        //点,XmlSerializer将忽略这些意外的节点，如果要处理这些意外节点，可以使用
        //XmlSerializer的一下事件进行处理:UnknownNode,UnknownElement  ,
        //UnknownAttribute ,UnreferencedObject
        serializer.UnknownNode+= new 
        XmlNodeEventHandler(serializer_UnknownNode);
        serializer.UnknownAttribute+= new 
        XmlAttributeEventHandler(serializer_UnknownAttribute);
    
        // A FileStream is needed to read the XML document.
        FileStream fs = new FileStream(filename, FileMode.Open);
        // Declares an object variable of the type to be deserialized.
        PurchaseOrder po;
        // Uses the Deserialize method to restore the object's state with
        // data from the XML document. */
        po = (PurchaseOrder) serializer.Deserialize(fs);
        // Reads the order date.
        Console.WriteLine ("OrderDate: " + po.OrderDate);
    
        // Reads the shipping address.
        Address shipTo = po.ShipTo;
        ReadAddress(shipTo, "Ship To:");
        // Reads the list of ordered items.
        OrderedItem [] items = po.OrderedItems;
        Console.WriteLine("Items to be shipped:");
        foreach(OrderedItem oi in items)
        {
            Console.WriteLine("\t"+
            oi.ItemName + "\t" + 
            oi.Description + "\t" +
            oi.UnitPrice + "\t" +
            oi.Quantity + "\t" +
            oi.LineTotal);
        }
        // Reads the subtotal, shipping cost, and total cost.
        Console.WriteLine(
        "\n\t\t\t\t\t Subtotal\t" + po.SubTotal + 
        "\n\t\t\t\t\t Shipping\t" + po.ShipCost + 
        "\n\t\t\t\t\t Total\t\t" + po.TotalCost
        );
    }
    
    protected void ReadAddress(Address a, string label)
    {
        // Reads the fields of the Address.
        Console.WriteLine(label);
        Console.Write("\t"+
        a.Name +"\n\t" +
        a.Line1 +"\n\t" +
        a.City +"\t" +
        a.State +"\n\t" +
        a.Zip +"\n");
    }
    protected void serializer_UnknownNode
    (object sender, XmlNodeEventArgs e)
    {
        Console.WriteLine("Unknown Node:" +   e.Name + "\t" + e.Text);
    }
    protected void serializer_UnknownAttribute
    (object sender, XmlAttributeEventArgs e)
    {
        System.Xml.XmlAttribute attr = e.Attr;
        Console.WriteLine("Unknown attribute " + 
        attr.Name + "='" + attr.Value + "'");
    }
}

xml输出如下:

<?xml version="1.0" encoding="utf-8"?>
<PurchaseOrder xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.cpandl.com">
    <ShipTo Name="Teresa Atkinson">
        <Line1>1 Main St.</Line1>
        <City>AnyTown</City>
        <State>WA</State>
        <Zip>00000</Zip>
    </ShipTo>
    <OrderDate>Wednesday, June 27, 2001</OrderDate>
    <Items>
        <OrderedItem>
            <ItemName>Widget S</ItemName>
            <Description>Small widget</Description>
            <UnitPrice>5.23</UnitPrice>
            <Quantity>3</Quantity>
            <LineTotal>15.69</LineTotal>
        </OrderedItem>
    </Items>
    <SubTotal>15.69</SubTotal>
    <ShipCost>12.51</ShipCost>
    <TotalCost>28.2</TotalCost>
</PurchaseOrder>

Das obige ist der detaillierte Inhalt vonBeispielcode für die XML-Serialisierung gemeinsam nutzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!