Freigeben über

Generieren von SOAP-Meldungen mit der XML-Serialisierung

Da eine SOAP-Meldung mit Hilfe von XML erstellt wird, kann die XmlSerializer-Klasse zum Serialisieren von Klassen und zum Generieren von codierten SOAP-Meldungen verwendet werden. Das resultierende XML entspricht Abschnitt 5 des Dokuments "Simple Object Access Protocol (SOAP) 1.1" (nur auf Englisch verfügbar) des World Wide Web Consortium (www.w3.org). Wenn Sie einen XML-Webdienst erstellen, der über SOAP-Meldungen kommuniziert, können Sie den XML-Stream anpassen, indem Sie eine Reihe von speziellen SOAP-Attributen auf Klassen und Member von Klassen anwenden. Eine Liste mit Attributen finden Sie unter Attribute für die Steuerung der Serialisierung von codiertem SOAP.

So serialisieren Sie ein Objekt als einen durch SOAP codierten XML-Stream

  1. Erstellen Sie die Klasse mit Hilfe des XML Schema Definition-Tools (Xsd.exe).

  2. Verwenden Sie eines oder mehrere der speziellen Attribute aus System.Xml.Serialization. Eine Liste finden Sie unter "Attribute für die Steuerung der Serialisierung von codiertem SOAP".

  3. Erstellen Sie ein XmlTypeMapping-Objekt, indem Sie eine neue SoapReflectionImporter-Klasse erstellen und die ImportTypeMapping-Methode mit dem Typ der serialisierten Klasse aufrufen.

    In folgendem Beispiel wird die ImportTypeMapping-Methode der SoapReflectionImporter-Klasse aufgerufen, um ein XmlTypeMapping-Objekt zu erstellen.

    ' 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. Erstellen Sie eine Instanz der XmlSerializer-Klasse, indem Sie das XmlTypeMapping-Objekt an den XmlSerializer-Konstruktor übergeben.

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

  5. Rufen Sie die Serialize-Methode oder die Deserialize-Methode auf.

Überschreiben einer XML-Serialisierung von codiertem SOAP

Das Verfahren zum Überschreiben der XML-Serialisierung von Objekten als SOAP-Meldungen ist mit dem zum Überschreiben der Standard-XML-Serialisierung vergleichbar. (Einzelheiten zum Überschreiben der Standard-XML-Serialisierung finden Sie unter Überschreiben der XML-Serialisierung.)

So überschreiben Sie die Serialisierung von Objekten als SOAP-Meldungen

  1. Erstellen Sie eine Instanz der SoapAttributeOverrides-Klasse.
  2. Erstellen Sie für jeden Klassenmember, der serialisiert wird, ein SoapAttributes.
  3. Erstellen Sie eine Instanz eines oder mehrerer der Attribute, die sich auf die XML-Serialisierung auswirken (eine Auflistung finden Sie unter "Attribute für die Steuerung der Serialisierung von codiertem SOAP"), dementsprechend für den Member, der serialisiert wird.
  4. Legen Sie die entsprechende Eigenschaft von SoapAttributes auf das in Schritt 3 erstellte Attribut fest.
  5. Fügen Sie das SoapAttributes-Objekt zum SoapAttributeOverrides-Objekt hinzu.
  6. Erstellen Sie mit Hilfe des SoapAttributeOverrides-Objekts ein XmlTypeMapping-Objekt. Verwenden Sie die SoapReflectionImporter.ImportTypeMapping-Methode.
  7. Erstellen Sie mit Hilfe des XmlTypeMapping-Objekts ein XmlSerializer-Objekt.
  8. Serialisieren oder deserialisieren Sie das Objekt.

Im folgenden Beispiel wird eine Datei auf zwei Arten serialisiert: erstens ohne Überschreiben des Verhaltens der XmlSerializer-Klasse und zweitens mit Überschreiben des Verhaltens. Das Beispiel enthält eine Klasse mit der Bezeichnung Group mit mehreren Membern. Auf Klassenmember wurden verschiedene Attribute wie z. B. SoapElementAttribute angewendet. Wird die Klasse mit der SerializeOriginal-Methode serialisiert, wird der Inhalt der SOAP-Meldung durch die Attribute gesteuert. Beim Aufrufen der SerializeOverride-Methode wird das Verhalten der XmlSerializer-Klasse dadurch überschrieben, dass verschiedene Attribute erstellt und die Eigenschaften eines SoapAttributes-Objekts entsprechend auf diese Attribute festgelegt werden.

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

Siehe auch

XML-Serialisierung | Attribute für die Steuerung der Serialisierung von codiertem SOAP | XML-Serialisierung mit XML-Webdiensten

  • Last updated on