XmlElementAttribute Classe

Definição

Namespace:

System.Xml.Serialization

Assembly:

System.Xml.ReaderWriter.dll

Origem:

XmlElementAttribute.cs

Indica que um campo ou propriedade pública representa um elemento XML quando o XmlSerializer serializa ou desserializa o objeto que o contém.

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

Herança

Object

Attribute

XmlElementAttribute

Atributos

AttributeUsageAttribute

Exemplos

O exemplo a seguir serializa uma classe chamada Group e aplica o XmlElementAttribute a vários de seus membros. O campo chamado Employees retorna uma matriz de Employee objetos . Nesse caso, o XmlElementAttribute especifica que o XML resultante não será aninhado (que é o comportamento padrão dos itens em uma matriz).

#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

Comentários

O XmlElementAttribute pertence a uma família de atributos que controla como o XmlSerializer serializa ou desserializa um objeto. Para obter uma lista completa de atributos semelhantes, consulte Atributos que controlam a serialização XML.

Um documento XML geralmente contém elementos XML, cada um deles consiste em três partes: uma marca de abertura com atributos possíveis, uma marca de fechamento e os dados entre as marcas. As marcas XML podem ser aninhadas, ou seja, os dados entre marcas também podem ser elementos XML. Essa capacidade de um elemento para incluir outro permite que o documento contenha hierarquias de dados. Um elemento XML também pode incluir atributos.

Aplique o XmlElementAttribute a campos públicos ou propriedades públicas de leitura/gravação para controlar características dos elementos XML, como o nome do elemento e o namespace.

O XmlElementAttribute pode ser aplicado várias vezes a um campo que retorna uma matriz de objetos . A finalidade disso é especificar (por meio da Type propriedade) diferentes tipos que podem ser inseridos na matriz. Por exemplo, a matriz no código C# a seguir aceita cadeias de caracteres e inteiros.

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

Isso resulta em XML que pode ser semelhante ao seguinte.

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

Observe que, quando você aplica XmlElementAttribute várias vezes sem especificar um ElementName valor de propriedade, os elementos são nomeados após o tipo dos objetos aceitáveis.

Se você aplicar o XmlElementAttribute a um campo ou propriedade que retorna uma matriz, os itens na matriz serão codificados como uma sequência de elementos XML.

Por outro lado, se um XmlElementAttribute não for aplicado a esse campo ou propriedade, os itens na matriz serão codificados como uma sequência de elementos, aninhados sob um elemento chamado após o campo ou propriedade. (Use os XmlArrayAttribute atributos e XmlArrayItemAttribute para controlar como uma matriz é serializada.)

Você pode definir a Type propriedade para especificar um tipo derivado do tipo do campo ou propriedade original , ou seja, o campo ou a propriedade ao qual você aplicou o XmlElementAttribute.

Se um campo ou propriedade retornar um ArrayList, você poderá aplicar várias instâncias do XmlElementAttribute ao membro. Para cada instância, defina a Type propriedade como um tipo de objeto que pode ser inserido na matriz.

Para obter mais informações sobre como usar atributos, consulte Atributos.

Observação

Você pode usar a palavra XmlElement em seu código em vez do mais longo XmlElementAttribute.

Construtores

XmlElementAttribute()	Inicializa uma nova instância da classe XmlElementAttribute.
XmlElementAttribute(String)	Inicializa uma nova instância da classe XmlElementAttribute e especifica o nome do elemento XML.
XmlElementAttribute(String, Type)	Inicializa uma nova instância do XmlElementAttribute e especifica o nome do elemento XML e um tipo derivado do membro ao qual o XmlElementAttribute é aplicado. Esse tipo de membro é usado quando o XmlSerializer serializa o objeto que o contém.
XmlElementAttribute(Type)	Inicializa uma nova instância da classe XmlElementAttribute e especifica um tipo para o membro ao qual o XmlElementAttribute é aplicado. Esse tipo é usado pelo XmlSerializer ao serializar ou desserializar um objeto que o contém.

Propriedades

DataType	Obtém ou define o tipo de dados XSD (definição de esquema XML) do elemento XML gerado pelo XmlSerializer.
ElementName	Obtém ou define o nome do elemento XML gerado.
Form	Obtém ou define um valor que indica se o elemento está qualificado.
IsNullable	Obtém ou define um valor que indica se o XmlSerializer deve serializar um membro definido como null como uma marca vazia com o atributo xsi:nil definido como true.
Namespace	Obtém ou define o namespace atribuído ao elemento XML resultante quando a classe é serializada.
Order	Obtém ou define a ordem explícita na qual os elementos são serializados ou desserializados.
Type	Obtém ou define o tipo de objeto usado para representar o elemento XML.
TypeId	Quando implementado em uma classe derivada, obtém um identificador exclusivo para este Attribute. (Herdado de Attribute)

Métodos

Equals(Object)	Retorna um valor que indica se essa instância é igual a um objeto especificado. (Herdado de Attribute)
GetHashCode()	Retorna o código hash para a instância. (Herdado de Attribute)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
IsDefaultAttribute()	Quando substituído em uma classe derivada, indica se o valor dessa instância é o valor padrão para a classe derivada. (Herdado de Attribute)
Match(Object)	Quando substituído em uma classe derivada, retorna um valor que indica se essa instância é igual a um objeto especificado. (Herdado de Attribute)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Confira também

• XmlArrayAttribute
• XmlAttributeOverrides
• XmlAttributes
• XmlElementAttributes
• XmlElements
• XmlRootAttribute
• XmlSerializer
• Apresentando a serialização XML
• Como especificar um nome de elemento alternativo para um fluxo XML
• Controlando a serialização XML usando atributos
• Exemplos de Serialização XML
• Ferramenta de Definição de Esquema XML (Xsd.exe)