XmlTextAttribute-Klasse

Gibt dem XmlSerializer an, dass der Member beim Serialisieren oder Deserialisieren der Klasse, in der er enthalten ist, als XML-Text behandelt werden muss.

Namespace: System.Xml.Serialization
Assembly: System.Xml (in system.xml.dll)

Syntax

'Declaration
<AttributeUsageAttribute(AttributeTargets.Property Or AttributeTargets.Field Or AttributeTargets.Parameter Or AttributeTargets.ReturnValue)> _
Public Class XmlTextAttribute
    Inherits Attribute
'Usage
Dim instance As XmlTextAttribute

[AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue)] 
public class XmlTextAttribute : Attribute

[AttributeUsageAttribute(AttributeTargets::Property|AttributeTargets::Field|AttributeTargets::Parameter|AttributeTargets::ReturnValue)] 
public ref class XmlTextAttribute : public Attribute

/** @attribute AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue) */ 
public class XmlTextAttribute extends Attribute

AttributeUsageAttribute(AttributeTargets.Property|AttributeTargets.Field|AttributeTargets.Parameter|AttributeTargets.ReturnValue) 
public class XmlTextAttribute extends Attribute

Hinweise

Das XmlTextAttribute gehört zu einer Familie von Attributen, die die Art steuern, in der XmlSerializer ein Objekt mit der Serialize-Methode und der Deserialize-Methode serialisiert und deserialisiert. Eine vollständige Liste ähnlicher Attribute finden Sie unter Attribute für die Steuerung der XML-Serialisierung.

In einer Klasse kann nur eine Instanz der XmlTextAttribute-Klasse angewendet werden.

Sie können XmlTextAttribute auf öffentliche Felder und öffentliche Lese-/Schreib-Eigenschaften anwenden, die primitive Typen und Enumerationstypen zurückgeben.

Sie können XmlTextAttribute Feldern oder Eigenschaften zuweisen, die ein Array aus Zeichenfolgen zurückgeben. Sie können das Attribut auch auf ein Array vom Typ Object anwenden; allerdings müssen Sie die Type-Eigenschaft dazu auf "string" festlegen. In diesem Fall werden alle in das Array eingefügten Zeichenfolgen als XML-Text serialisiert.

XmlTextAttribute kann auch auf ein Feld angewendet werden, das XmlNode oder ein Array aus XmlNode-Objekten zurückgibt.

In der Standardeinstellung wird ein Klassenmember von XmlSerializer als XML-Element serialisiert. Wenn Sie allerdings das XmlTextAttribute auf einen Member anwenden, wird dessen Wert von XmlSerializer in XML-Text übersetzt. Dies bedeutet, dass der Wert als Inhalt eines XML-Elements codiert wird.

In manchen Fällen generiert XML Schema Definition-Tool (Xsd.exe) das XmlTextAttribute beim Erstellen von Klassen aus einer XML-Schemadefinitionsdatei (XSD-Datei). Dies erfolgt, wenn das Schema einen complexType mit gemischtem Inhalt enthält. In diesem Fall enthält die entsprechende Klasse einen Member, der ein Zeichenfolgenarray zurückgibt, auf das XmlTextAttribute angewendet wird. Wenn das Xml Schema Definition-Tool z.B. das folgende Schema verarbeitet:

 <xs:schema attributeFormDefault="qualified" elementFormDefault="qualified" targetNamespace="" 
 xmlns:xs="http://www.w3.org/2001/XMLSchema">
   <xs:element name="LinkList" type="LinkList" />
   <xs:complexType name="LinkList" mixed="true">
     <xs:sequence>
       <xs:element minOccurs="1" maxOccurs="1" name="id" type="xs:int" />
       <xs:element minOccurs="0" maxOccurs="1" name="name" type="xs:string" />
       <xs:element minOccurs="0" maxOccurs="1" name="next" type="LinkList" />
     </xs:sequence>
   </xs:complexType>
 </xs:schema>

Die folgende Klasse wird generiert:

 ' Visual Basic code
 Public Class LinkList 
    Public id As Integer
    Public string name
    Public LinkList next
    <System.Xml.Serialization.XmlTextAttribute()> _
    Public Text() As string
 End Class
 // C# code
 public class LinkList {
    public int id;
    public string name;
    public LinkList next;
    [System.Xml.Serialization.XmlTextAttribute()]
    public string[] Text;
 }

Weitere Informationen über das Verwenden von Attributen finden Sie unter Erweitern von Metadaten mithilfe von Attributen.

