XmlArrayItemAttribute.DataType-Eigenschaft

Ruft den XML-Datentyp des generierten XML-Elements ab oder legt diesen fest.

Namespace: System.Xml.Serialization
Assembly: System.Xml (in system.xml.dll)

Syntax

'Declaration
Public Property DataType As String
'Usage
Dim instance As XmlArrayItemAttribute
Dim value As String

value = instance.DataType

instance.DataType = value

public string DataType { get; set; }

public:
property String^ DataType {
    String^ get ();
    void set (String^ value);
}

/** @property */
public String get_DataType ()

/** @property */
public void set_DataType (String value)

public function get DataType () : String

public function set DataType (value : String)

Eigenschaftenwert

Ein Datentyp für die XML-Schemadefinition (XSD) laut Definition im Dokument "XML Schema Part 2: DataTypes" des World Wide Web Consortium (www.w3.org ).

Hinweise

In der folgenden Tabelle werden einfache XML-Schemadatentypen mit ihren .NET-Entsprechungen aufgelistet.

Verwenden Sie beim XML-Schemadatentyp base64Binary und hexBinary ein Array von Byte-Objekten, und weisen Sie ein XmlArrayItemAttribute zu, wobei die DataType-Eigenschaft auf "base64Binary" bzw. "hexBinary" festgelegt wird. Verwenden Sie beim XML-Schemadatentyp time und date den DateTime-Typ, und weisen Sie das XmlArrayItemAttribute zu, wobei DataType auf "date" oder "time" festgelegt ist.

Weisen Sie bei jedem einer Zeichenfolge zugeordneten XML-Schematyp das XmlArrayItemAttribute zu, wobei die DataType-Eigenschaft auf den XML-Schematyp festgelegt ist. Allerdings wird dadurch nicht das Serialisierungsformat geändert, sondern nur das Schema für den Member.

Weitere Informationen über XML-Schemadatentypen finden Sie im Dokument "XML Schema Part 2: Datatypes" des World Wide Web Consortium (www.w3.org).

Beispiel

Im folgenden Beispiel wird die Klasse PurchaseOrder serialisiert. Es werden mehrere Instanzen der XmlArrayItemAttribute-Klasse auf drei Member angewendet, und die DataType-Eigenschaft jeder Instanz wird auf einen im Array zulässigen Typ festgelegt.

Imports System
Imports System.Collections
Imports System.Xml
Imports System.Xml.Serialization
Imports System.IO
Imports System.Xml.Schema
Public Class PurchaseOrder
   <XmlArrayItem(DataType:= "gMonth", _
   ElementName:="MyMonths", _
   Namespace:= "http:'www.cohowinery.com")> _
   public Months() As String 

   <XmlArrayItem(GetType(Item)), XmlArrayItem(GetType(NewItem))> _
   public Items () As Item

   <XmlArray(IsNullable:= true), _
   XmlArrayItem(GetType(String)), _
   XmlArrayItem(GetType(double)), _
   XmlArrayItem(GetType(NewItem))> _
   public Things() As Object
End Class

Public Class Item
   public ItemID As String 

   public Sub New()
   End Sub
   
   public Sub New (id As String)
    ItemID = id
   End Sub
End Class

Public Class NewItem
   Inherits Item
   public Category As String 
   
   public Sub New()
      
   End Sub

   public Sub New(id As String , cat As String )
    me.ItemID = id
    Category = cat
   End Sub
End Class
 
Public Class Test
   Shared Sub Main()
      ' Read and write purchase orders.
      Dim t As Test = New Test()
      t.SerializeObject("ArrayItemExVB.xml")
      t.DeserializeObject("ArrayItemExVB.xml")
   End Sub 

   private Sub SerializeObject(filename As String)
      ' Create an instance of the XmlSerializer class
      ' specify the type of object to serialize.
      Dim serializer As XmlSerializer = _
      New XmlSerializer(GetType(PurchaseOrder))
      Dim writer As TextWriter = New StreamWriter(filename)
      ' Create a PurchaseOrder and set its properties.
      Dim po As PurchaseOrder =New PurchaseOrder()
      po.Months = New String() { "March", "May", "August"}
      po.Items= New Item(){New Item("a1"), New NewItem("b1", "book")}
      po.Things= New Object() {"String", 2003.31, New NewItem("Item100", "book")}
      
      ' Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po)
      writer.Close()
   End Sub
 
   protected Sub DeserializeObject(filename As String)
      ' Create an instance of the XmlSerializer class
      ' specify the type of object to be deserialized.
      Dim serializer As XmlSerializer = _
      New XmlSerializer(GetType(PurchaseOrder))
   
      ' A FileStream is needed to read the XML document.
      Dim fs As FileStream = New FileStream(filename, FileMode.Open)
      ' Declare an object variable of the type to be deserialized.
      Dim po As PurchaseOrder 
      ' Use the Deserialize method to restore the object's state with
      ' data from the XML document. 
      po = CType( serializer.Deserialize(fs), PurchaseOrder)
      Dim s As String
      Dim i As Item
      Dim thing As Object
      for each s in po.Months
          Console.WriteLine(s)
      Next 
      
      for each i in po.Items
         Console.WriteLine(i.ItemID)
      Next 
      
      for each thing in po.Things
         Console.WriteLine(thing) 
      Next
   End Sub
