SoapEnumAttribute Class
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Controls how the XmlSerializer serializes an enumeration member.
public ref class SoapEnumAttribute : Attribute
[System.AttributeUsage(System.AttributeTargets.Field)]
public class SoapEnumAttribute : Attribute
[<System.AttributeUsage(System.AttributeTargets.Field)>]
type SoapEnumAttribute = class
inherit Attribute
Public Class SoapEnumAttribute
Inherits Attribute
- Inheritance
- Attributes
Examples
The following example uses the XmlSerializer to serialize a class named Food
that includes an enumeration named FoodType
. The FoodType
enumeration is overridden by creating a SoapEnumAttribute for each enumeration and setting the SoapEnum property of a SoapAttributes to the SoapEnumAttribute. The SoapAttributes is added to a SoapAttributeOverrides that is used to create an XmlSerializer.
#using <System.Xml.dll>
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Xml::Serialization;
public enum class 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 ref class Group
{
public:
String^ GroupName;
GroupType Grouptype;
};
public ref class Run
{
public:
void SerializeObject( String^ filename )
{
// Create an instance of the XmlSerializer Class.
XmlTypeMapping^ mapp = (gcnew SoapReflectionImporter)->ImportTypeMapping( Group::typeid );
XmlSerializer^ mySerializer = gcnew XmlSerializer( mapp );
// Writing the file requires a TextWriter.
TextWriter^ writer = gcnew StreamWriter( filename );
// Create an instance of the Class that will be serialized.
Group^ myGroup = gcnew 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();
}
void SerializeOverride( String^ fileName )
{
SoapAttributeOverrides^ soapOver = gcnew SoapAttributeOverrides;
SoapAttributes^ SoapAtts = gcnew SoapAttributes;
// Add a SoapEnumAttribute for the GroupType::A enumerator.
// Instead of 'A' it will be S"West".
SoapEnumAttribute^ soapEnum = gcnew SoapEnumAttribute( "West" );
// Override the S"A" enumerator.
SoapAtts->GroupType::SoapEnum = soapEnum;
soapOver->Add( GroupType::typeid, "A", SoapAtts );
// Add another SoapEnumAttribute for the GroupType::B enumerator.
// Instead of //B// it will be S"East".
SoapAtts = gcnew SoapAttributes;
soapEnum = gcnew SoapEnumAttribute;
soapEnum->Name = "East";
SoapAtts->GroupType::SoapEnum = soapEnum;
soapOver->Add( GroupType::typeid, "B", SoapAtts );
// Create an XmlSerializer used for overriding.
XmlTypeMapping^ map = (gcnew SoapReflectionImporter( soapOver ))->ImportTypeMapping( Group::typeid );
XmlSerializer^ ser = gcnew XmlSerializer( map );
Group^ myGroup = gcnew Group;
myGroup->GroupName = ".NET";
myGroup->Grouptype = GroupType::B;
// Writing the file requires a TextWriter.
TextWriter^ writer = gcnew StreamWriter( fileName );
ser->Serialize( writer, myGroup );
writer->Close();
}
};
int main()
{
Run^ test = gcnew Run;
test->SerializeObject( "SoapEnum.xml" );
test->SerializeOverride( "SoapOverride.xml" );
Console::WriteLine( "Fininished writing two files" );
}
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();
}
}
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
Remarks
The SoapEnumAttribute class belongs to a family of attributes that controls how the XmlSerializer serializes or deserializes an object as encoded SOAP XML. The resulting XML conforms to section 5 of the World Wide Web Consortium document Simple Object Access Protocol (SOAP) 1.1. For a complete list of similar attributes, see Attributes That Control Encoded SOAP Serialization.
To serialize an object as an encoded SOAP message, you must construct the XmlSerializer using an XmlTypeMapping created with the ImportTypeMapping method of the SoapReflectionImporter class.
Use the SoapEnumAttribute to change the enumeration that the XmlSerializer generates or recognizes (when it serializes or deserializes a class, respectively). For example, if an enumeration contains a member named One
, but you prefer that the XML output be named Single
, apply the SoapEnumAttribute to the enumeration member and set the Name property to "Single".
You can override the Name property value of a SoapEnumAttribute by creating an instance of the SoapEnumAttribute class and assigning it to the SoapEnum property of a SoapAttributes. For details, see the SoapAttributeOverrides class overview.
To serialize an object as an encoded SOAP message, you must construct the XmlSerializer using an XmlTypeMapping created with the ImportTypeMapping method of the SoapReflectionImporter class.
Note
You can use the word SoapEnum
in your code instead of the longer SoapEnumAttribute.
For more information about using attributes, see Attributes.
Constructors
SoapEnumAttribute() |
Initializes a new instance of the SoapEnumAttribute class. |
SoapEnumAttribute(String) |
Initializes a new instance of the SoapEnumAttribute class using the specified element name. |
Properties
Name |
Gets or sets the value generated in an XML document when the XmlSerializer serializes an enumeration, or the value recognized when it deserializes the enumeration member. |
TypeId |
When implemented in a derived class, gets a unique identifier for this Attribute. (Inherited from Attribute) |
Methods
Equals(Object) |
Returns a value that indicates whether this instance is equal to a specified object. (Inherited from Attribute) |
GetHashCode() |
Returns the hash code for this instance. (Inherited from Attribute) |
GetType() |
Gets the Type of the current instance. (Inherited from Object) |
IsDefaultAttribute() |
When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class. (Inherited from Attribute) |
Match(Object) |
When overridden in a derived class, returns a value that indicates whether this instance equals a specified object. (Inherited from Attribute) |
MemberwiseClone() |
Creates a shallow copy of the current Object. (Inherited from Object) |
ToString() |
Returns a string that represents the current object. (Inherited from Object) |
Explicit Interface Implementations
_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Maps a set of names to a corresponding set of dispatch identifiers. (Inherited from Attribute) |
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) |
Retrieves the type information for an object, which can be used to get the type information for an interface. (Inherited from Attribute) |
_Attribute.GetTypeInfoCount(UInt32) |
Retrieves the number of type information interfaces that an object provides (either 0 or 1). (Inherited from Attribute) |
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Provides access to properties and methods exposed by an object. (Inherited from Attribute) |