SoapAttributeAttribute Constructors

Definition

Namespace:

System.Xml.Serialization

Assembly:

System.Xml.XmlSerializer.dll

Initializes a new instance of the SoapAttributeAttribute class.

Overloads

SoapAttributeAttribute()	Initializes a new instance of the SoapAttributeAttribute class.
SoapAttributeAttribute(String)	Initializes a new instance of the SoapAttributeAttribute class using the specified value as the name of the XML attribute.

SoapAttributeAttribute()

Source:

SoapAttributeAttribute.cs

Initializes a new instance of the SoapAttributeAttribute class.

public:
 SoapAttributeAttribute();

public SoapAttributeAttribute ();

Public Sub New ()

Examples

The following example creates a new SoapAttributeAttribute that is used to override the serialization of a field. After creating a SoapAttributeAttribute and setting its properties, the object is set to the SoapAttribute property of a SoapAttributes. The SoapAttributes is then 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 ref class Group
{
public:

   // This attribute will be overridden.

   [SoapAttributeAttribute(Namespace="http://www.cpandl.com")]
   String^ GroupName;
};

public ref class Run
{
public:
   void SerializeOverride( String^ filename )
   {
      // Create an instance of the XmlSerializer class
      // that overrides the serialization.
      XmlSerializer^ overRideSerializer = CreateOverrideSerializer();

      // 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";

      // Serialize the class, and close the TextWriter.
      overRideSerializer->Serialize( writer, myGroup );
      writer->Close();
   }

private:
   XmlSerializer^ CreateOverrideSerializer()
   {
      SoapAttributeOverrides^ mySoapAttributeOverrides = gcnew SoapAttributeOverrides;
      SoapAttributes^ mySoapAttributes = gcnew SoapAttributes;

      // Create a new SoapAttributeAttribute to  the 
      // one applied to the Group class. The resulting XML 
      // stream will use the new namespace and attribute name.
      SoapAttributeAttribute^ mySoapAttribute = gcnew SoapAttributeAttribute;
      mySoapAttribute->AttributeName = "TeamName";

      // Change the Namespace.
      mySoapAttribute->Namespace = "http://www.cohowinery.com";
      mySoapAttributes->SoapAttribute = mySoapAttribute;
      mySoapAttributeOverrides->Add( Group::typeid, "GroupName", mySoapAttributes );
      XmlTypeMapping^ myMapping = (gcnew SoapReflectionImporter( mySoapAttributeOverrides ))->ImportTypeMapping( Group::typeid );
      XmlSerializer^ ser = gcnew XmlSerializer( myMapping );
      return ser;
   }
};

int main()
{
   Run^ test = gcnew Run;
   test->SerializeOverride( "SoapOveride.xml" );
}

//<?xml version=S"1.0" encoding=S"utf-8" ?> 
// <Group xmlns:xsi=S"http://www.w3.org/2001/XMLSchema-instance" 
//xmlns:xsd=S"http://www.w3.org/2001/XMLSchema" n1:TeamName=S".NET" 
//xmlns:n1=S"http://www.cohowinery" />

using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

public class Group
{
   // This attribute will be overridden.
   [SoapAttribute (Namespace = "http://www.cpandl.com")]
   public string GroupName;
}

public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeOverride("SoapOveride.xml");
   }

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

      // 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";

      // Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup);
       writer.Close();
   }

   private XmlSerializer CreateOverrideSerializer(){
    
      SoapAttributeOverrides mySoapAttributeOverrides =
        new SoapAttributeOverrides();
      SoapAttributes mySoapAttributes = new SoapAttributes();
      // Create a new SoapAttributeAttribute to override the
      // one applied to the Group class. The resulting XML
      // stream will use the new namespace and attribute name.
      SoapAttributeAttribute mySoapAttribute =
      new SoapAttributeAttribute();
      mySoapAttribute.AttributeName = "TeamName";
      // Change the Namespace.
      mySoapAttribute.Namespace = "http://www.cohowinery.com";

      mySoapAttributes.SoapAttribute = mySoapAttribute;
      mySoapAttributeOverrides.
      Add(typeof(Group), "GroupName" ,mySoapAttributes);
    
      XmlTypeMapping myMapping = (new SoapReflectionImporter
        (mySoapAttributeOverrides)).ImportTypeMapping(typeof(Group));
    
      XmlSerializer ser = new XmlSerializer(myMapping);
      return ser;
   }
}
//<?xml version="1.0" encoding="utf-8" ?>
// <Group xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
//xmlns:xsd="http://www.w3.org/2001/XMLSchema" n1:TeamName=".NET"
//xmlns:n1="http://www.cohowinery" />

Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization


