XmlElementAttribute Classe

Référence

Définition

Espace de noms:: System.Xml.Serialization

Assembly:: System.Xml.XmlSerializer.dll

Assembly:: System.Xml.ReaderWriter.dll

Assembly:: System.Xml.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Indique qu'un champ public ou une propriété publique représente un élément XML lorsque XmlSerializer sérialise ou désérialise l'objet qui le contient.

public ref class XmlElementAttribute : Attribute

[System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, AllowMultiple=true)]
public class XmlElementAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property | System.AttributeTargets.ReturnValue, AllowMultiple=true)>]
type XmlElementAttribute = class
    inherit Attribute

Public Class XmlElementAttribute
Inherits Attribute

Héritage: Object

Attribute
XmlElementAttribute

Attributs: AttributeUsageAttribute

Exemples

L’exemple suivant sérialise une classe nommée Group et s’applique XmlElementAttribute à plusieurs de ses membres. Le champ nommé Employees retourne un tableau d’objets Employee . Dans ce cas, le XmlElementAttribute code XML résultant n’est pas imbriqué (c’est-à-dire le comportement par défaut des éléments dans un tableau).

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

using namespace System;
using namespace System::Collections;
using namespace System::IO;
using namespace System::Xml::Serialization;
public ref class Employee
{
public:
   String^ Name;
};

public ref class Manager: public Employee
{
public:
   int Level;
};

public ref class Group
{
public:

   /* Set the element name and namespace of the XML element.
      By applying an XmlElementAttribute to an array,  you instruct
      the XmlSerializer to serialize the array as a series of XML
      elements, instead of a nested set of elements. */

   [XmlElement(
   ElementName="Members",
   Namespace="http://www.cpandl.com")]
   array<Employee^>^Employees;

   [XmlElement(DataType="snippet1>",
   ElementName="Building")]
   double GroupID;

   [XmlElement(DataType="hexBinary")]
   array<Byte>^HexBytes;

   [XmlElement(DataType="boolean")]
   bool IsActive;

   [XmlElement(Type=::Manager::typeid)]
   Employee^ Manager;

   [XmlElement(Int32::typeid,
   ElementName="ObjectNumber"),
   XmlElement(String::typeid,
   ElementName="ObjectString")]
   ArrayList^ ExtraInfo;
};

void SerializeObject( String^ filename )
{
   // Create the XmlSerializer.
   XmlSerializer^ s = gcnew XmlSerializer( Group::typeid );

   // To write the file, a TextWriter is required.
   TextWriter^ writer = gcnew StreamWriter( filename );

   /* Create an instance of the group to serialize, and set
      its properties. */
   Group^ group = gcnew Group;
   group->GroupID = 10.089f;
   group->IsActive = false;
   array<Byte>^temp0 = {Convert::ToByte( 100 )};
   group->HexBytes = temp0;
   Employee^ x = gcnew Employee;
   Employee^ y = gcnew Employee;
   x->Name = "Jack";
   y->Name = "Jill";
   array<Employee^>^temp1 = {x,y};
   group->Employees = temp1;
   Manager^ mgr = gcnew Manager;
   mgr->Name = "Sara";
   mgr->Level = 4;
   group->Manager = mgr;

   /* Add a number and a string to the 
      ArrayList returned by the ExtraInfo property. */
   group->ExtraInfo = gcnew ArrayList;
   group->ExtraInfo->Add( 42 );
   group->ExtraInfo->Add( "Answer" );

   // Serialize the object, and close the TextWriter.      
   s->Serialize( writer, group );
   writer->Close();
}

void DeserializeObject( String^ filename )
{
   FileStream^ fs = gcnew FileStream( filename,FileMode::Open );
   XmlSerializer^ x = gcnew XmlSerializer( Group::typeid );
   Group^ g = dynamic_cast<Group^>(x->Deserialize( fs ));
   Console::WriteLine( g->Manager->Name );
   Console::WriteLine( g->GroupID );
   Console::WriteLine( g->HexBytes[ 0 ] );
   IEnumerator^ myEnum = g->Employees->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Employee^ e = safe_cast<Employee^>(myEnum->Current);
      Console::WriteLine( e->Name );
   }
}

int main()
{
   SerializeObject( "FirstDoc.xml" );
   DeserializeObject( "FirstDoc.xml" );
}

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

public class Group
{
   /* Set the element name and namespace of the XML element.
   By applying an XmlElementAttribute to an array,  you instruct
   the XmlSerializer to serialize the array as a series of XML
   elements, instead of a nested set of elements. */

   [XmlElement(
   ElementName = "Members",
   Namespace = "http://www.cpandl.com")]
   public Employee[] Employees;

   [XmlElement(DataType = "double",
   ElementName = "Building")]
   public double GroupID;

   [XmlElement(DataType = "hexBinary")]
   public byte [] HexBytes;

   [XmlElement(DataType = "boolean")]
   public bool IsActive;

   [XmlElement(Type = typeof(Manager))]
   public Employee Manager;