End Class

using System;
using System.Collections;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Xml.Schema;
public class PurchaseOrder
{
   [XmlArrayItem(DataType = "gMonth", 
   ElementName="MyMonths",
   Namespace = "http://www.cohowinery.com")]
   public string[] Months;

   [XmlArrayItem(typeof(Item)), XmlArrayItem(typeof(NewItem))]
   public Item[] Items;

   [XmlArray(IsNullable = true)]
   [XmlArrayItem(typeof(string)), 
   XmlArrayItem(typeof(double)), 
   XmlArrayItem(typeof(NewItem))]
   public object[] Things;
   }

public class Item{
   public string ItemID;
   public Item(){}
   public Item(string id){
    ItemID = id;
   }
}
public class NewItem:Item{
   public string Category;
   public NewItem(){}
   public NewItem(string id, string cat){
    this.ItemID = id;
    Category = cat;
    }
}
 
public class Test
{
   public static void Main()
   {
      // Read and write purchase orders.
      Test t = new Test();
      t.SerializeObject("ArrayItemEx.xml");
      t.DeserializeObject("ArrayItemEx.xml");
   } 

   private void SerializeObject(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to serialize.
      XmlSerializer serializer = 
      new XmlSerializer(typeof(PurchaseOrder));
      TextWriter writer = new StreamWriter(filename);
      // Create a PurchaseOrder and set its properties.
      PurchaseOrder po=new PurchaseOrder();
      po.Months = new string[]{ "March", "May", "August"};
      po.Items= new Item[]{new Item("a1"), new NewItem("b1", "book")};
      po.Things= new object[] {"String", 2003.31, new NewItem("Item100", "book")};
      
      // Serialize the purchase order, and close the TextWriter.
      serializer.Serialize(writer, po);
      writer.Close();
   }
 
   protected void DeserializeObject(string filename)
   {
      // Create an instance of the XmlSerializer class;
      // specify the type of object to be deserialized.
      XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
   
      // A FileStream is needed to read the XML document.
      FileStream fs = new FileStream(filename, FileMode.Open);
      // Declare an object variable of the type to be deserialized.
      PurchaseOrder po;
      /* Use the Deserialize method to restore the object's state with
      data from the XML document. */
      po = (PurchaseOrder) serializer.Deserialize(fs);
      foreach(string s in po.Months)
          Console.WriteLine(s);
      foreach(Item i in po.Items)
         Console.WriteLine(i.ItemID);
      foreach(object thing in po.Things)
         Console.WriteLine(thing); 
   } 
}

#using <System.dll>
#using <System.xml.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Xml;
using namespace System::Xml::Serialization;
using namespace System::IO;
using namespace System::Xml::Schema;
public ref class Item
{
public:
   String^ ItemID;
   Item(){}

   Item( String^ id )
   {
      ItemID = id;
   }
};

public ref class NewItem: public Item
{
public:
   String^ Category;
   NewItem(){}

   NewItem( String^ id, String^ cat )
   {
      ItemID = id;
      Category = cat;
   }
};

public ref class PurchaseOrder
{
public:

   [XmlArrayItem(DataType="gMonth",
   ElementName="MyMonths",
   Namespace="http://www.cohowinery.com")]
   array<String^>^Months;

   [XmlArrayItem(Item::typeid),XmlArrayItem(NewItem::typeid)]
   array<Item^>^Items;

   [XmlArray(IsNullable=true)]
   [XmlArrayItem(String::typeid),
   XmlArrayItem(Double::typeid),
   XmlArrayItem(NewItem::typeid)]
   array<Object^>^Things;
};