Public Class Group
   ' This attribute will be overridden.
   <SoapAttribute (Namespace: = "http://www.cpandl.com")> _
   Public GroupName As String 
   
End Class

public class Run
   Public Shared Sub Main()
   
      Dim test  As Run = new Run()
      test.SerializeOverride("SoapOveride.xml")
   End Sub
   
   Public Sub SerializeOverride(filename As String )
      ' Create an instance of the XmlSerializer class
      ' that overrides the serialization.
      Dim overRideSerializer  As XmlSerializer = _
      CreateOverrideSerializer()

      ' 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"

      ' Serialize the class, and close the TextWriter.
      overRideSerializer.Serialize(writer, myGroup)
       writer.Close()
   End Sub


   Private Function CreateOverrideSerializer() As XmlSerializer 
    
      Dim mySoapAttributeOverrides As SoapAttributeOverrides = _
      New SoapAttributeOverrides()
      Dim mySoapAttributes As SoapAttributes = New SoapAttributes()
      ' Create a new SoapAttributeAttribute to override the 
      ' one applied to the Group class. The resulting XML 
      ' stream will use the new namespace and attribute name.
      Dim mySoapAttribute As SoapAttributeAttribute = _
      New SoapAttributeAttribute()
      mySoapAttribute.AttributeName = "TeamName"
      ' Change the Namespace.
      mySoapAttribute.Namespace = "http://www.cohowinery"

      mySoapAttributes.SoapAttribute = mySoapAttribute
      mySoapAttributeOverrides. _
      Add(GetType(Group), "GroupName" ,mySoapAttributes)
    
      Dim myMapping  As XmlTypeMapping = (new SoapReflectionImporter _
      (mySoapAttributeOverrides)).ImportTypeMapping(GetType(Group))
    
      Dim ser As XmlSerializer = new XmlSerializer(myMapping)
      CreateOverrideSerializer = ser
   End Function

End Class
'<?xml version="1.0" encoding="utf-8" ?> 
'<Group xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
'xmlns:xsd="http://www.w3.org/2001/XMLSchema" n1:TeamName=".NET" 
'xmlns:n1="http://www.cohowinery" />

Remarks

Use this constructor to create a SoapAttributeAttribute when you override the serialization of a class member. Create the SoapAttributeAttribute, set its properties, and set the object to the SoapAttribute property of a SoapAttributes object. For more details, see the SoapAttributeOverrides class overview.

SoapAttributeAttribute(String)

Source:

SoapAttributeAttribute.cs

Initializes a new instance of the SoapAttributeAttribute class using the specified value as the name of the XML attribute.

public:
 SoapAttributeAttribute(System::String ^ attributeName);

public SoapAttributeAttribute (string attributeName);

new System.Xml.Serialization.SoapAttributeAttribute : string -> System.Xml.Serialization.SoapAttributeAttribute

Public Sub New (attributeName As String)

Parameters

attributeName

String

The name of the XML attribute.

Examples

The following example serializes a class that contains several fields to which a SoapAttributeAttribute is applied.

#using <System.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;

//using namespace System::Runtime::Remoting::Metadata;
public ref class Vehicle
{
public:
   String^ licenseNumber;
};


[SoapInclude(Vehicle::typeid)]
public ref class Group
{
public:

   [SoapAttributeAttribute(Namespace="http://www.cpandl.com")]
   String^ GroupName;

   [SoapAttributeAttribute(DataType="base64Binary")]
   array<Byte>^GroupNumber;

   [SoapAttributeAttribute(DataType="date",AttributeName="CreationDate")]
   DateTime Today;

   [SoapElement(DataType="nonNegativeInteger",ElementName="PosInt")]
   String^ PostitiveInt;
   Vehicle^ GroupVehicle;
};