   [XmlElement(typeof(int),
   ElementName = "ObjectNumber"),
   XmlElement(typeof(string),
   ElementName = "ObjectString")]
   public ArrayList ExtraInfo;
}

public class Employee
{
   public string Name;
}

public class Manager:Employee{
   public int Level;
}

public class Run
{
    public static void Main()
    {
       Run test = new Run();
       test.SerializeObject("FirstDoc.xml");
       test.DeserializeObject("FirstDoc.xml");
    }

   public void SerializeObject(string filename)
   {
      // Create the XmlSerializer.
      XmlSerializer s = new XmlSerializer(typeof(Group));

      // To write the file, a TextWriter is required.
      TextWriter writer = new StreamWriter(filename);

      /* Create an instance of the group to serialize, and set
         its properties. */
      Group group = new Group();
      group.GroupID = 10.089f;
      group.IsActive = false;

      group.HexBytes = new byte[1]{Convert.ToByte(100)};

      Employee x = new Employee();
      Employee y = new Employee();

      x.Name = "Jack";
      y.Name = "Jill";

      group.Employees = new Employee[2]{x,y};

      Manager mgr = new Manager();
      mgr.Name = "Sara";
      mgr.Level = 4;
      group.Manager = mgr;

      /* Add a number and a string to the
      ArrayList returned by the ExtraInfo property. */
      group.ExtraInfo = new ArrayList();
      group.ExtraInfo.Add(42);
      group.ExtraInfo.Add("Answer");

      // Serialize the object, and close the TextWriter.
      s.Serialize(writer, group);
      writer.Close();
   }

   public void DeserializeObject(string filename)
   {
      FileStream fs = new FileStream(filename, FileMode.Open);
      XmlSerializer x = new XmlSerializer(typeof(Group));
      Group g = (Group) x.Deserialize(fs);
      Console.WriteLine(g.Manager.Name);
      Console.WriteLine(g.GroupID);
      Console.WriteLine(g.HexBytes[0]);
      foreach(Employee e in g.Employees)
      {
         Console.WriteLine(e.Name);
      }
   }
}

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


Public Class Group
    ' Set the element name and namespace of the XML element.
    <XmlElement(ElementName := "Members", _
     Namespace := "http://www.cpandl.com")> _    
    Public Employees() As Employee
    
    <XmlElement(DataType := "double", _
     ElementName := "Building")> _
    Public GroupID As Double
    
    <XmlElement(DataType := "hexBinary")> _
    Public HexBytes() As Byte
    
    <XmlElement(DataType := "boolean")> _
    Public IsActive As Boolean
    
    <XmlElement(GetType(Manager))> _
    Public Manager As Employee
    
    <XmlElement(GetType(Integer), _
        ElementName := "ObjectNumber"), _
     XmlElement(GetType(String), _
        ElementName := "ObjectString")> _
    Public ExtraInfo As ArrayList
End Class

Public Class Employee
    Public Name As String
End Class

Public Class Manager
    Inherits Employee
    Public Level As Integer
End Class

Public Class Run
    
    Public Shared Sub Main()
        Dim test As New Run()
        test.SerializeObject("FirstDoc.xml")
        test.DeserializeObject("FirstDoc.xml")
    End Sub
    
    Public Sub SerializeObject(filename As String)
        ' Create the XmlSerializer.
        Dim s As New XmlSerializer(GetType(Group))
        
        ' To write the file, a TextWriter is required.
        Dim writer As New StreamWriter(filename)
        
        ' Create an instance of the group to serialize, and set
        ' its properties. 
        Dim group As New Group()
        group.GroupID = 10.089f
        group.IsActive = False
        
        group.HexBytes = New Byte() {Convert.ToByte(100)}
        
        Dim x As New Employee()
        Dim y As New Employee()
        
        x.Name = "Jack"
        y.Name = "Jill"
        
        group.Employees = New Employee() {x, y}
        
        Dim mgr As New Manager()
        mgr.Name = "Sara"
        mgr.Level = 4
        group.Manager = mgr
        
        ' Add a number and a string to the
        ' ArrayList returned by the ExtraInfo property. 
        group.ExtraInfo = New ArrayList()
        group.ExtraInfo.Add(42)
        group.ExtraInfo.Add("Answer")
        
        ' Serialize the object, and close the TextWriter.      
        s.Serialize(writer, group)
        writer.Close()
    End Sub    
    
    Public Sub DeserializeObject(filename As String)
        Dim fs As New FileStream(filename, FileMode.Open)
        Dim x As New XmlSerializer(GetType(Group))
        Dim g As Group = CType(x.Deserialize(fs), Group)
        Console.WriteLine(g.Manager.Name)
        Console.WriteLine(g.GroupID)
        Console.WriteLine(g.HexBytes(0))

        Dim e As Employee
        For Each e In g.Employees
            Console.WriteLine(e.Name)
        Next e
    End Sub
End Class

Remarques