void SerializeObject( String^ filename )
{
   // Create an instance of the XmlSerializer class;
   // specify the type of object to serialize.
   XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );
   TextWriter^ writer = gcnew StreamWriter( filename );

   // Create a PurchaseOrder and set its properties.
   PurchaseOrder^ po = gcnew PurchaseOrder;
   array<String^>^months = {"March","May","August"};
   po->Months = months;
   array<Item^>^items = {gcnew Item( "a1" ),gcnew NewItem( "b1","book" )};
   po->Items = items;
   array<Object^>^things = {"String",2003.31,gcnew NewItem( "Item100","book" )};
   po->Things = things;

   // Serialize the purchase order, and close the TextWriter.
   serializer->Serialize( writer, po );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   // Create an instance of the XmlSerializer class;
   // specify the type of object to be deserialized.
   XmlSerializer^ serializer = gcnew XmlSerializer( PurchaseOrder::typeid );

   // A FileStream is needed to read the XML document.
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );

   // Declare an object variable of the type to be deserialized.
   PurchaseOrder^ po;

   /* Use the Deserialize method to restore the object's state with
      data from the XML document. */
   po = safe_cast<PurchaseOrder^>(serializer->Deserialize( fs ));
   for ( int i = 0; i < po->Months->Length; ++i )
      Console::WriteLine( po->Months[ i ] );
   for ( int i = 0; i < po->Items->Length; ++i )
      Console::WriteLine( po->Items[ i ]->ItemID );
   for ( int i = 0; i < po->Things->Length; ++i )
      Console::WriteLine( po->Things[ i ] );
}

int main()
{
   // Read and write purchase orders.
   SerializeObject(  "ArrayItemEx.xml" );
   DeserializeObject(  "ArrayItemEx.xml" );
}

import System.*;
import System.Collections.*;
import System.Xml.*;
import System.Xml.Serialization.*;
import System.IO.*;
import System.Xml.Schema.*;

public class PurchaseOrder
{
    /** @attribute XmlArrayItem(DataType = "gMonth", ElementName = 
        "Mymonths", Namespace = "http://www.cohowinery.com")
     */
    public String months[];

    /** @attribute XmlArrayItem(Item.class)
        @attribute XmlArrayItem(NewItem.class)
     */
    public Item items[];

    /** @attribute XmlArray(IsNullable = true)
     */
    /** @attribute XmlArrayItem(String.class)
        @attribute XmlArrayItem(double.class)
        @attribute XmlArrayItem(NewItem.class)
     */
    public Object things[];
} //PurchaseOrder

public class Item
{
    public String itemID;

    public Item()
    {
    } //Item

    public Item(String id)
    {
        itemID = id;
    } //Item
} //Item

public class NewItem extends Item
{
    public String category;

    public NewItem()
    {
    } //NewItem

    public NewItem(String id, String cat)
    {
        this.itemID = id;
        category = cat;
    } //NewItem
} //NewItem

public class Test
{
    public static void main(String[] args)
    {
        // Read and write purchase orders.
        Test t = new Test();
        t.SerializeObject("ArrayItemEx.xml");
        t.DeserializeObject("ArrayItemEx.xml");
    } //main

    private void SerializeObject(String fileName)
    {
        // Create an instance of the XmlSerializer class;
        // specify the type of object to serialize.
        XmlSerializer serializer = new XmlSerializer(
            PurchaseOrder.class.ToType());
        TextWriter writer = new StreamWriter(fileName);
        // Create a PurchaseOrder and set its properties.
        PurchaseOrder po = new PurchaseOrder();
        po.months = new String[] { "March", "May", "August" };
        po.items = (new Item[] { new Item("a1"), new NewItem("b1", "book") });
        po.things = new Object[] {
            "String", (System.Double)2003.31, new NewItem("Item100", "book")
        };
        // Serialize the purchase order, and close the TextWriter.
        serializer.Serialize(writer, po);
        writer.Close();
    } //SerializeObject

    protected void DeserializeObject(String fileName)
    {
        // Create an instance of the XmlSerializer class;
        // specify the type of object to be deserialized.
        XmlSerializer serializer = new XmlSerializer(
            PurchaseOrder.class.ToType());
        // A FileStream is needed to read the XML document.
        FileStream fs = new FileStream(fileName, FileMode.Open);
        // Declare an object variable of the type to be deserialized.
        PurchaseOrder po;

        /* Use the Deserialize method to restore the object's state with
           data from the XML document. 
         */
        po = (PurchaseOrder)serializer.Deserialize(fs);
        for (int iCtr = 0; iCtr < po.months.get_Length(); iCtr++) {
            String s = po.months[iCtr];
            Console.WriteLine(s);
        }
        for (int iCtr = 0; iCtr < po.items.get_Length(); iCtr++) {
            Item i = po.items[iCtr];
            Console.WriteLine(i.itemID);
        }

        for (int iCtr = 0; iCtr < po.things.get_Length(); iCtr++) {
            Object thing = po.things[iCtr];
            Console.WriteLine(thing);
        }
    } //DeserializeObject
} //Test

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

XmlArrayItemAttribute-Klasse
XmlArrayItemAttribute-Member
System.Xml.Serialization-Namespace