public ref class Run
{
public:
   void SerializeObject( String^ filename )
   {
      // Create an instance of the XmlSerializer class that
      // can generate encoded SOAP messages.
      XmlSerializer^ mySerializer = ReturnSOAPSerializer();
      Group^ myGroup = MakeGroup();

      // Writing the file requires a TextWriter.
      XmlTextWriter^ writer = gcnew 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();
   }


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

      // Set the Object* properties.
      myGroup->GroupName = ".NET";
      array<Byte>^hexByte = {Convert::ToByte( 100 ),Convert::ToByte( 50 )};
      myGroup->GroupNumber = hexByte;
      DateTime myDate = DateTime(2002,5,2);
      myGroup->Today = myDate;
      myGroup->PostitiveInt = "10000";
      myGroup->GroupVehicle = gcnew Vehicle;
      myGroup->GroupVehicle->licenseNumber = "1234";
      return myGroup;
   }

public:
   void DeserializeObject( String^ filename )
   {
      // Create an instance of the XmlSerializer class that
      // can generate encoded SOAP messages.
      XmlSerializer^ mySerializer = ReturnSOAPSerializer();

      // Reading the file requires an  XmlTextReader.
      XmlTextReader^ reader = gcnew XmlTextReader( filename );
      reader->ReadStartElement( "wrapper" );

      // Deserialize and cast the Object*.
      Group^ myGroup;
      myGroup = safe_cast<Group^>(mySerializer->Deserialize( reader ));
      reader->ReadEndElement();
      reader->Close();
   }

private:
   XmlSerializer^ ReturnSOAPSerializer()
   {
      
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping^ myMapping = (gcnew SoapReflectionImporter)->ImportTypeMapping( Group::typeid );
      return gcnew XmlSerializer( myMapping );
   }
};

int main()
{
   Run^ test = gcnew Run;
   test->SerializeObject( "SoapAtts.xml" );
   test->DeserializeObject( "SoapAtts.xml" );
}

using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;

[SoapInclude(typeof(Vehicle))]
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;

   public Vehicle GroupVehicle;
}

public class Vehicle
{
   public string licenseNumber;
}

public class Run
{
   public static void Main()
   {
      Run test = new Run();
      test.SerializeObject("SoapAtts.xml");
      test.DeserializeObject("SoapAtts.xml");
   }
   public void SerializeObject(string filename)
   {
      // Create an instance of the XmlSerializer class that
      // can generate encoded SOAP messages.
      XmlSerializer mySerializer =  ReturnSOAPSerializer();

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

   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.GroupVehicle = new Vehicle();
      myGroup.GroupVehicle.licenseNumber="1234";
      return myGroup;
   }   	

   public void DeserializeObject(string filename)
   {
      // Create an instance of the XmlSerializer class that
      // can generate encoded SOAP messages.
      XmlSerializer mySerializer =  ReturnSOAPSerializer();

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

   private XmlSerializer ReturnSOAPSerializer(){
      // Create an instance of the XmlSerializer class.
      XmlTypeMapping myMapping =
      (new SoapReflectionImporter().ImportTypeMapping
      (typeof(Group)));
       return new XmlSerializer(myMapping);
   }
}

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

<SoapInclude(GetType(Vehicle))> _
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 

   Public GroupVehicle As Vehicle 
End Class
  
Public Class Vehicle
   Public licenseNumber As String 
End Class

Public Class Run

   Shared Sub Main()
   
      Dim test As Run = New Run()
      test.SerializeObject("SoapAtts.xml")
      test.DeserializeObject("SoapAtts.xml")
   End Sub
   
   Public Sub SerializeObject(filename As String)
   
      ' Create an instance of the XmlSerializer Class that
      ' can generate encoded SOAP messages.
      Dim mySerializer As XmlSerializer  =  ReturnSOAPSerializer()

      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

   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.GroupVehicle = New Vehicle()
      myGroup.GroupVehicle.licenseNumber="1234"
      return myGroup
   End Function   	

   Public Sub DeserializeObject(filename As String)
      ' Create an instance of the XmlSerializer Class that
      ' can generate encoded SOAP messages.
      Dim mySerializer As XmlSerializer =  ReturnSOAPSerializer()

      ' 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 
      myGroup = _
      CType(mySerializer.Deserialize(reader), Group)
      reader.ReadEndElement()
      reader.Close()

   End Sub
   
   private Function ReturnSOAPSerializer() As XmlSerializer 
      ' Create an instance of the XmlSerializer Class.
      Dim myMapping As XmlTypeMapping = _
      (New SoapReflectionImporter().ImportTypeMapping _
      (GetType(Group)))
       return New XmlSerializer(myMapping)
   End Function
End Class