XmlElementAttribute Classe

Definizione

Spazio dei nomi:

System.Xml.Serialization

Assembly:

System.Xml.ReaderWriter.dll

Origine:

XmlElementAttribute.cs

Indica che una proprietà o un campo public rappresenta un elemento XML quando XmlSerializer serializza o deserializza l'oggetto in cui è contenuto.

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

Ereditarietà

Object

Attribute

XmlElementAttribute

Attributi

AttributeUsageAttribute

Esempio

Nell'esempio seguente viene serializzato una classe denominata Group e viene applicato a XmlElementAttribute diversi membri. Il campo denominato Employees restituisce una matrice di Employee oggetti. In questo caso, specifica XmlElementAttribute che il codice XML risultante non verrà annidato , ovvero il comportamento predefinito degli elementi in una matrice.

#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

Commenti

Appartiene XmlElementAttribute a una famiglia di attributi che controlla il modo in cui serializza XmlSerializer o deserializza un oggetto. Per un elenco completo di attributi simili, vedere Attributi che controllano la serializzazione XML.

Un documento XML contiene in genere elementi XML, ognuno dei quali è costituito da tre parti: un tag di apertura con possibili attributi, un tag di chiusura e i dati tra i tag. I tag XML possono essere annidati, ovvero i dati tra i tag possono essere anche elementi XML. Questa capacità di un elemento da racchiudere in un altro consente al documento di contenere gerarchie di dati. Un elemento XML può includere anche attributi.

Applicare a XmlElementAttribute campi pubblici o proprietà pubbliche di lettura/scrittura per controllare le caratteristiche degli elementi XML, ad esempio il nome dell'elemento e lo spazio dei nomi.

Può XmlElementAttribute essere applicato più volte a un campo che restituisce una matrice di oggetti. Lo scopo di questa operazione è specificare (tramite la Type proprietà) tipi diversi che possono essere inseriti nella matrice. Ad esempio, la matrice nel codice C# seguente accetta stringhe e numeri interi.

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

In questo modo il codice XML potrebbe essere simile al seguente.

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

Si noti che quando si applicano XmlElementAttribute più volte senza specificare un ElementName valore di proprietà, gli elementi vengono denominati dopo il tipo degli oggetti accettabili.

Se si applica a XmlElementAttribute un campo o a una proprietà che restituisce una matrice, gli elementi nella matrice vengono codificati come sequenza di elementi XML.

Al contrario, se un XmlElementAttribute oggetto non viene applicato a un campo o a una proprietà di questo tipo, gli elementi nella matrice vengono codificati come sequenza di elementi, annidati in un elemento denominato dopo il campo o la proprietà. Usare gli XmlArrayAttribute attributi e XmlArrayItemAttribute per controllare la modalità di serializzazione di una matrice.

È possibile impostare la Type proprietà per specificare un tipo derivato dal tipo del campo originale o della proprietà, ovvero il campo o la proprietà a cui è stato applicato l'oggetto XmlElementAttribute.

Se un campo o una proprietà restituisce un ArrayListoggetto , è possibile applicare più istanze di XmlElementAttribute al membro. Per ogni istanza, impostare la Type proprietà su un tipo di oggetto che può essere inserito nella matrice.

Per altre informazioni sull'uso degli attributi, vedere Attributi.

Nota

È possibile usare la parola XmlElement nel codice anziché quella più lunga XmlElementAttribute.

Costruttori

XmlElementAttribute()	Inizializza una nuova istanza della classe XmlElementAttribute.
XmlElementAttribute(String)	Consente di inizializzare una nuova istanza della classe XmlElementAttribute e di specificare il nome dell'elemento XML.
XmlElementAttribute(String, Type)	Inizializza una nuova istanza di XmlElementAttribute e specifica il nome dell'elemento XML e un tipo derivato per il membro a cui viene applicato XmlElementAttribute. Questo tipo di membro viene utilizzato quando XmlSerializer serializza l'oggetto in cui è contenuto.
XmlElementAttribute(Type)	Inizializza una nuova istanza di XmlElementAttribute e specifica un tipo per il membro a cui viene applicato XmlElementAttribute. Questo tipo viene utilizzato da XmlSerializer durante la serializzazione o la deserializzazione dell'oggetto in cui è contenuto.

Proprietà

DataType	Ottiene o imposta il tipo di dati XSD (XML Schema Definition) dell'elemento XML generato da XmlSerializer.
ElementName	Ottiene o imposta il nome dell'elemento XML generato.
Form	Ottiene o imposta un valore che indica se l'elemento è completo.
IsNullable	Ottiene o imposta un valore che indica se XmlSerializer deve serializzare un membro impostato su null come un tag vuoto con l'attributo xsi:nil impostato su true.
Namespace	Ottiene o imposta lo spazio dei nomi assegnato all'elemento XML restituito quando la classe viene serializzata.
Order	Ottiene o imposta l'ordine esplicito in cui gli elementi vengono serializzati o deserializzati.
Type	Ottiene o imposta il tipo di oggetto utilizzato per rappresentare l'elemento XML.
TypeId	Quando è implementata in una classe derivata, ottiene un identificatore univoco della classe Attribute. (Ereditato da Attribute)

Metodi

Equals(Object)	Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. (Ereditato da Attribute)
GetHashCode()	Restituisce il codice hash per l'istanza. (Ereditato da Attribute)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
IsDefaultAttribute()	In caso di override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata. (Ereditato da Attribute)
Match(Object)	Quando è sottoposto a override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• XmlArrayAttribute
• XmlAttributeOverrides
• XmlAttributes
• XmlElementAttributes
• XmlElements
• XmlRootAttribute
• XmlSerializer
• Introduzione alla serializzazione XML
• Procedura: specificare un nome di elemento alternativo per un flusso XML
• Controllo della serializzazione XML mediante attributi
• Esempi di serializzazione XML
• Xml Schema Definition Tool (Xsd.exe)