SoapAttributeOverrides.Add メソッド

SoapAttributeOverrides に格納されている SoapAttributes オブジェクトのコレクションに SoapAttributes を追加します。

オーバーロードの一覧

SoapAttributes を SoapAttributes オブジェクトのコレクションに追加します。type パラメータには、この SoapAttributes によってオーバーライドされるオブジェクトを指定します。

[Visual Basic] Overloads Public Sub Add(Type, SoapAttributes)

[C#] public void Add(Type, SoapAttributes);

[C++] public: void Add(Type*, SoapAttributes*);

[JScript] public function Add(Type, SoapAttributes);

SoapAttributeOverrides に格納されている SoapAttributes オブジェクトのコレクションに SoapAttributes を追加します。type パラメータには、この SoapAttributes によってオーバーライドされるオブジェクトを指定します。member パラメータには、オーバーライドされるメンバの名前を指定します。

[Visual Basic] Overloads Public Sub Add(Type, String, SoapAttributes)

[C#] public void Add(Type, string, SoapAttributes);

[C++] public: void Add(Type*, String*, SoapAttributes*);

[JScript] public function Add(Type, String, SoapAttributes);

使用例

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

[Visual Basic, C#, C++] メモ   ここでは、Add のオーバーロード形式のうちの 1 つだけについて、使用例を示します。その他の例については、各オーバーロード形式のトピックを参照してください。

 
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++ のサンプルを表示するには、このページの左上隅にある言語のフィルタ ボタン をクリックします。

参照

SoapAttributeOverrides クラス | SoapAttributeOverrides メンバ | System.Xml.Serialization 名前空間