BinaryFormatter 类

定义

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

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class BinaryFormatter : System.Runtime.Remoting.Messaging.IRemotingFormatter

type BinaryFormatter = class
    interface IRemotingFormatter
    interface IFormatter

Public NotInheritable Class BinaryFormatter
Implements IRemotingFormatter

继承

Object

BinaryFormatter

属性

ComVisibleAttribute

实现

IRemotingFormatter IFormatter

示例

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

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

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

注解

SoapFormatter 和 BinaryFormatter 类实现了 IRemotingFormatter 接口以支持远程过程调用（Rpc），并实现 IFormatter 接口（由 IRemotingFormatter继承）以支持对象图形的序列化。The SoapFormatter and BinaryFormatter classes implement the IRemotingFormatter interface to support remote procedure calls (RPCs), and the IFormatter interface (inherited by the IRemotingFormatter) to support serialization of a graph of objects. SoapFormatter 类还支持与 ISoapMessage 对象的 Rpc，而不使用 IRemotingFormatter 功能。The SoapFormatter class also supports RPCs with ISoapMessage objects, without using the IRemotingFormatter functionality.

在 Rpc 过程中，IRemotingFormatter 接口允许指定两个单独的对象图：要序列化的对象的关系图，以及一个包含标头对象数组的表，这些标头对象用于传递有关远程函数调用的信息（例如，事务 ID 或方法签名）。During RPCs, the IRemotingFormatter interface allows the specification of two separate object graphs: the graph of objects to serialize, and an additional graph that contains an array of header objects that convey information about the remote function call (for example, transaction ID or a method signature).

使用 BinaryFormatter 分为两个不同的部分的 Rpc：方法调用（发送到包含所调用方法的远程对象的服务器）和方法响应（使用被调用方法中的状态和响应信息从服务器发送到客户端）。RPCs that use the BinaryFormatter separate into two distinct parts: method calls, which are sent to the server with the remote object that contains the method called, and method responses, which are sent from the server to the client with the status and response information from the called method.

在方法调用的序列化过程中，对象图的第一个对象必须支持 IMethodCallMessage 接口。During serialization of a method call the first object of the object graph must support the IMethodCallMessage interface. 若要反序列化方法调用，请将 Deserialize 方法与 HeaderHandler 参数一起使用。To deserialize a method call, use the Deserialize method with the HeaderHandler parameter. 远程处理基础结构使用 HeaderHandler 委托生成支持 ISerializable 接口的对象。The remoting infrastructure uses the HeaderHandler delegate to produce an object that supports the ISerializable interface. 当 BinaryFormatter 调用 HeaderHandler 委托时，它将返回远程对象的 URI 以及正在调用的方法。When the BinaryFormatter invokes the HeaderHandler delegate, it returns the URI of the remote object with the method that is being called. 返回的关系图中的第一个对象支持 IMethodCallMessage 接口。The first object in the graph returned supports the IMethodCallMessage interface.

方法响应的序列化过程与方法调用的序列化过程相同，不同之处在于对象图的第一个对象必须支持 IMethodReturnMessage 接口。The serialization procedure for a method response is identical to that of a method call, except the first object of the object graph must support the IMethodReturnMessage interface. 若要反序列化方法响应，请使用 DeserializeMethodResponse 方法。To deserialize a method response, use the DeserializeMethodResponse method. 为了节省时间，在方法调用期间，不会将有关调用方对象的详细信息发送到远程对象。To save time, details about the caller object are not sent to the remote object during the method call. 这些详细信息是从原始方法调用获取的，该方法调用会传递到 IMethodCallMessage 参数中的 DeserializeMethodResponse 方法。These details are instead obtained from the original method call, which is passed to the DeserializeMethodResponse method in the IMethodCallMessage parameter. DeserializeMethodResponse 方法返回的关系图中的第一个对象支持 IMethodReturnMessage 接口。The first object in the graph returned by the DeserializeMethodResponse method supports the IMethodReturnMessage interface.

不成对代理项Unpaired Surrogates

二进制序列化会丢失任何未成对的代理项字符。Any unpaired surrogate characters are lost in binary serialization. 例如，以下字符串在两个 Test 单词之间包含一个高代理项 Unicode 字符 (\ud800）：For example, the following string contains a high surrogate Unicode character (\ud800) in between the two Test words:

Test\ud800Test

序列化之前，字符串的字节数组如下所示：Before serialization, the byte array of the string is as follows:

反序列化后，高位代理项 Unicode 字符将丢失：After deserialization, the high surrogate Unicode character is lost:

构造函数

属性

方法

适用于