Export (0) Print
Expand All

SoapAttributes Class

Represents a collection of attribute objects that control how the XmlSerializer serializes and deserializes SOAP methods.

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

public class SoapAttributes

Creating a SoapAttributes is part of a process that overrides the default way the XmlSerializer serializes class instances. For example, suppose you want to serialize an object that is created from a DLL that has an inaccessible source. By using the SoapAttributeOverrides class, you can augment or otherwise control how the object is serialized.

The members of the SoapAttributes class correspond directly to a family of attribute classes that control serialization. For example, the SoapAttribute property must be set to a SoapAttributeAttribute, which allows you to override serialization of a field or property by instructing the XmlSerializer to serialize the property value as an encoded SOAP attribute. For a complete list of attributes that control encoded SOAP serialization, see [<topic://cpconAttributesThatControlSOAPEncodedSerialization>].

For more details about adding an instance of the SoapAttributes class to an instance of the SoapAttributeOverrides class, see the SoapAttributeOverrides class overview.

The following example serializes a class named Group. The serialization of the GroupName and IgnoreThis fields and the members of the GroupType enumeration are overridden. In the CreateOverrideSerializer method, a SoapAttributeOverrides is created, and for each overridden member or enumeration, a SoapAttributes is created with the appropriate property set and added to the SoapAttributeOverrides. An XmlTypeMapping is created using the SoapAttributeOverrides, and that XmlTypeMapping is used to create the XmlSerializer that overrides the default serialization.

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;
   }
}
#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();
}

System.Object
  System.Xml.Serialization.SoapAttributes

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360, Zune

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0

XNA Framework

Supported in: 3.0, 2.0, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft