SoapAttributes クラス

[アーティクル]
03/28/2008

XmlSerializer が SOAP メソッドをシリアル化および逆シリアル化する方法を制御する属性オブジェクトのコレクションを表します。

この型のすべてのメンバの一覧については、SoapAttributes メンバを参照してください。

System.Object
System.Xml.Serialization.SoapAttributes

Public Class SoapAttributes
[C#]
public class SoapAttributes
[C++]
public __gc class SoapAttributes
[JScript]
public class SoapAttributes

スレッドセーフ

この型の public static (Visual Basicでは Shared) のすべてのメンバは、マルチスレッド操作で安全に使用できます。インスタンスのメンバの場合は、スレッドセーフであるとは限りません。

解説

SoapAttributes の作成は、 XmlSerializer がクラスインスタンスをシリアル化する既定の方法をオーバーライドするプロセスに含まれます。たとえば、アクセスできないソースを持つ DLL から作成されたオブジェクトをシリアル化するとします。 SoapAttributeOverrides クラスを使用することにより、そのようなオブジェクトをシリアル化する別の方法を追加したり、その他の形でシリアル化を制御したりできます。

SoapAttributes クラスのメンバは、シリアル化を制御する一連の属性クラスに直接対応します。たとえば、 SoapAttribute プロパティには SoapAttributeAttribute を設定する必要があります。これにより、フィールドまたはプロパティの値をエンコード済みの SOAP 属性としてシリアル化するように XmlSerializer に指示し、それらのフィールドやプロパティのシリアル化をオーバーライドできます。エンコード済み SOAP としてのシリアル化を制御する属性の完全な一覧については、「エンコード済み SOAP シリアル化を制御する属性」を参照してください。

SoapAttributes クラスのインスタンスを SoapAttributeOverrides クラスのインスタンスに追加する方法については、 SoapAttributeOverrides クラスの概要を参照してください。

使用例

[Visual Basic, C#, C++] Group という名前のクラスをシリアル化する例を次に示します。 GroupName フィールド、 IgnoreThis フィールド、および GroupType 列挙体のメンバのシリアル化がオーバーライドされます。 CreateOverrideSerializer メソッド内では、 SoapAttributeOverrides が作成され、オーバーライド対象のメンバまたは列挙体ごとに、適切なプロパティが設定された SoapAttributes が作成され、それぞれが SoapAttributeOverrides に追加されています。 XmlTypeMapping が SoapAttributeOverrides を使用して作成され、その XmlTypeMapping を使用して、既定のシリアル化をオーバーライドする XmlSerializer が作成されます。

 
Imports System
Imports System.IO
Imports System.Text
Imports System.Xml
Imports System.Xml.Serialization
Imports System.Xml.Schema

Public Class Group
   <SoapAttribute (Namespace:= "http:'www.cpandl.com")> _
   Public GroupName As String 
   
   <SoapAttribute(DataType:= "base64Binary")> _
   Public GroupNumber() As Byte

   <SoapAttribute(DataType:= "date", _
   AttributeName:= "CreationDate")> _
   Public Today As DateTime 
   <SoapElement(DataType:= "nonNegativeInteger", _
   ElementName:= "PosInt")> _
   Public PostitiveInt As String 
   ' This is ignored when serialized unless it's overridden.
   <SoapIgnore> _ 
   Public IgnoreThis As Boolean 
   
   Public Grouptype As GroupType 

   Public MyVehicle As Vehicle 

   '  The SoapInclude allows the method to return a Car.
   <SoapInclude(GetType(Car))> _
   Public Function myCar(licNumber As String ) As Vehicle 
      Dim v As Vehicle 
      if licNumber = "" Then
         v = New Car()
         v.licenseNumber = "!!!!!!"
      else  
          v = New Car()
          v.licenseNumber = licNumber
      End If
      
      return v
   End Function
End Class
  
' SoapInclude allows Vehicle to accept Car type.
<SoapInclude(GetType(Car))> _
Public MustInherit  class Vehicle
   Public licenseNumber As String 
   Public makeDate As DateTime 
End Class

Public Class Car
   Inherits Vehicle

End Class

Public enum GroupType
   ' These enums can be overridden.
   <SoapEnum("Small")> _
   A
   <SoapEnum("Large")> _ 
   B
End Enum
 
Public Class Run

   Shared Sub Main()
      Dim test As Run = New Run()
      test.SerializeOriginal("SoapOriginal.xml")
      test.SerializeOverride("SoapOverrides.xml")
      test.DeserializeOriginal("SoapOriginal.xml")
      test.DeserializeOverride("SoapOverrides.xml")
   End SUb
   
   Public Sub SerializeOriginal(filename As String)

      ' Create an instance of the XmlSerializer class.
      Dim myMapping As XmlTypeMapping = _
      (New SoapReflectionImporter().ImportTypeMapping _
      (GetType(Group)))
      Dim mySerializer As XmlSerializer =  _
      New XmlSerializer(myMapping)
      
      Dim myGroup As Group =MakeGroup()
      ' Writing the file requires a TextWriter.
      Dim writer As XmlTextWriter  = _
      New XmlTextWriter(filename, Encoding.UTF8)
      writer.Formatting = Formatting.Indented
      writer.WriteStartElement("wrapper")
      ' Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myGroup)
      writer.WriteEndElement()
      writer.Close()
   End Sub

   Public Sub SerializeOverride(filename As String)
      ' Create an instance of the XmlSerializer class
      ' that overrides the serialization.
      Dim overRideSerializer As XmlSerializer = _
      CreateOverrideSerializer()
      Dim myGroup As Group =MakeGroup()
      ' Writing the file requires a TextWriter.
      Dim writer As XmlTextWriter  = _
      New XmlTextWriter(filename, Encoding.UTF8)
      writer.Formatting = Formatting.Indented
      writer.WriteStartElement("wrapper")
      ' Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup)
      writer.WriteEndElement()
      writer.Close()
    End Sub

   private Function MakeGroup() As Group 
      ' Create an instance of the class that will be serialized.
      Dim myGroup As Group  = New Group()

      ' Set the object properties.
      myGroup.GroupName = ".NET"

      Dim hexByte()As Byte = new Byte(1){Convert.ToByte(100), _
      Convert.ToByte(50)}
      myGroup.GroupNumber = hexByte

      Dim myDate As DateTime  = new DateTime(2002,5,2)
      myGroup.Today = myDate

      myGroup.PostitiveInt = "10000"
    myGroup.IgnoreThis = true
    myGroup.Grouptype = GroupType.B
    Dim thisCar As Car 
    thisCar =CType(myGroup.myCar("1234566"), Car)
    myGroup.myVehicle=thisCar
      return myGroup
   End Function       

   Public Sub DeserializeOriginal(filename As String)
      ' Create an instance of the XmlSerializer class.
      Dim myMapping As XmlTypeMapping = _
      (New SoapReflectionImporter().ImportTypeMapping _
      (GetType(Group)))
      Dim mySerializer As XmlSerializer =  _
      New XmlSerializer(myMapping)

      ' Reading the file requires an  XmlTextReader.
      Dim reader As XmlTextReader = _
      New XmlTextReader(filename)
      reader.ReadStartElement("wrapper")

      ' Deserialize and cast the object.
      Dim myGroup As Group  = _
      CType(mySerializer.Deserialize(reader), Group)
      reader.ReadEndElement()
      reader.Close()
   End Sub

   Public Sub DeserializeOverride(filename As String)
      ' Create an instance of the XmlSerializer class.
      Dim overRideSerializer As XmlSerializer  = _
      CreateOverrideSerializer()

      ' Reading the file requires an  XmlTextReader.
      Dim reader As XmlTextReader = _
      New XmlTextReader(filename)
      reader.ReadStartElement("wrapper")

      ' Deserialize and cast the object.
      Dim myGroup As Group = _
      CType(overRideSerializer.Deserialize(reader), Group)
      reader.ReadEndElement()
      reader.Close()
      ReadGroup(myGroup)
   End Sub

   private Sub ReadGroup(myGroup As Group)
      Console.WriteLine(myGroup.GroupName)
      Console.WriteLine(myGroup.GroupNumber(0))
      Console.WriteLine(myGroup.GroupNumber(1))
      Console.WriteLine(myGroup.Today)
      Console.WriteLine(myGroup.PostitiveInt)
      Console.WriteLine(myGroup.IgnoreThis)
      Console.WriteLine()
   End Sub
   
   Private Function CreateOverrideSerializer() As XmlSerializer
      Dim soapOver As SoapAttributeOverrides = New SoapAttributeOverrides()
      Dim soapAtts As SoapAttributes = New SoapAttributes()

      Dim mySoapElement As SoapElementAttribute = New SoapElementAttribute()
      mySoapElement.ElementName = "xxxx"
      soapAtts.SoapElement = mySoapElement
      soapOver.Add(GetType(Group), "PostitiveInt", soapAtts)

      ' Override the IgnoreThis property.
      Dim myIgnore As SoapIgnoreAttribute  = new SoapIgnoreAttribute()
      soapAtts = New SoapAttributes()
      soapAtts.SoapIgnore = false
      soapOver.Add(GetType(Group), "IgnoreThis", soapAtts)

      ' Override the GroupType enumeration.
      soapAtts = New SoapAttributes()
      Dim xSoapEnum As SoapEnumAttribute = new SoapEnumAttribute()
      xSoapEnum.Name = "Over1000"
      soapAtts.SoapEnum = xSoapEnum
      ' Add the SoapAttributes to the SoapOverrides object.
      soapOver.Add(GetType(GroupType), "A", soapAtts)

      ' Create second enumeration and add it.
      soapAtts = New SoapAttributes()
      xSoapEnum = New SoapEnumAttribute()
      xSoapEnum.Name = "ZeroTo1000"
      soapAtts.SoapEnum = xSoapEnum
      soapOver.Add(GetType(GroupType), "B", soapAtts)

      ' Override the Group type.
      soapAtts = New SoapAttributes()
      Dim soapType As SoapTypeAttribute = New SoapTypeAttribute()
      soapType.TypeName = "Team"
      soapAtts.SoapType = soapType
      soapOver.Add(GetType(Group),soapAtts)
    
      Dim myMapping As XmlTypeMapping = (New SoapReflectionImporter( _
      soapOver)).ImportTypeMapping(GetType(Group))
    
       Dim ser As XmlSerializer = new XmlSerializer(myMapping)
      return ser
   End Function
End Class

[C#] 
using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;

public class Group
{
   [SoapAttribute (Namespace = "http://www.cpandl.com")]
   public string GroupName;
   
   [SoapAttribute(DataType = "base64Binary")]
   public Byte [] GroupNumber;

   [SoapAttribute(DataType = "date", AttributeName = "CreationDate")]
   public DateTime Today;
   [SoapElement(DataType = "nonNegativeInteger", ElementName = "PosInt")]
   public string PostitiveInt;
   // This is ignored when serialized unless it's overridden.
   [SoapIgnore] 
   public bool IgnoreThis;
   
   public GroupType Grouptype;

   public Vehicle MyVehicle;

   // The SoapInclude allows the method to return a Car.
   [SoapInclude(typeof(Car))]
   public Vehicle myCar(string licNumber)
   {
      Vehicle v;
      if(licNumber == "")
         {
            v = new Car();
           v.licenseNumber = "!!!!!!";
        }
      else
        {
          v = new Car();
          v.licenseNumber = licNumber;
        }
      return v;
   }
}
  
// SoapInclude allows Vehicle to accept Car type.
[SoapInclude(typeof(Car))]
public abstract class Vehicle
{
   public string licenseNumber;
   public DateTime makeDate;
}

public class Car: Vehicle
{
}

public enum GroupType
{
   // These enums can be overridden.
   [SoapEnum("Small")]
   A,
   [SoapEnum("Large")]
   B
}
 
public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeOriginal("SoapOriginal.xml");
      test.SerializeOverride("SoapOverrides.xml");
      test.DeserializeOriginal("SoapOriginal.xml");
      test.DeserializeOverride("SoapOverrides.xml");
   
   }
   public void SerializeOriginal(string filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping myMapping = 
      (new SoapReflectionImporter().ImportTypeMapping(
      typeof(Group)));
      XmlSerializer mySerializer =  
      new XmlSerializer(myMapping);
      Group myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter writer = 
      new XmlTextWriter(filename, Encoding.UTF8);
      writer.Formatting = Formatting.Indented;
      writer.WriteStartElement("wrapper");
      // Serialize the class, and close the TextWriter.
      mySerializer.Serialize(writer, myGroup);
      writer.WriteEndElement();
      writer.Close();
   }

   public void SerializeOverride(string filename)
   {
      // Create an instance of the XmlSerializer class
      // that overrides the serialization.
      XmlSerializer overRideSerializer = CreateOverrideSerializer();
      Group myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter writer = 
      new XmlTextWriter(filename, Encoding.UTF8);
      writer.Formatting = Formatting.Indented;
      writer.WriteStartElement("wrapper");
      // Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup);
      writer.WriteEndElement();
      writer.Close();

   }

   private Group MakeGroup(){
      // Create an instance of the class that will be serialized.
      Group myGroup = new Group();

      // Set the object properties.
      myGroup.GroupName = ".NET";

      Byte [] hexByte = new Byte[2]{Convert.ToByte(100),
      Convert.ToByte(50)};
      myGroup.GroupNumber = hexByte;

      DateTime myDate = new DateTime(2002,5,2);
      myGroup.Today = myDate;
      myGroup.PostitiveInt= "10000";
      myGroup.IgnoreThis=true;
      myGroup.Grouptype= GroupType.B;
      Car thisCar =(Car)  myGroup.myCar("1234566");
      myGroup.MyVehicle=thisCar;
      return myGroup;
   }       

   public void DeserializeOriginal(string filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping myMapping = 
      (new SoapReflectionImporter().ImportTypeMapping(
      typeof(Group)));
      XmlSerializer mySerializer =  
      new XmlSerializer(myMapping);


      // Reading the file requires an  XmlTextReader.
      XmlTextReader reader= 
      new XmlTextReader(filename);
      reader.ReadStartElement("wrapper");

      // Deserialize and cast the object.
      Group myGroup; 
      myGroup = (Group) mySerializer.Deserialize(reader);
      reader.ReadEndElement();
      reader.Close();

   }

   public void DeserializeOverride(string filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlSerializer overRideSerializer = CreateOverrideSerializer();

      // Reading the file requires an  XmlTextReader.
      XmlTextReader reader= 
      new XmlTextReader(filename);
      reader.ReadStartElement("wrapper");

      // Deserialize and cast the object.
      Group myGroup; 
      myGroup = (Group) overRideSerializer.Deserialize(reader);
      reader.ReadEndElement();
      reader.Close();
      ReadGroup(myGroup);
   }

   private void ReadGroup(Group myGroup){
      Console.WriteLine(myGroup.GroupName);
      Console.WriteLine(myGroup.GroupNumber[0]);
      Console.WriteLine(myGroup.GroupNumber[1]);
      Console.WriteLine(myGroup.Today);
      Console.WriteLine(myGroup.PostitiveInt);
      Console.WriteLine(myGroup.IgnoreThis);
      Console.WriteLine();
   }
   private XmlSerializer CreateOverrideSerializer()
   {
      SoapAttributeOverrides mySoapAttributeOverrides = 
      new SoapAttributeOverrides();
      SoapAttributes soapAtts = new SoapAttributes();

      SoapElementAttribute mySoapElement = new SoapElementAttribute();
      mySoapElement.ElementName = "xxxx";
      soapAtts.SoapElement = mySoapElement;
      mySoapAttributeOverrides.Add(typeof(Group), "PostitiveInt", 
      soapAtts);

      // Override the IgnoreThis property.
      SoapIgnoreAttribute myIgnore = new SoapIgnoreAttribute();
      soapAtts = new SoapAttributes();
      soapAtts.SoapIgnore = false;      
      mySoapAttributeOverrides.Add(typeof(Group), "IgnoreThis", 
      soapAtts);

      // Override the GroupType enumeration.    
      soapAtts = new SoapAttributes();
      SoapEnumAttribute xSoapEnum = new SoapEnumAttribute();
      xSoapEnum.Name = "Over1000";
      soapAtts.SoapEnum = xSoapEnum;

      // Add the SoapAttributes to the 
      // mySoapAttributeOverridesrides object.
      mySoapAttributeOverrides.Add(typeof(GroupType), "A", 
      soapAtts);

      // Create second enumeration and add it.
      soapAtts = new SoapAttributes();
      xSoapEnum = new SoapEnumAttribute();
      xSoapEnum.Name = "ZeroTo1000";
      soapAtts.SoapEnum = xSoapEnum;
      mySoapAttributeOverrides.Add(typeof(GroupType), "B", 
      soapAtts);

      // Override the Group type.
      soapAtts = new SoapAttributes();
      SoapTypeAttribute soapType = new SoapTypeAttribute();
      soapType.TypeName = "Team";
      soapAtts.SoapType = soapType;
      mySoapAttributeOverrides.Add(typeof(Group),soapAtts);

      // Create an XmlTypeMapping that is used to create an instance 
      // of the XmlSerializer. Then return the XmlSerializer object.
      XmlTypeMapping myMapping = (new SoapReflectionImporter(
      mySoapAttributeOverrides)).ImportTypeMapping(typeof(Group));
    
      XmlSerializer ser = new XmlSerializer(myMapping);
      return ser;
   }
}

[C++] 
#using <mscorlib.dll>
#using <System.Xml.dll>
using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Xml;
using namespace System::Xml::Serialization;
using namespace System::Xml::Schema;

public __gc class Car;

// SoapInclude allows Vehicle to accept Car type.
[SoapInclude(__typeof(Car))]
public __abstract __gc class Vehicle
{
public:
   String* licenseNumber;
   DateTime makeDate;
};

public __gc class Car: public Vehicle
{
};

public __value enum GroupType
{
   // These enums can be overridden.
   [SoapEnum(S"Small")]
   A,
   [SoapEnum(S"Large")]
   B
};
 
public __gc class Group
{
public:
   [SoapAttributeAttribute(Namespace = S"http://www.cpandl.com")]
   String* GroupName;
   
   [SoapAttributeAttribute(DataType = S"base64Binary")]
   Byte GroupNumber[];

   [SoapAttributeAttribute(DataType = S"date", AttributeName = S"CreationDate")]
   DateTime Today;
   [SoapElement(DataType = S"nonNegativeInteger", ElementName = S"PosInt")]
   String* PostitiveInt;
   // This is ignored when serialized unless it's overridden.
   [SoapIgnore] 
   bool IgnoreThis;
   
   GroupType Grouptype;

   Vehicle* MyVehicle;

   // The SoapInclude allows the method to return a Car.
   [SoapInclude(__typeof(Car))]
   Vehicle* myCar(String* licNumber)
   {
      Vehicle* v;
      if(licNumber->Equals(S""))
         {
            v = new Car();
           v->licenseNumber = S"!!!!!!";
        }
      else
        {
          v = new Car();
          v->licenseNumber = licNumber;
        }
      return v;
   }
};
  
public __gc class Run
{
public:
   static void main()
   {
      Run* test = new Run();
      test->SerializeOriginal(S"SoapOriginal.xml");
      test->SerializeOverride(S"SoapOverrides.xml");
      test->DeserializeOriginal(S"SoapOriginal.xml");
      test->DeserializeOverride(S"SoapOverrides.xml");
   
   }

   void SerializeOriginal(String* filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping* myMapping =
         (new SoapReflectionImporter())->ImportTypeMapping(__typeof(Group));
      XmlSerializer* mySerializer =  
         new XmlSerializer(myMapping);
      Group* myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter* writer = 
         new XmlTextWriter(filename, Encoding::UTF8);
      writer->Formatting = Formatting::Indented;
      writer->WriteStartElement(S"wrapper");
      // Serialize the class, and close the TextWriter.
      mySerializer->Serialize(writer, myGroup);
      writer->WriteEndElement();
      writer->Close();
   }

   void SerializeOverride(String* filename)
   {
      // Create an instance of the XmlSerializer class
      // that overrides the serialization.
      XmlSerializer* overRideSerializer = CreateOverrideSerializer();
      Group* myGroup=MakeGroup();
      // Writing the file requires a TextWriter.
      XmlTextWriter* writer = 
         new XmlTextWriter(filename, Encoding::UTF8);
      writer->Formatting = Formatting::Indented;
      writer->WriteStartElement(S"wrapper");
      // Serialize the class, and close the TextWriter.
      overRideSerializer->Serialize(writer, myGroup);
      writer->WriteEndElement();
      writer->Close();

   }

private:
   Group* MakeGroup(){
      // Create an instance of the class that will be serialized.
      Group* myGroup = new Group();

      // Set the object properties.
      myGroup->GroupName = S".NET";

      Byte hexByte[] = {Convert::ToByte(100),
      Convert::ToByte(50)};
      myGroup->GroupNumber = hexByte;

      DateTime myDate = DateTime(2002,5,2);
      myGroup->Today = myDate;
      myGroup->PostitiveInt= S"10000";
      myGroup->IgnoreThis=true;
      myGroup->Grouptype= GroupType::B;
      Car* thisCar =dynamic_cast<Car*>(myGroup->myCar(S"1234566"));
      myGroup->MyVehicle=thisCar;
      return myGroup;
   }       

public:
   void DeserializeOriginal(String* filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping* myMapping = 
         (new SoapReflectionImporter())->ImportTypeMapping(__typeof(Group));
      XmlSerializer* mySerializer =  
         new XmlSerializer(myMapping);


      // Reading the file requires an  XmlTextReader.
      XmlTextReader* reader= 
         new XmlTextReader(filename);
      reader->ReadStartElement(S"wrapper");

      // Deserialize and cast the object.
      Group* myGroup; 
      myGroup = dynamic_cast<Group*>(mySerializer->Deserialize(reader));
      reader->ReadEndElement();
      reader->Close();

   }

   void DeserializeOverride(String* filename)
   {
      // Create an instance of the XmlSerializer class.
      XmlSerializer* overRideSerializer = CreateOverrideSerializer();

      // Reading the file requires an XmlTextReader.
      XmlTextReader* reader= 
         new XmlTextReader(filename);
      reader->ReadStartElement(S"wrapper");

      // Deserialize and cast the object.
      Group* myGroup; 
      myGroup = dynamic_cast<Group*>(overRideSerializer->Deserialize(reader));
      reader->ReadEndElement();
      reader->Close();
      ReadGroup(myGroup);
   }

private:
   void ReadGroup(Group* myGroup){
      Console::WriteLine(myGroup->GroupName);
      Console::WriteLine(myGroup->GroupNumber[0]);
      Console::WriteLine(myGroup->GroupNumber[1]);
      Console::WriteLine( __box(myGroup->Today));
      Console::WriteLine(myGroup->PostitiveInt);
      Console::WriteLine(myGroup->IgnoreThis);
      Console::WriteLine();
   }

   XmlSerializer* CreateOverrideSerializer()
   {
      SoapAttributeOverrides* mySoapAttributeOverrides = 
         new SoapAttributeOverrides();
      SoapAttributes* soapAtts = new SoapAttributes();

      SoapElementAttribute* mySoapElement = new SoapElementAttribute();
      mySoapElement->ElementName = S"xxxx";
      soapAtts->SoapElement = mySoapElement;
      mySoapAttributeOverrides->Add(__typeof(Group), S"PostitiveInt", 
      soapAtts);

      // Override the IgnoreThis property.
      SoapIgnoreAttribute* myIgnore = new SoapIgnoreAttribute();
      soapAtts = new SoapAttributes();
      soapAtts->SoapIgnore = false;      
      mySoapAttributeOverrides->Add(__typeof(Group), S"IgnoreThis", 
      soapAtts);

      // Override the GroupType enumeration.    
      soapAtts = new SoapAttributes();
      SoapEnumAttribute* xSoapEnum = new SoapEnumAttribute();
      xSoapEnum->Name = S"Over1000";
      soapAtts->SoapEnum = xSoapEnum;

      // Add the SoapAttributes to the 
      // mySoapAttributeOverridesrides object.
      mySoapAttributeOverrides->Add(__typeof(GroupType), S"A", 
      soapAtts);

      // Create second enumeration and add it.
      soapAtts = new SoapAttributes();
      xSoapEnum = new SoapEnumAttribute();
      xSoapEnum->Name = S"ZeroTo1000";
      soapAtts->SoapEnum = xSoapEnum;
      mySoapAttributeOverrides->Add(__typeof(GroupType), S"B", 
      soapAtts);

      // Override the Group type.
      soapAtts = new SoapAttributes();
      SoapTypeAttribute* soapType = new SoapTypeAttribute();
      soapType->TypeName = S"Team";
      soapAtts->SoapType = soapType;
      mySoapAttributeOverrides->Add(__typeof(Group),soapAtts);

      // Create an XmlTypeMapping that is used to create an instance 
      // of the XmlSerializer. Then return the XmlSerializer object.
      XmlTypeMapping* myMapping = (new SoapReflectionImporter(
      mySoapAttributeOverrides))->ImportTypeMapping(__typeof(Group));
    
      XmlSerializer* ser = new XmlSerializer(myMapping);
      return ser;
   }
};

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

[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタボタンをクリックします。

必要条件

名前空間: System.Xml.Serialization

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

アセンブリ: System.Xml (System.Xml.dll 内)

参照

SoapAttributes メンバ | System.Xml.Serialization 名前空間 | XmlAttributes | エンコード済み SOAP シリアル化を制御する属性 | XML シリアル化を使用した SOAP メッセージの生成

次の方法で共有

SoapAttributes クラス

スレッドセーフ

解説

使用例

必要条件

参照

その他のリソース