BinaryFormatter-Klasse

Artikel
08/20/2007

Serialisiert und deserialisiert ein Objekt oder ein gesamtes Diagramm verbundener Objekte im binären Format.

Namespace: System.Runtime.Serialization.Formatters.Binary
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<ComVisibleAttribute(True)> _
Public NotInheritable Class BinaryFormatter
    Implements IRemotingFormatter, IFormatter
'Usage
Dim instance As BinaryFormatter

[ComVisibleAttribute(true)] 
public sealed class BinaryFormatter : IRemotingFormatter, IFormatter

[ComVisibleAttribute(true)] 
public ref class BinaryFormatter sealed : IRemotingFormatter, IFormatter

/** @attribute ComVisibleAttribute(true) */ 
public final class BinaryFormatter implements IRemotingFormatter, IFormatter

ComVisibleAttribute(true) 
public final class BinaryFormatter implements IRemotingFormatter, IFormatter

Hinweise

Die SoapFormatter-Klasse und die BinaryFormatter-Klasse implementieren die IRemotingFormatter-Schnittstelle, um RPCs (Remote Procedure Calls, Remoteprozeduraufrufe) zu unterstützen. Außerdem wird die IFormatter-Schnittstelle (geerbt von IRemotingFormatter) implementiert, um die Serialisierung eines Objektdiagramms zu unterstützen. Die SoapFormatter-Klasse unterstützt außerdem RPCs mit ISoapMessage-Objekten, ohne dabei die IRemotingFormatter-Funktionen zu verwenden.

Während eines RPC lässt die IRemotingFormatter-Schnittstelle die Spezifikation zweier separater Objektdiagramme zu: das Diagramm der zu serialisierenden Objekte sowie ein weiteres Diagramm mit einem Array von Headerobjekten, die Informationen über den Remotefunktionsaufruf übermitteln (z. B. die Transaktions-ID oder eine Methodensignatur).

RPCs, die den BinaryFormatter verwenden, untergliedern sich in zwei Teile: Methodenaufrufe, die mit dem Remoteobjekt, das die aufgerufene Methode enthält, an den Server gesendet werden, sowie Methodenantworten, die mit den Status- und Antwortinformationen der aufgerufenen Methode vom Server an den Client gesendet werden.

Während der Serialisierung eines Methodenaufrufs muss das erste Objekt des Objektdiagramms die IMethodCallMessage-Schnittstelle unterstützen. Verwenden Sie die Deserialize-Methode mit dem HeaderHandler-Parameter, um einen Methodenaufruf zu deserialisieren. Die Remotinginfrastruktur erstellt mithilfe des HeaderHandler-Delegaten ein Objekt, das die ISerializable-Schnittstelle unterstützt. Wenn der BinaryFormatter den HeaderHandler-Delegaten aufruft, wird der URI des Remoteobjekts mit der aufgerufenen Methode zurückgegeben. Das erste Objekt im zurückgegebenen Diagramm unterstützt die IMethodCallMessage-Schnittstelle.

Die Serialisierungsprozedur für eine Methodenantwort ist identisch mit der Prozedur für einen Methodenaufruf, abgesehen davon, dass das erste Objekt des Objektdiagramms die IMethodReturnMessage-Schnittstelle unterstützen muss. Verwenden Sie die DeserializeMethodResponse-Methode, um eine Methodenantwort zu deserialisieren. Um Zeit zu sparen, werden während des Methodenaufrufs keine Details über das aufrufende Objekt an das Remoteobjekt gesendet. Diese werden stattdessen vom ursprünglichen Methodenaufruf abgerufen, der an die DeserializeMethodResponse-Methode im IMethodCallMessage-Parameter übergeben wird. Das erste Objekt im von der DeserializeMethodResponse-Methode zurückgegebenen Diagramm unterstützt die IMethodReturnMessage-Schnittstelle.

Ungepaarte Ersatzzeichen

Alle ungepaarten Ersatzzeichen gehen bei der binären Serialisierung verloren. Die folgende Zeichenfolge z. B. enthält ein hohes Unicode-Ersatzzeichen (\ud800) zwischen den beiden Test Wörtern:

Test\ud800Test

