SoapEnumAttribute-Klasse
Steuert die Art, in der XmlSerializer einen Enumerationsmember serialisiert.
Namespace: System.Xml.Serialization
Assembly: System.Xml (in system.xml.dll)
Syntax
'Declaration
<AttributeUsageAttribute(AttributeTargets.Field)> _
Public Class SoapEnumAttribute
Inherits Attribute
'Usage
Dim instance As SoapEnumAttribute
[AttributeUsageAttribute(AttributeTargets.Field)]
public class SoapEnumAttribute : Attribute
[AttributeUsageAttribute(AttributeTargets::Field)]
public ref class SoapEnumAttribute : public Attribute
/** @attribute AttributeUsageAttribute(AttributeTargets.Field) */
public class SoapEnumAttribute extends Attribute
AttributeUsageAttribute(AttributeTargets.Field)
public class SoapEnumAttribute extends Attribute
Hinweise
Die SoapEnumAttribute-Klasse gehört zu einer Familie von Attributen, die das Serialisieren bzw. Deserialisieren eines Objekts als codiertes SOAP-XML durch XmlSerializer steuern. Das resultierende XML entspricht Abschnitt 5 des Dokuments "Simple Object Access Protocol (SOAP) 1.1" des World Wide Web Consortium (www.w3.org). Eine vollständige Liste ähnlicher Attribute finden Sie unter Attribute für die Steuerung der Serialisierung von codiertem SOAP.
Um ein Objekt als codierte SOAP-Meldung zu serialisieren, müssen Sie den XmlSerializer mithilfe einer XmlTypeMapping erstellen, die mit der ImportTypeMapping-Methode der SoapReflectionImporter-Klasse erstellt wurde.
Verwenden Sie SoapEnumAttribute, um die von XmlSerializer beim Serialisieren einer Klasse generierte bzw. beim Deserialisieren erkannte Enumeration zu ändern. Wenn eine Enumeration z. B. den Member One enthält, Sie aber die XML-Ausgabe Single bevorzugen, weisen Sie dem Enumerationsmember das SoapEnumAttribute zu, und legen Sie dessen Name-Eigenschaft auf "Single" fest.
Sie können den Name-Eigenschaftenwert eines SoapEnumAttribute überschreiben, indem Sie eine Instanz der SoapEnumAttribute-Klasse erstellen und diese der SoapEnum-Eigenschaft eines SoapAttributes zuweisen. Weitere Informationen finden Sie in der Übersicht über die SoapAttributeOverrides-Klasse.
Um ein Objekt als codierte SOAP-Meldung zu serialisieren, müssen Sie den XmlSerializer mithilfe einer XmlTypeMapping erstellen, die mit der ImportTypeMapping-Methode der SoapReflectionImporter-Klasse erstellt wurde.
Hinweis
Sie können das Wort SoapEnum anstelle des längeren SoapEnumAttribute im Code verwenden.
Weitere Informationen über das Verwenden von Attributen finden Sie unter Erweitern von Metadaten mithilfe von Attributen.
Beispiel
Im folgenden Beispiel wird XmlSerializer zum Serialisieren einer Klasse mit dem Namen Food verwendet, die die Enumeration FoodType enthält. Die FoodType-Enumeration wird überschrieben, indem ein SoapEnumAttribute für jede Enumeration erstellt und die SoapEnum-Eigenschaft eines SoapAttributes auf das SoapEnumAttribute festgelegt wird. Das SoapAttributes wird einem SoapAttributeOverrides hinzugefügt, mit dem eine XmlSerializer erstellt wird.
Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Public Class Group
Public GroupName As String
Public Grouptype As GroupType
End Class
Public enum GroupType
' Use the SoapEnumAttribute to instruct the XmlSerializer
' to generate Small and Large instead of A and B.
<SoapEnum("Small")> _
A
<SoapEnum("Large")> _
B
End enum
Public Class Run
Public Shared Sub Main()
Dim test As Run = new Run()
test.SerializeObject("SoapEnum.xml")
test.SerializeOverride("SoapOverride.xml")
Console.WriteLine("Fininished writing two files")
End Sub
Private Shared Sub SerializeObject(filename As string)
' Create an instance of the XmlSerializer Class.
Dim mapp As XmlTypeMapping = _
(New SoapReflectionImporter()).ImportTypeMapping(GetType(Group))
Dim mySerializer As XmlSerializer = New XmlSerializer(mapp)
' Writing the file requires a TextWriter.
Dim writer As TextWriter = New StreamWriter(filename)
' Create an instance of the Class that will be serialized.
Dim myGroup As Group = New Group()
' Set the object properties.
myGroup.GroupName = ".NET"
myGroup.Grouptype= GroupType.A
' Serialize the Class, and close the TextWriter.
mySerializer.Serialize(writer, myGroup)
writer.Close()
End Sub
Private Sub SerializeOverride(fileName As String)
Dim soapOver As SoapAttributeOverrides = new SoapAttributeOverrides()
Dim SoapAtts As SoapAttributes = new SoapAttributes()
' Add a SoapEnumAttribute for the GroupType.A enumerator. Instead
' of 'A' it will be "West".
Dim soapEnum As SoapEnumAttribute = new SoapEnumAttribute("West")
' Override the "A" enumerator.
SoapAtts.SoapEnum = soapEnum
soapOver.Add(GetType(GroupType), "A", SoapAtts)
' Add another SoapEnumAttribute for the GroupType.B enumerator.
' Instead of 'B' it will be "East".
SoapAtts= New SoapAttributes()
soapEnum = new SoapEnumAttribute()
soapEnum.Name = "East"
SoapAtts.SoapEnum = soapEnum
soapOver.Add(GetType(GroupType), "B", SoapAtts)
' Create an XmlSerializer used for overriding.
Dim map As XmlTypeMapping = New SoapReflectionImporter _
(soapOver).ImportTypeMapping(GetType(Group))
Dim ser As XmlSerializer = New XmlSerializer(map)
Dim myGroup As Group = New Group()
myGroup.GroupName = ".NET"
myGroup.Grouptype = GroupType.B
' Writing the file requires a TextWriter.
Dim writer As TextWriter = New StreamWriter(fileName)
ser.Serialize(writer, myGroup)
writer.Close
End Sub
End Class
using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
public class Group{
public string GroupName;
public GroupType Grouptype;
}
public enum GroupType{
// Use the SoapEnumAttribute to instruct the XmlSerializer
// to generate Small and Large instead of A and B.
[SoapEnum("Small")]
A,
[SoapEnum("Large")]
B
}
public class Run {
static void Main(){
Run test= new Run();
test.SerializeObject("SoapEnum.xml");
test.SerializeOverride("SoapOverride.xml");
Console.WriteLine("Fininished writing two files");
}
private void SerializeObject(string filename){
// Create an instance of the XmlSerializer Class.
XmlTypeMapping mapp =
(new SoapReflectionImporter()).ImportTypeMapping(typeof(Group));
XmlSerializer mySerializer = new XmlSerializer(mapp);
// Writing the file requires a TextWriter.
TextWriter writer = new StreamWriter(filename);
// Create an instance of the Class that will be serialized.
Group myGroup = new Group();
// Set the object properties.
myGroup.GroupName = ".NET";
myGroup.Grouptype= GroupType.A;
// Serialize the Class, and close the TextWriter.
mySerializer.Serialize(writer, myGroup);
writer.Close();
}
private void SerializeOverride(string fileName){
SoapAttributeOverrides soapOver = new SoapAttributeOverrides();
SoapAttributes SoapAtts = new SoapAttributes();
// Add a SoapEnumAttribute for the GroupType.A enumerator.
// Instead of 'A' it will be "West".
SoapEnumAttribute soapEnum = new SoapEnumAttribute("West");
// Override the "A" enumerator.
SoapAtts.SoapEnum = soapEnum;
soapOver.Add(typeof(GroupType), "A", SoapAtts);
// Add another SoapEnumAttribute for the GroupType.B enumerator.
// Instead of //B// it will be "East".
SoapAtts= new SoapAttributes();
soapEnum = new SoapEnumAttribute();
soapEnum.Name = "East";
SoapAtts.SoapEnum = soapEnum;
soapOver.Add(typeof(GroupType), "B", SoapAtts);
// Create an XmlSerializer used for overriding.
XmlTypeMapping map =
new SoapReflectionImporter(soapOver).
ImportTypeMapping(typeof(Group));
XmlSerializer ser = new XmlSerializer(map);
Group myGroup = new Group();
myGroup.GroupName = ".NET";
myGroup.Grouptype = GroupType.B;
// Writing the file requires a TextWriter.
TextWriter writer = new StreamWriter(fileName);
ser.Serialize(writer, myGroup);
writer.Close();
}
}
import System.*;
import System.IO.*;
import System.Xml.*;
import System.Xml.Serialization.*;
public class Group
{
public String groupName;
public GroupType groupType;
} //Group
public class GroupType
{
// Use the SoapEnumAttribute to instruct the XmlSerializer
// to generate Small and Large instead of a and b.
public int member;
public GroupType()
{
member = 0;
} //GroupType
public GroupType(int n)
{
member = n;
} //GroupType
/** @attribute SoapEnum("Small")
*/
public static int a = 0;
/** @attribute SoapEnum("Large")
*/
public static int b = 1;
} //GroupType
public class Run
{
public static void main(String[] args)
{
Run test = new Run();
test.SerializeObject("SoapEnum.xml");
test.SerializeOverride("SoapOverride.xml");
Console.WriteLine("Fininished writing two files");
} //main
private void SerializeObject(String fileName)
{
// Writing the file requires a TextWriter.
TextWriter writer = new StreamWriter(fileName);
// Create an instance of the Class that will be serialized.
Group myGroup = new Group();
// Set the object properties.
myGroup.groupName = ".NET";
myGroup.groupType = new GroupType(GroupType.a);
// Create an instance of the XmlSerializer Class.
XmlSerializer mySerializer = new XmlSerializer(myGroup.GetType());
// Serialize the Class, and close the TextWriter.
mySerializer.Serialize(writer, myGroup);
writer.Close();
} //SerializeObject
private void SerializeOverride(String fileName)
{
SoapAttributeOverrides soapOver = new SoapAttributeOverrides();
SoapAttributes SoapAtts = new SoapAttributes();
// Add a SoapEnumAttribute for the GroupType.a enumerator.
// Instead of 'a' it will be "West".
SoapEnumAttribute soapEnum = new SoapEnumAttribute("West");
// Override the "a" enumerator.
SoapAtts.set_SoapEnum(soapEnum);
soapOver.Add(GroupType.class.ToType(), "a", SoapAtts);
// Add another SoapEnumAttribute for the GroupType.b enumerator.
// Instead of b it will be "East".
SoapAtts = new SoapAttributes();
soapEnum = new SoapEnumAttribute();
soapEnum.set_Name("East");
SoapAtts.set_SoapEnum(soapEnum);
soapOver.Add(GroupType.class.ToType(), "b", SoapAtts);
// Create an XmlSerializer used for overriding.
Group myGroup = new Group();
myGroup.groupName = ".NET";
myGroup.groupType = new GroupType(GroupType.b);
// Writing the file requires a TextWriter.
TextWriter writer = new StreamWriter(fileName);
XmlSerializer ser = new XmlSerializer(myGroup.GetType());
ser.Serialize(writer, myGroup);
writer.Close();
} //SerializeOverride
} //Run
Vererbungshierarchie
System.Object
System.Attribute
System.Xml.Serialization.SoapEnumAttribute
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