Il XmlElementAttribute appartient à une famille d’attributs qui contrôle la XmlSerializer sérialisation ou la désérialisation d’un objet. Pour obtenir la liste complète des attributs similaires, consultez Attributs qui contrôlent la sérialisation XML.

Un document XML contient généralement des éléments XML, chacun comprenant trois parties : une balise ouvrante avec des attributs possibles, une balise de fermeture et les données entre les balises. Les balises XML peuvent être imbriquées, c’est-à-dire que les données entre les balises peuvent également être des éléments XML. Cette capacité d’un élément à placer un autre permet au document de contenir des hiérarchies de données. Un élément XML peut également inclure des attributs.

Appliquez les XmlElementAttribute propriétés de lecture/écriture publiques aux champs publics pour contrôler les caractéristiques des éléments XML tels que le nom et l’espace de noms d’éléments.

Il XmlElementAttribute peut être appliqué plusieurs fois à un champ qui retourne un tableau d’objets. L’objectif de cette opération est de spécifier (par le biais de la Type propriété) différents types qui peuvent être insérés dans le tableau. Par exemple, le tableau du code C# suivant accepte les chaînes et les entiers.

public class Things{  
   [XmlElement(Type = typeof(string)),  
   XmlElement(Type = typeof(int))]  
   public object[] StringsAndInts;  
}

Cela entraîne des résultats XML qui peuvent ressembler à ce qui suit.

<Things>  
   <string>Hello</string>  
   <int>999</int>  
   <string>World</string>  
</Things>

Notez que lorsque vous appliquez plusieurs XmlElementAttribute fois sans spécifier de ElementName valeur de propriété, les éléments sont nommés après le type des objets acceptables.

Si vous appliquez le XmlElementAttribute champ ou la propriété qui retourne un tableau, les éléments du tableau sont encodés sous la forme d’une séquence d’éléments XML.

En revanche, si un XmlElementAttribute champ ou une propriété n’est pas appliqué, les éléments du tableau sont encodés en tant que séquence d’éléments, imbriqués sous un élément nommé après le champ ou la propriété. (Utilisez les attributs et XmlArrayItemAttribute les XmlArrayAttribute attributs pour contrôler la façon dont un tableau est sérialisé.)

Vous pouvez définir la Type propriété pour spécifier un type dérivé du type du champ d’origine ou de la propriété- autrement dit, le champ ou la propriété auquel vous avez appliqué le XmlElementAttribute.

Si un champ ou une propriété retourne un ArrayList, vous pouvez appliquer plusieurs instances du XmlElementAttribute membre. Pour chaque instance, définissez la Type propriété sur un type d’objet qui peut être inséré dans le tableau.

Pour plus d’informations sur l’utilisation d’attributs, consultez Attributs.

Notes

Vous pouvez utiliser le mot XmlElement dans votre code plutôt que plus long XmlElementAttribute.

Constructeurs

XmlElementAttribute()	Initialise une nouvelle instance de la classe XmlElementAttribute.
XmlElementAttribute(String)	Initialise une nouvelle instance de la classe XmlElementAttribute et spécifie le nom de l'élément XML.
XmlElementAttribute(String, Type)	Initialise une nouvelle instance de XmlElementAttribute et spécifie le nom de l'élément XML et un type dérivé pour le membre auquel XmlElementAttribute est appliqué. Ce type de membre est utilisé lorsque XmlSerializer sérialise l'objet qui le contient.
XmlElementAttribute(Type)	Initialise une nouvelle instance de la classe XmlElementAttribute et spécifie un type pour le membre auquel XmlElementAttribute est appliqué. Ce type est utilisé par XmlSerializer lors de la sérialisation ou la désérialisation de l'objet qui le contient.

Propriétés

DataType	Obtient ou définit le type de données XSD (XML Schema Definition) de l'élément XML généré par XmlSerializer.
ElementName	Obtient ou définit le nom de l'élément XML généré.
Form	Obtient ou définit une valeur qui indique si l'élément est qualifié.
IsNullable	Obtient ou définit une valeur qui indique si XmlSerializer doit sérialiser un membre dont la valeur est `null` comme balise vide avec l'attribut `xsi:nil` ayant la valeur `true`.
Namespace	Obtient ou définit l'espace de noms assigné à l'élément XML obtenu lorsque la classe est sérialisée.
Order	Obtient ou définit l'ordre explicite dans lequel les éléments sont sérialisés ou désérialisés.
Type	Obtient ou définit le type d'objet utilisé pour représenter l'élément XML.
TypeId	Lors de l'implémentation dans une classe dérivée, obtient un identificateur unique pour l'objet Attribute. (Hérité de Attribute)

Méthodes

Equals(Object)	Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
GetHashCode()	Retourne le code de hachage de cette instance. (Hérité de Attribute)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
IsDefaultAttribute()	En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée. (Hérité de Attribute)
Match(Object)	En cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface. (Hérité de Attribute)
_Attribute.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Attribute)

S’applique à