XmlArrayItemAttribute.Type-Eigenschaft

Ruft den in einem Array zulässigen Typ ab oder legt diesen fest.

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

Syntax

'Declaration
Public Property Type As Type
'Usage
Dim instance As XmlArrayItemAttribute
Dim value As Type

value = instance.Type

instance.Type = value

public Type Type { get; set; }

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

/** @property */
public Type get_Type ()

/** @property */
public void set_Type (Type value)

public function get Type () : Type

public function set Type (value : Type)

Eigenschaftenwert

Ein Type, der in dem Array zulässig ist.

Hinweise

Geben Sie mithilfe der Type-Eigenschaft einen überschriebenen Typ für den Wert eines öffentliches Felds oder einer öffentlichen Lese-/Schreibeigenschaft an.

Wenn ein Feld oder eine Eigenschaft ein Array vom Typ Object zurückgibt, weisen Sie dem Feld oder der Eigenschaft mehrere XmlArrayItemAttribute-Instanzen zu. Legen Sie für jede Instanz die Type-Eigenschaft auf einen Objekttyp fest, der in das Array eingefügt werden kann.

Wenn ein Array nur primitive Typen enthält, müssen Sie XmlArrayItemAttribute nicht anwenden. Standardmäßig wird vom XmlSerializer eine Reihe von Elementen mit gleichem Elementnamen für jeden Wert generiert. Der Typ der einzelnen Elemente wird allerdings auf den XML-Schemadatentyp festgelegt. Folgender Code z. B.:

 ' Visual Basic code
 Public Class Arrays
    Public XSDTypes ()As Object= New Object(){"one", 2, 3.0}
 End Class
 // C# code
 public class MyArray{
    // No XmlArrayItemAttribute is applied.
    public object[] XSDTypes= new object[]{"one", 2, 3.2};
 }

Führt zu diesem XML:

 <?xml version="1.0" encoding="utf-8"?>
 <Arrays xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <XSDTypes>
     <Object xsi:type="xsd:string">one</Object>
     <Object xsi:type="xsd:int">2</Object>
     <Object xsi:type="xsd:double">3</Object>
   </XSDTypes>
 </Arrays>

Wenn Sie die Type-Eigenschaft allerdings für jeden primitiven Typen angeben, wird der Elementname für jeden Wert mit dem .NET-Typnamen generiert. Dieser Code z. B.:

 ' Visual Basic code
 Public Class Arrays
    <XmlArrayItem(GetType(String)), _
    XmlArrayItem(GetType(Integer)), _
    XmlArrayItem(GetType(Double))> _
    Public PrimitiveTypes () As Object = New Object(){"one", 2, 3.0}
 End Class
 // C# code
 public class Arrays{
    [XmlArrayItem(typeof(string))]
    [XmlArrayItem(typeof(int))]
    [XmlArrayItem(typeof(double))]
    public object [] PrimitiveTypes = new object[]{"one", 2, 3.0};
 }

Führt zu diesem XML:

 <?xml version="1.0" encoding="utf-8"?>
 <Arrays xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <PrimitiveTypes>
     <string>one</string>
     <int>2</int>
     <double>3</double>
   </PrimitiveTypes>
 </Arrays>

Beispiel

Im folgenden Beispiel wird ein Array von Objekten serialisiert. Dem Feld, das das Array zurückgibt, sind zwei XmlArrayItemAttribute-Instanzen als Attribute zugeordnet. Durch jede Instanz wird XmlSerializer angewiesen, den angegebenen Type im Array zu akzeptieren.

Imports System
Imports System.IO
Imports System.Xml.Serialization



Public Class Group
    ' The Type property instructs the XmlSerializer to accept both
    ' the Person and Manager types in the array. 
    <XmlArrayItem(Type := GetType(Manager)), _
     XmlArrayItem(Type := GetType(Person))> _
    Public Staff() As Person
        
End Class 'Group


Public Class Person
    Public Name As String
End Class 


Public Class Manager
    Inherits Person
    Public Rank As Integer
