XmlArrayItemAttribute.Type Propriété

Définition

Espace de noms:

System.Xml.Serialization

Assembly:

System.Xml.XmlSerializer.dll

Source:

XmlArrayItemAttribute.cs

Obtient ou définit le type autorisé dans un tableau.

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

public Type? Type { get; set; }

member this.Type : Type with get, set

Public Property Type As Type

Valeur de propriété

Type

Type autorisé dans le tableau.

Exemples

L’exemple suivant sérialise un tableau d’objets. Le champ qui retourne le tableau est attribué à deux XmlArrayItemAttribute instances. Chaque instance indique au d’accepter XmlSerializer le spécifié Type dans le tableau.

#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" );
}

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);
   }
}

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


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

Remarques

Utilisez la Type propriété pour spécifier un type remplacé pour un champ public ou une valeur de propriété publique en lecture/écriture.

Si un champ ou une propriété retourne un tableau de type Object, appliquez plusieurs instances de au champ ou à la XmlArrayItemAttribute propriété . Pour chaque instance, définissez la Type propriété sur un type d’objet qui peut être inséré dans le tableau.

Si un tableau contient uniquement des types primitifs, vous n’avez pas besoin d’appliquer le XmlArrayItemAttribute. Par défaut, le XmlSerializer génère une série d’éléments, chacun portant le même nom d’élément, pour chaque valeur, mais le type de chaque élément est défini sur le type de données Schéma XML. Par exemple, le code suivant :

' 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};  
}  

aboutit à ce CODE 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>  

Toutefois, si vous spécifiez la Type propriété pour chaque type primitif, le nom d’élément de chaque valeur est généré à l’aide du nom de type .NET. Par exemple, ce code :

' 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};  
}  

aboutit à ce CODE 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>