Hinweis

Sie können das Wort XmlText anstelle des längeren XmlTextAttribute im Code verwenden.

Beispiel

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


Public Class Group1
   ' The XmlTextAttribute with type set to String informs the 
   ' XmlSerializer that strings should be serialized as XML text.
   <XmlText(GetType(String)), _
   XmlElement(GetType(integer)), _  
   XmlElement(GetType(double))> _
   public All () As Object = _
   New Object (){321, "One", 2, 3.0, "Two" }
End Class


Public Class Group2
   <XmlText(GetType(GroupType))> _
   public Type As GroupType 
End Class

Public Enum GroupType
   Small
   Medium
   Large
End Enum

Public Class Group3
   <XmlText(GetType(DateTime))> _
   Public CreationTime As DateTime = DateTime.Now
End Class

Public Class Test
   Shared Sub Main()
      Dim t As Test = New Test()
      t.SerializeArray("XmlText1.xml")
      t.SerializeEnum("XmlText2.xml")
      t.SerializeDateTime("XmlText3.xml")
   End Sub

   Private Sub SerializeArray(filename As String)
      Dim ser As XmlSerializer = New XmlSerializer(GetType(Group1))
      Dim myGroup1 As Group1 = New Group1()

      Dim writer As TextWriter = New StreamWriter(filename)

      ser.Serialize(writer, myGroup1)
      writer.Close()
   End Sub

   Private Sub SerializeEnum(filename As String)
      Dim ser As XmlSerializer = New XmlSerializer(GetType(Group2))
      Dim myGroup As Group2 = New Group2()
      myGroup.Type = GroupType.Medium
      Dim writer As TextWriter = New StreamWriter(filename)

      ser.Serialize(writer, myGroup)
      writer.Close()
   End Sub

   Private Sub SerializeDateTime(filename As String)
      Dim ser As XmlSerializer = new XmlSerializer(GetType(Group3))
      Dim myGroup As Group3 = new Group3()
      Dim writer As TextWriter = new StreamWriter(filename)

      ser.Serialize(writer, myGroup)
      writer.Close()
   End Sub
End Class

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


public class Group1{
   // The XmlTextAttribute with type set to string informs the 
   // XmlSerializer that strings should be serialized as XML text.
   [XmlText(typeof(string))]
   [XmlElement(typeof(int))]  
   [XmlElement(typeof(double))]
   public object [] All= new object []{321, "One", 2, 3.0, "Two" };
}

public class Group2{
   [XmlText(Type = typeof(GroupType))]
   public GroupType Type;
}
public enum GroupType{
   Small,
   Medium,
   Large
}

public class Group3{
   [XmlText(Type=typeof(DateTime))]
   public DateTime CreationTime = DateTime.Now;
}

public class Test{
   static void Main(){
      Test t = new Test();
      t.SerializeArray("XmlText1.xml");
      t.SerializeEnum("XmlText2.xml");
      t.SerializeDateTime("XmlText3.xml");
   }

   private void SerializeArray(string filename){
      XmlSerializer ser = new XmlSerializer(typeof(Group1));
      Group1 myGroup1 = new Group1();

      TextWriter writer = new StreamWriter(filename);

      ser.Serialize(writer, myGroup1);
      writer.Close();
   }

   private void SerializeEnum(string filename){
      XmlSerializer ser = new XmlSerializer(typeof(Group2));
      Group2 myGroup = new Group2();
      myGroup.Type = GroupType.Medium;
      TextWriter writer = new StreamWriter(filename);

      ser.Serialize(writer, myGroup);
      writer.Close();
   }

   private void SerializeDateTime(string filename){
      XmlSerializer ser = new XmlSerializer(typeof(Group3));
      Group3 myGroup = new Group3();
      TextWriter writer = new StreamWriter(filename);

      ser.Serialize(writer, myGroup);
      writer.Close();
   }   
}

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

using namespace System;
using namespace System::Xml::Serialization;
using namespace System::IO;

public ref class Group1
{
public:

   // The XmlTextAttribute with type set to string informs the 
   // XmlSerializer that strings should be serialized as XML text.

   [XmlText(String::typeid)]
   [XmlElement(Int32::typeid)]
   [XmlElement(Double::typeid)]
   array<Object^>^All;
   Group1()
   {
      array<Object^>^temp = {321,"One",2,3.0,"Two"};
      All = temp;
   }
};

public enum class GroupType
{
   Small, Medium, Large
};