End Class 


Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeOrder("TypeEx.xml")
    End Sub 
        
    
    Public Sub SerializeOrder(filename As String)
        ' Creates an XmlSerializer.
        Dim xSer As New XmlSerializer(GetType(Group))
        
        ' Creates the Group object, and two array items.
        Dim myGroup As New Group()
        
        Dim p1 As New Person()
        p1.Name = "Jacki"
        Dim p2 As New Manager()
        
        p2.Name = "Megan"
        p2.Rank = 2
        
        Dim myStaff() As Person =  {p1, p2}
        myGroup.Staff = myStaff
        
        ' Serializes the object, and closes the StreamWriter.
        Dim writer As New StreamWriter(filename)
        xSer.Serialize(writer, myGroup)
    End Sub 
End Class 'Run

using System;
using System.IO;
using System.Xml.Serialization;

public class Group
{
   /* The Type property instructs the XmlSerializer to accept both
   the Person and Manager types in the array. */
   [XmlArrayItem(Type = typeof(Manager)),
   XmlArrayItem(Type=typeof(Person))]
   public Person[]Staff;
}

public class Person
{
   public string Name;
}

public class Manager:Person
{
   public int Rank;
}

public class Run 
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeOrder("TypeEx.xml");
   }


   public void SerializeOrder(string filename)
   {
      // Creates an XmlSerializer.
      XmlSerializer xSer = 
      new XmlSerializer(typeof(Group));

      // Creates the Group object, and two array items.
      Group myGroup = new Group();

      Person p1 = new Person();
      p1.Name = "Jacki";
      Manager p2 = new Manager();

      p2.Name = "Megan";
      p2.Rank = 2;

      Person [] myStaff = {p1,p2};
      myGroup.Staff = myStaff;

      // Serializes the object, and closes the StreamWriter.
      TextWriter writer = new StreamWriter(filename);
      xSer.Serialize(writer, myGroup);
   }
}

#using <System.Xml.dll>
#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml::Serialization;

public ref class Person
{
public:
   String^ Name;
};

public ref class Manager: public Person
{
public:
   int Rank;
};

public ref class Group
{
public:

   /* The Type property instructs the XmlSerializer to accept both
      the Person and Manager types in the array. */

   [XmlArrayItem(Type=Manager::typeid),
   XmlArrayItem(Type=Person::typeid)]
   array<Person^>^Staff;
};

void SerializeOrder( String^ filename )
{
   // Creates an XmlSerializer.
   XmlSerializer^ xSer = gcnew XmlSerializer( Group::typeid );

   // Creates the Group object, and two array items.
   Group^ myGroup = gcnew Group;
   Person^ p1 = gcnew Person;
   p1->Name = "Jacki";
   Manager^ p2 = gcnew Manager;
   p2->Name = "Megan";
   p2->Rank = 2;
   array<Person^>^myStaff = {p1,p2};
   myGroup->Staff = myStaff;
   
   // Serializes the object, and closes the StreamWriter.
   TextWriter^ writer = gcnew StreamWriter( filename );
   xSer->Serialize( writer, myGroup );
}

int main()
{
   SerializeOrder( "TypeEx.xml" );
}

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

public class Group
{
    /* The Type property instructs the XmlSerializer to accept both
       the Person and Manager types in the array. 
     */
    /** @attribute XmlArrayItem(Type = Manager.class)
        @attribute XmlArrayItem(Type = Person.class)
     */
    public Person staff[];
} //Group

public class Person
{
    public String name;
}//Person

public class Manager extends Person
{
    public int rank;
} //Manager

public class Run
{
    public static void main(String[] args)
    {
        Run test = new Run();
        test.SerializeOrder("TypeEx.xml");
    } //main

    public void SerializeOrder(String fileName)
    {
        // Creates an XmlSerializer.
        XmlSerializer xSer = new XmlSerializer(Group.class.ToType());

        // Creates the Group object, and two array items.
        Group myGroup = new Group();
        Person p1 = new Person();
        p1.name = "Jacki";

        Manager p2 = new Manager();
        p2.name = "Megan";
        p2.rank = 2;

        Person myStaff[] =  { p1, p2 };
        myGroup.staff = myStaff;

        // Serializes the object, and closes the StreamWriter.
        TextWriter writer = new StreamWriter(fileName);
        xSer.Serialize(writer, myGroup);
    } //SerializeOrder
} //Run

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