Compartir a través de

Generar mensajes SOAP con serialización XML

Como un mensaje SOAP se crea mediante XML, XmlSerializer puede utilizarse para serializar clases y generar mensajes SOAP codificados. El XML generado se ajusta a la sección 5 del documento del W3C (World Wide Web Consortium), en www.w3.org, titulado "Simple Object Access Protocol (SOAP) 1.1". Cuando crea un servicio Web XML que se comunica mediante mensajes SOAP, puede personalizar la secuencia XML si aplica un conjunto de atributos SOAP especiales a las clases y miembros de clases. Para obtener una lista de los atributos, vea Atributos que controlan la serialización SOAP codificada.

Para serializar un objeto como secuencia XML con codificación SOAP

  1. Cree la clase utilizando la herramienta Definición de esquemas XML (Xsd.exe).

  2. Aplique uno o varios de los atributos especiales que se encuentran en System.Xml.Serialization. Vea la lista en "Atributos que controlan la serialización SOAP codificada".

  3. Cree XmlTypeMapping mediante la creación de un nuevo SoapReflectionImporter y la invocación del método ImportTypeMapping con el tipo de clase serializada.

    En el ejemplo siguiente se llama al método ImportTypeMapping de la clase SoapReflectionImporter para crear un XmlTypeMapping.

    ' Serializes a class named Group as a SOAP message.
Dim myTypeMapping As XmlTypeMapping = (New SoapReflectionImporter(). _
ImportTypeMapping(GetType(Group))
[C#]
// Serializes a class named Group as a SOAP message.
XmlTypeMapping myTypeMapping = (new SoapReflectionImporter().
ImportTypeMapping(typeof(Group));

  4. Cree una instancia de la clase XmlSerializer; para ello, pase XmlTypeMapping al constructor XmlSerializer.

    Dim mySerializer As XmlSerializer = New XmlSerializer(myTypeMapping)
[C#]
XmlSerializer mySerializer = new XmlSerializer(myTypeMapping);

  5. Llame al método Serialize o Deserialize.

Reemplazar la serialización XML con codificación SOAP

El proceso para reemplazar la serialización XML de objetos como mensajes SOAP es similar al proceso para reemplazar la serialización XML estándar. Para obtener información detallada sobre cómo reemplazar la serialización XML estándar, vea Reemplazar la serialización XML.

Para reemplazar la serialización de objetos como mensajes SOAP

  1. Cree una instancia de la clase SoapAttributeOverrides.
  2. Cree un SoapAttributes para cada miembro de clase que se serialice.
  3. Cree una instancia de uno o varios atributos que afectan a la serialización XML (para obtener una lista, vea "Atributos que controlan la serialización SOAP codificada"), según corresponda, para el miembro que se esté serializando.
  4. Establezca el valor de la propiedad correspondiente de SoapAttributes como el atributo creado en el paso 3.
  5. Agregue SoapAttributes a SoapAttributeOverrides.
  6. Cree un XmlTypeMapping con SoapAttributeOverrides. Utilice el método SoapReflectionImporter.ImportTypeMapping.
  7. Cree XmlSerializer con XmlTypeMapping.
  8. Serialice o deserialice el objeto.

En el ejemplo siguiente se serializa un archivo de dos modos: en el primero no se reemplaza el comportamiento de la clase XmlSerializer mientras que en el segundo se reemplaza. En el ejemplo siguiente se muestra una clase denominada Group con varios miembros. Se han aplicado varios atributos, como SoapElementAttribute, a los miembros de la clase. Cuando la clase se serializa con el método SerializeOriginal, los atributos controlan el contenido del mensaje SOAP. Cuando se llama al método SerializeOverride, el comportamiento de XmlSerializer se reemplaza al crear varios atributos y establecer las propiedades de SoapAttributes para esos atributos (según corresponda).

using System;
using System.IO;
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 is overridden.
    [SoapIgnore] 
    public bool IgnoreThis;

    public GroupType Grouptype;
    
    [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;
    }
}

public abstract class Vehicle
{
    public string licenseNumber;
    public DateTime makeDate;
}

public class Car: Vehicle
{
}

public enum GroupType
{
    // These enums can be overridden.
    small,
    large
}
    
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)
    {
        // Creates an instance of the XmlSerializer class.
        XmlTypeMapping myMapping = 
        (new SoapReflectionImporter().ImportTypeMapping(
        typeof(Group)));
        XmlSerializer mySerializer =  
        new XmlSerializer(myMapping);

        // Writing the file requires a TextWriter.
        TextWriter writer = new StreamWriter(filename);

        // Creates an instance of the class that will be serialized.
        Group myGroup = new Group();

        // Sets 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.small;
        Car thisCar =(Car)  myGroup.myCar("1234566");

        // Prints the license number just to prove the car was created.
        Console.WriteLine("License#: " + thisCar.licenseNumber + "\n");

        // Serializes the class, and closes the TextWriter.
        mySerializer.Serialize(writer, myGroup);
        writer.Close();
    }

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

        // Writing the file requires a TextWriter.
        TextWriter writer = new StreamWriter(filename);

        // Creates an instance of the class that will be serialized.
        Group myGroup = new Group();

        // Sets 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.small;
        Car thisCar =(Car)  myGroup.myCar("1234566");

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

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

        TextReader reader = new StreamReader(filename);

        // Deserializes and casts the object.
        Group myGroup; 
        myGroup = (Group) mySerializer.Deserialize(reader);

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

    public void DeserializeOverride(string filename)
    {
        // Creates an instance of the XmlSerializer class.
        XmlSerializer overRideSerializer = CreateOverrideSerializer();
        // Reading the file requires a TextReader.
        TextReader reader = new StreamReader(filename);

        // Deserializes and casts the object.
        Group myGroup; 
        myGroup = (Group) overRideSerializer.Deserialize(reader);

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

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

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

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

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

        // Creates a second enumeration and adds it.
        soapAtts = new SoapAttributes();
        xSoapEnum = new SoapEnumAttribute();
        xSoapEnum.Name = "ZeroTo1000";
        soapAtts.SoapEnum = xSoapEnum;
        mySoapAttributeOverrides.Add(typeof(GroupType), "small", 
        soapAtts);

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

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

Vea también

Serialización XML | Atributos que controlan la serialización SOAP codificada | Serialización XML con servicios Web XML

  • Last updated on