Vor der Serialisierung sieht das Bytearray der Zeichenfolge wie folgt aus:

Bytearraywert	Zeichen
84	T
101	e
115	s
116	t
55296	\ud800
84	T
101	e
115	s
116	t

Nach der Deserialisierung geht das hohe Unicode-Ersatzzeichen verloren:

Bytearraywert	Zeichen
84	T
101	e
115	s
116	t
84	T
101	e
115	s
116	t

Beispiel

Imports System.IO
Imports System.Collections
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Runtime.Serialization


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. 
        ' In this case, use a file stream.
        Dim fs As New FileStream("DataFile.dat", FileMode.Create)

        ' Construct a BinaryFormatter and use it to serialize the data to the stream.
        Dim formatter As New BinaryFormatter
        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.dat", FileMode.Open)
        Try
            Dim formatter As New BinaryFormatter

            ' 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.
        Dim de As DictionaryEntry
        For Each de In addresses
            Console.WriteLine("{0} lives at {1}.", de.Key, de.Value)
        Next
    End Sub
End Module

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

public 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. 
        // In this case, use a file stream.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        // Construct a BinaryFormatter and use it to serialize the data to the stream.
        BinaryFormatter formatter = new BinaryFormatter();
        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.dat", FileMode.Open);
        try 
        {
            BinaryFormatter formatter = new BinaryFormatter();

            // 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.
        foreach (DictionaryEntry de in addresses) 
        {
            Console.WriteLine("{0} lives at {1}.", de.Key, de.Value);
        }
    }
}

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;
using namespace System::Runtime::Serialization;
ref class App
{
public:
   static 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. 
      // In this case we will use a file stream.
      FileStream^ fs = gcnew FileStream( "DataFile.dat",FileMode::Create );
      
      // Construct a BinaryFormatter and use it to serialize the data to the stream.
      BinaryFormatter^ formatter = gcnew BinaryFormatter;
      try
      {
         formatter->Serialize( fs, addresses );
      }
      catch ( SerializationException^ e ) 
      {
         Console::WriteLine( "Failed to serialize. Reason: {0}", e->Message );
         throw;
      }
      finally
      {
         fs->Close();
      }

   }

   static 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.dat",FileMode::Open );
      try
      {
         BinaryFormatter^ formatter = gcnew BinaryFormatter;
         
         // 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.
      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()
{
   App::Serialize();
   App::Deserialize();
   return 0;
}

import System.*;
import System.IO.*;
import System.Collections.*;
import System.Runtime.Serialization.Formatters.Binary.*;
import System.Runtime.Serialization.*;

public class App
{
    /** @attribute STAThread()
     */
    public static void main(String[] args) throws SerializationException
    {
        Serialize();
        Deserialize();
    } //main

    static void Serialize() throws SerializationException
    {
        // 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. 
        // In this case, use a file stream.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        // Construct a BinaryFormatter and use it to serialize the data to the 
        // stream.
        BinaryFormatter formatter = new BinaryFormatter();

        try {
            formatter.Serialize(fs, addresses);
        }
        catch (SerializationException e) {
            Console.WriteLine("Failed to serialize. Reason: " 
                + e.get_Message());
            throw e;
        }
        finally {
            fs.Close();
        }
    } //Serialize

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

        // Open the file containing the data that you want to deserialize.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Open);

        try {
            BinaryFormatter formatter = new BinaryFormatter();

            // 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.get_Message());
            throw e;
        }
        finally {
            fs.Close();
        }

        // To prove that the table deserialized correctly, 
        // display the key/value pairs.
        IEnumerator objEnum = addresses.GetEnumerator();
        while (objEnum.MoveNext()) {
            DictionaryEntry de = (DictionaryEntry)objEnum.get_Current();        
            Console.WriteLine("{0} lives at {1}.", de.get_Key(), 
                de.get_Value());
        }
    } //Deserialize
} //App

Vererbungshierarchie

System.Object
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

BinaryFormatter-Klasse

Syntax

Hinweise

Ungepaarte Ersatzzeichen

Beispiel

Vererbungshierarchie

Threadsicherheit

Plattformen

Versionsinformationen

.NET Framework

Siehe auch

Referenz

Zusätzliche Ressourcen