SoapFormatter Classe

Définition

Espace de noms:

System.Runtime.Serialization.Formatters.Soap

Assembly:

System.Runtime.Serialization.Formatters.Soap.dll

Sérialise et désérialise un objet ou l'intégralité d'un graphique d'objets connectés, au format SOAP.

public ref class SoapFormatter sealed : System::Runtime::Remoting::Messaging::IRemotingFormatter

public sealed class SoapFormatter : System.Runtime.Remoting.Messaging.IRemotingFormatter

type SoapFormatter = class
    interface IRemotingFormatter
    interface IFormatter

Public NotInheritable Class SoapFormatter
Implements IRemotingFormatter

Héritage

Object

SoapFormatter

Implémente

IRemotingFormatter IFormatter

Exemples

#using <system.dll>
#using <system.runtime.serialization.formatters.soap.dll>

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization;
using namespace System::Runtime::Serialization::Formatters::Soap;
void Serialize()
{
   
   // Create a hashtable of values that will eventually be serialized.
   Hashtable^ addresses = gcnew Hashtable;
   addresses->Add( "Jeff", "123 Main Street, Redmond, WA 98052" );
   addresses->Add( "Fred", "987 Pine Road, Phila., PA 19116" );
   addresses->Add( "Mary", "PO Box 112233, Palo Alto, CA 94301" );
   
   // To serialize the hashtable (and its keys/values), 
   // you must first open a stream for writing.
   // We will use a file stream here.
   FileStream^ fs = gcnew FileStream( "DataFile.soap",FileMode::Create );
   
   // Construct a SoapFormatter and use it 
   // to serialize the data to the stream.
   SoapFormatter^ formatter = gcnew SoapFormatter;
   try
   {
      formatter->Serialize( fs, addresses );
   }
   catch ( SerializationException^ e ) 
   {
      Console::WriteLine( "Failed to serialize. Reason: {0}", e->Message );
      throw;
   }
   finally
   {
      fs->Close();
   }

}

void Deserialize()
{
   
   // Declare the hashtable reference.
   Hashtable^ addresses = nullptr;
   
   // Open the file containing the data that we want to deserialize.
   FileStream^ fs = gcnew FileStream( "DataFile.soap",FileMode::Open );
   try
   {
      SoapFormatter^ formatter = gcnew SoapFormatter;
      
      // Deserialize the hashtable from the file and 
      // assign the reference to our local variable.
      addresses = dynamic_cast<Hashtable^>(formatter->Deserialize( fs ));
   }
   catch ( SerializationException^ e ) 
   {
      Console::WriteLine( "Failed to deserialize. Reason: {0}", e->Message );
      throw;
   }
   finally
   {
      fs->Close();
   }

   
   // To prove that the table deserialized correctly, 
   // display the keys/values to the console.
   IEnumerator^ myEnum = addresses->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      DictionaryEntry^ de = safe_cast<DictionaryEntry^>(myEnum->Current);
      Console::WriteLine( " {0} lives at {1}.", de->Key, de->Value );
   }
}


[STAThread]
int main()
{
   Serialize();
   Deserialize();
}

using System;
using System.IO;
using System.Collections;
using System.Runtime.Serialization;

// Note: When building this code, you must reference the
// System.Runtime.Serialization.Formatters.Soap.dll assembly.
using System.Runtime.Serialization.Formatters.Soap;

class App
{
    [STAThread]
    static void Main()
    {
        Serialize();
        Deserialize();
    }

    static void Serialize()
    {
        // Create a hashtable of values that will eventually be serialized.
        Hashtable addresses = new Hashtable();
        addresses.Add("Jeff", "123 Main Street, Redmond, WA 98052");
        addresses.Add("Fred", "987 Pine Road, Phila., PA 19116");
        addresses.Add("Mary", "PO Box 112233, Palo Alto, CA 94301");

        // To serialize the hashtable (and its key/value pairs),
        // you must first open a stream for writing.
        // Use a file stream here.
        FileStream fs = new FileStream("DataFile.soap", FileMode.Create);

        // Construct a SoapFormatter and use it
        // to serialize the data to the stream.
        SoapFormatter formatter = new SoapFormatter();
        try
        {
            formatter.Serialize(fs, addresses);
        }
        catch (SerializationException e)
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally
        {
            fs.Close();
        }
    }

    static void Deserialize()
    {
        // Declare the hashtable reference.
        Hashtable addresses  = null;

        // Open the file containing the data that you want to deserialize.
        FileStream fs = new FileStream("DataFile.soap", FileMode.Open);
        try
        {
            SoapFormatter formatter = new SoapFormatter();

            // Deserialize the hashtable from the file and
            // assign the reference to the local variable.
            addresses = (Hashtable) formatter.Deserialize(fs);
        }
        catch (SerializationException e)
        {
            Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
            throw;
        }
        finally
        {
            fs.Close();
        }

        // To prove that the table deserialized correctly,
        // display the key/value pairs to the console.
        foreach (DictionaryEntry de in addresses)
        {
            Console.WriteLine("{0} lives at {1}.", de.Key, de.Value);
        }
    }
}

Imports System.IO
Imports System.Collections
Imports System.Runtime.Serialization

' Note: When building this code, you must reference the
' System.Runtime.Serialization.Formatters.Soap.dll assembly.
Imports System.Runtime.Serialization.Formatters.Soap


