XmlElementAttribute Klasse

Definition

Namespace:

System.Xml.Serialization

Assembly:

System.Xml.ReaderWriter.dll

Quelle:

XmlElementAttribute.cs

Gibt an, dass ein öffentliches Feld oder eine öffentliche Eigenschaft beim Serialisieren bzw. Deserialisieren des Objekts, in dem diese enthalten sind, durch XmlSerializer ein XML-Element darstellt.

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

Vererbung

Object

Attribute

XmlElementAttribute

Attribute

AttributeUsageAttribute

Beispiele

Im folgenden Beispiel wird eine Klasse namens Group serialisiert und auf XmlElementAttribute mehrere ihrer Member angewendet. Das Feld mit dem Namen Employees gibt ein Array von Employee Objekten zurück. In diesem Fall gibt der XmlElementAttribute an, dass der resultierende XML-Code nicht geschachtelt wird (das Standardverhalten von Elementen in einem Array).

#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

Hinweise

Gehört XmlElementAttribute zu einer Familie von Attributen, die steuern, wie ein XmlSerializer Objekt serialisiert oder deserialisiert wird. Eine vollständige Liste ähnlicher Attribute finden Sie unter Attribute, die die XML-Serialisierung steuern.

Ein XML-Dokument enthält normalerweise XML-Elemente, die jeweils aus drei Teilen bestehen: einem öffnenden Tag mit möglichen Attributen, einem schließenden Tag und den Daten zwischen den Tags. XML-Tags können geschachtelt werden. Das heißt, die Daten zwischen Tags können auch XML-Elemente sein. Diese Fähigkeit eines Elements, ein anderes einzuschließen, ermöglicht es dem Dokument, Hierarchien von Daten zu enthalten. Ein XML-Element kann auch Attribute enthalten.

Wenden Sie die XmlElementAttribute auf öffentliche Felder oder öffentliche Lese-/Schreibeigenschaften an, um Merkmale der XML-Elemente wie den Elementnamen und den Namespace zu steuern.

Kann XmlElementAttribute mehrmals auf ein Feld angewendet werden, das ein Array von Objekten zurückgibt. Der Zweck besteht darin, (über die Type -Eigenschaft) verschiedene Typen anzugeben, die in das Array eingefügt werden können. Beispielsweise akzeptiert das Array im folgenden C#-Code sowohl Zeichenfolgen als auch ganze Zahlen.

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

Dies führt zu XML, die wie folgt aussehen könnte.

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

Beachten Sie, dass die Elemente nach dem Typ der zulässigen Objekte benannt werden, wenn Sie den XmlElementAttribute Wert mehrmals anwenden, ohne einen ElementName Eigenschaftswert anzugeben.

Wenn Sie die XmlElementAttribute auf ein Feld oder eine Eigenschaft anwenden, die ein Array zurückgibt, werden die Elemente im Array als Sequenz von XML-Elementen codiert.

Im Gegensatz dazu, wenn ein XmlElementAttribute nicht auf ein solches Feld oder eine solche Eigenschaft angewendet wird, werden die Elemente im Array als Sequenz von Elementen codiert, die unter einem Element geschachtelt sind, das nach dem Feld oder der Eigenschaft benannt ist. (Verwenden Sie die XmlArrayAttribute Attribute und XmlArrayItemAttribute , um zu steuern, wie ein Array serialisiert wird.)

Sie können die Type -Eigenschaft festlegen, um einen Typ anzugeben, der vom Typ des ursprünglichen Felds oder der ursprünglichen Eigenschaft abgeleitet ist, d. h. das Feld oder die Eigenschaft, auf das Sie angewendet XmlElementAttributehaben.

Wenn ein Feld oder eine Eigenschaft einen ArrayListzurückgibt, können Sie mehrere Instanzen von auf XmlElementAttribute das Element anwenden. Legen Sie für jede Instanz die Type Eigenschaft auf einen Objekttyp fest, der in das Array eingefügt werden kann.

Weitere Informationen zur Verwendung von Attributen finden Sie unter Attribute.

Hinweis

Sie können das Wort XmlElement im Code anstelle des längeren XmlElementAttributeverwenden.

Konstruktoren

XmlElementAttribute()	Initialisiert eine neue Instanz der XmlElementAttribute-Klasse.
XmlElementAttribute(String)	Initialisiert eine neue Instanz der XmlElementAttribute-Klasse und gibt den Namen des XML-Elements an.
XmlElementAttribute(String, Type)	Initialisiert eine neue Instanz von XmlElementAttribute, und gibt den Namen des XML-Elements und einen abgeleiteten Typ für den Member an, auf den das XmlElementAttribute angewendet wird. Dieser Membertyp wird verwendet, wenn der XmlSerializer das Objekt serialisiert, in dem es enthalten ist.
XmlElementAttribute(Type)	Initialisiert eine neues Instanz der XmlElementAttribute-Klasse und gibt einen Typ für den Member an, auf den das XmlElementAttribute angewendet wird. Dieser Typ wird vom XmlSerializer verwendet, wenn das Objekt serialisiert oder deserialisiert wird, in dem es enthalten ist.

Eigenschaften

DataType	Ruft den XSD (XML Schema Definition)-Datentyp des vom XmlSerializer generierten XML-Elements ab oder legt diesen fest.
ElementName	Ruft den Namen des generierten XML-Elements ab oder legt diesen fest.
Form	Ruft einen Wert ab, der angibt, ob das Element qualifiziert ist.
IsNullable	Ruft einen Wert ab, der angibt, ob XmlSerializer einen Member, der auf null festgelegt ist, als leeres Tag, dessen xsi:nil-Attribut auf true festgelegt ist, serialisieren muss, oder legt diesen fest.
Namespace	Ruft den Namespace ab, der dem XML-Element zugeordnet ist, das aus dem Serialisieren der Klasse resultiert, oder legt diesen fest.
Order	Ruft die explizite Reihenfolge ab, in der die Elemente serialisiert oder deserialisiert werden, oder legt diese fest.
Type	Ruft den Objekttyp ab, mit dem das XML-Element dargestellt wird, oder legt diesen fest.
TypeId	Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab. (Geerbt von Attribute)

Methoden

Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Geerbt von Attribute)
GetHashCode()	Gibt den Hashcode für diese Instanz zurück. (Geerbt von Attribute)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
IsDefaultAttribute()	Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist. (Geerbt von Attribute)
Match(Object)	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht. (Geerbt von Attribute)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Weitere Informationen

• XmlArrayAttribute
• XmlAttributeOverrides
• XmlAttributes
• XmlElementAttributes
• XmlElements
• XmlRootAttribute
• XmlSerializer
• Einführung in die XML-Serialisierung
• How to: Angeben eines alternativen Elementnamens für einen XML-Stream.
• Steuern der XML-Serialisierung mit Attributen
• Beispiele für die XML-Serialisierung
• XML Schema Definition-Tool (Xsd.exe)