XmlElementAttribute Klasse

Definition

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
XmlElementAttribute
Attribute

Beispiele

Im folgenden Beispiel wird eine Klasse namens serialisiert Group und auf mehrere ihrer Member XmlElementAttribute angewendet. Das Feld mit dem Namen Employees gibt ein Array von Employee -Objekten zurück. In diesem Fall gibt an, XmlElementAttribute dass das resultierende XML 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 steuert, wie das ein Objekt XmlSerializer serialisiert oder deserialisiert. Eine vollständige Liste ähnlicher Attribute finden Sie unter Attribute, die die XML-Serialisierung steuern.

Ein XML-Dokument enthält in der Regel 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 sein, d. h., die Daten zwischen Tags können auch XML-Elemente sein. Diese Kapazität 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 XmlElementAttribute auf öffentliche Felder oder öffentliche Lese-/Schreibeigenschaften an, um die Merkmale der XML-Elemente wie den Elementnamen und den Namespace zu steuern.

XmlElementAttributekann mehrmals auf ein Feld angewendet werden, das ein Array von -Objekten zurückgibt. Dies dient dazu, (ü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, das etwa wie folgt aussehen kann.

<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 mehrmals XmlElementAttribute anwenden, ohne einen ElementName Eigenschaftswert anzugeben.

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

Wenn dagegen XmlElementAttribute kein 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 , um zu XmlArrayItemAttribute 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 bzw. die Sie angewendet XmlElementAttribute haben.

Wenn ein Feld oder eine Eigenschaft ein ArrayList zurückgibt, können Sie mehrere Instanzen von auf den Member XmlElementAttribute 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 in Ihrem Code anstelle des längeren XmlElementAttribute verwenden.

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)

Explizite Schnittstellenimplementierungen

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.

(Geerbt von Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können.

(Geerbt von Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).

(Geerbt von Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.

(Geerbt von Attribute)

Gilt für

Siehe auch