Module App

   Sub Main()
      Serialize()
      Deserialize()
   End Sub

   Sub Serialize()
      ' Create a hashtable of values that will eventually be serialized.
      Dim addresses As New Hashtable
      addresses.Add("Jeff", "123 Main Street, Redmond, WA 98052")
      addresses.Add("Fred", "987 Pine Road, Phila., PA 19116")
      addresses.Add("Mary", "PO Box 112233, Palo Alto, CA 94301")

      ' To serialize the hashtable (and its key/value pairs), 
      ' you must first open a stream for writing.
      ' Use a file stream here.
      Dim fs As New FileStream("DataFile.soap", FileMode.Create)

      ' Construct a SoapFormatter and use it 
      ' to serialize the data to the stream.
      Dim formatter As New SoapFormatter
      Try
         formatter.Serialize(fs, addresses)
      Catch e As SerializationException
         Console.WriteLine("Failed to serialize. Reason: " & e.Message)
         Throw
      Finally
         fs.Close()
      End Try
   End Sub


   Sub Deserialize()
      ' Declare the hashtable reference.
      Dim addresses As Hashtable = Nothing

      ' Open the file containing the data that you want to deserialize.
      Dim fs As New FileStream("DataFile.soap", FileMode.Open)
      Try
         Dim formatter As New SoapFormatter

         ' Deserialize the hashtable from the file and 
         ' assign the reference to the local variable.
         addresses = DirectCast(formatter.Deserialize(fs), Hashtable)
      Catch e As SerializationException
         Console.WriteLine("Failed to deserialize. Reason: " & e.Message)
         Throw
      Finally
         fs.Close()
      End Try

      ' To prove that the table deserialized correctly, 
      ' display the key/value pairs to the console.
      Dim de As DictionaryEntry
      For Each de In addresses
         Console.WriteLine("{0} lives at {1}.", de.Key, de.Value)
      Next
   End Sub
End Module

Remarques

Notes

À compter de .NET Framework 2.0, cette classe est obsolète.

Avertissement

BinaryFormatter n’est pas sécurisé et ne peut pas être sécurisé. Pour plus d’informations, consultez le Guide de sécurité de BinaryFormatter.

Les SoapFormatter classes et BinaryFormatter implémentent l’interface IRemotingFormatter pour prendre en charge les appels de procédure distante (RPC) et l’interface IFormatter (héritée par ) pour prendre en charge la IRemotingFormattersérialisation d’un graphique d’objets. La SoapFormatter classe prend également en charge les RPC avec ISoapMessage des objets, sans utiliser la IRemotingFormatter fonctionnalité .

Pendant les RPC, l’interface IRemotingFormatter permet de spécifier deux graphiques d’objets distincts : le graphe des objets à sérialiser et un graphe supplémentaire qui contient un tableau d’objets d’en-tête qui transmettent des informations sur l’appel de fonction distante (par exemple, l’ID de transaction ou une signature de méthode). Pour une sérialisation correcte, l’objet racine du premier graphique doit être un objet qui implémente l’interface IMethodCallMessage ou l’interface IMethodReturnMessage .

Pendant la désérialisation d’un RPC, un HeaderHandler délégué est spécifié à la Deserialize méthode du formateur. L’infrastructure de communication à distance utilise le HeaderHandler délégué pour produire un objet qui prend en charge l’interface ISerializable . Cet objet contient les informations stockées dans les en-têtes et devient la racine du graphique retourné par le désérialiseur.

Peut SoapFormatter également gérer les RPC générés avec des objets qui implémentent l’interface ISoapMessage . Pour créer un RPC sans utiliser la IRemotingFormatter fonctionnalité, placez un objet qui prend en charge l’interface ISoapMessage à la racine d’un graphique en cours de sérialisation. Pour désérialiser un RPC créé de cette manière, la TopObject propriété doit être définie sur un autre objet qui prend en charge l’interface ISoapMessage et contient les informations d’appel à distance pertinentes.

Les objets TimeSpan sont sérialisés selon la norme ISO 8601 : 1998 section 5.5.3.2.1 « Alternative ».

Constructeurs

SoapFormatter()	Initialise une nouvelle instance de la classe SoapFormatter avec des valeurs de propriété par défaut.
SoapFormatter(ISurrogateSelector, StreamingContext)	Initialise une nouvelle instance de la classe SoapFormatter avec les ISurrogateSelector et StreamingContext spécifiés.

Propriétés

AssemblyFormat	Obtient ou définit le comportement du désérialiseur par rapport à la recherche et au chargement d'assemblys.
Binder	Obtient ou définit le SerializationBinder qui contrôle la liaison d'un objet sérialisé à un type.
Context	Obtient ou définit le StreamingContext utilisé avec ce SoapFormatter.
FilterLevel	Obtient ou définit le TypeFilterLevel de la désérialisation automatique du .NET Framework Remoting.
SurrogateSelector	Obtient ou définit le SurrogateSelector qui contrôle la substitution de types pendant la sérialisation et la désérialisation.
TopObject	Obtient ou définit le ISoapMessage dans lequel l'objet SOAP supérieur est désérialisé.
TypeFormat	Obtient ou définit le format dans lequel les descriptions de type sont disposées dans le flux sérialisé.

Méthodes

Deserialize(Stream)	Désérialise les données sur le flux fourni et reconstitue le graphique d'objets.
Deserialize(Stream, HeaderHandler)	Désérialise le flux dans un graphique d'objets, avec n'importe quel en-tête dans ce flux géré par le HeaderHandler donné.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Serialize(Stream, Object)	Sérialise un objet ou un graphique d'objets avec la racine spécifiée vers le Stream donné.
Serialize(Stream, Object, Header[])	Sérialise un objet ou graphique d'objets avec la racine spécifiée vers le Stream donné dans le format d'appel de procédure distante SOAP.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)