public ref class Group2
{
public:

   [XmlText(Type=GroupType::typeid)]
   GroupType Type;
};

public ref class Group3
{
public:

   [XmlText(Type=DateTime::typeid)]
   DateTime CreationTime;
   Group3()
   {
      CreationTime = DateTime::Now;
   }
};

public ref class Test
{
public:
   static void main()
   {
      Test^ t = gcnew Test;
      t->SerializeArray( "XmlText1.xml" );
      t->SerializeEnum( "XmlText2.xml" );
      t->SerializeDateTime( "XmlText3.xml" );
   }

private:
   void SerializeArray( String^ filename )
   {
      XmlSerializer^ ser = gcnew XmlSerializer( Group1::typeid );
      Group1^ myGroup1 = gcnew Group1;
      TextWriter^ writer = gcnew StreamWriter( filename );
      ser->Serialize( writer, myGroup1 );
      writer->Close();
   }

   void SerializeEnum( String^ filename )
   {
      XmlSerializer^ ser = gcnew XmlSerializer( Group2::typeid );
      Group2^ myGroup = gcnew Group2;
      myGroup->Type = GroupType::Medium;
      TextWriter^ writer = gcnew StreamWriter( filename );
      ser->Serialize( writer, myGroup );
      writer->Close();
   }

   void SerializeDateTime( String^ filename )
   {
      XmlSerializer^ ser = gcnew XmlSerializer( Group3::typeid );
      Group3^ myGroup = gcnew Group3;
      TextWriter^ writer = gcnew StreamWriter( filename );
      ser->Serialize( writer, myGroup );
      writer->Close();
   }
};

int main()
{
   Test::main();
}

import System.*;
import System.Xml.Serialization.*;
import System.IO.*;

public class Group1
{
    // The XmlTextAttribute with type set to string informs the 
    // XmlSerializer that strings should be serialized as XML text.
    /** @attribute XmlText(String.class)
     */
    /** @attribute XmlElement(int.class)
     */
    /** @attribute XmlElement(double.class)
     */
    public Object all[] = new Object[] { (Int32)321, "One", (Int32)2,
        (System.Double)3.0, "Two" };
} //Group1

public class Group2
{
    /** @attribute XmlElement(GroupType.class, ElementName = "GroupType")
     */
    public GroupType type;
} //Group2

public class GroupType
{
    private int member;
    GroupType()
    {
        member = 0;
    } //GroupType

    GroupType(int n)
    {
        member = n;
    } //GroupType

    public static int small;
    public static int medium;
    public static int large;
} //GroupType

public class Group3
{
    /** @attribute XmlText(Type = DateTime.class)
     */
    public DateTime creationTime = DateTime.get_Now();
} //Group3

public class Test
{
    public static void main(String[] args)
    {
        Test t = new Test();
        t.SerializeArray("XmlText1.xml");
        t.SerializeEnum("XmlText2.xml");
        t.SerializeDateTime("XmlText3.xml");
    } //main

    private void SerializeArray(String fileName)
    {
        XmlSerializer ser = new XmlSerializer(Group1.class.ToType());
        Group1 myGroup1 = new Group1();
        TextWriter writer = new StreamWriter(fileName);
        ser.Serialize(writer, myGroup1);
        writer.Close();
    } //SerializeArray

    private void SerializeEnum(String fileName)
    {
        XmlSerializer ser = new XmlSerializer(Group2.class.ToType());
        Group2 myGroup = new Group2();
        myGroup.type = new GroupType(GroupType.medium);
        TextWriter writer = new StreamWriter(fileName);
        ser.Serialize(writer, myGroup);
        writer.Close();
    } //SerializeEnum

    private void SerializeDateTime(String fileName)
    {
        XmlSerializer ser = new XmlSerializer(Group3.class.ToType());
        Group3 myGroup = new Group3();
        TextWriter writer = new StreamWriter(fileName);
        ser.Serialize(writer, myGroup);
        writer.Close();
    } //SerializeDateTime
} //Test

Vererbungshierarchie

System.Object
   System.Attribute
    System.Xml.Serialization.XmlTextAttribute

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

XmlTextAttribute-Member
System.Xml.Serialization-Namespace
XmlAttributeOverrides-Klasse
XmlAttributes-Klasse
XmlSerializer-Klasse
XmlAttributes.XmlText-Eigenschaft
XmlAttributes-Klasse

Weitere Ressourcen

Einführung in die XML-Serialisierung
Gewusst wie: 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)