Compartilhar via


BinaryMessageFormatter Classe

Definição

Serializa ou desserializa um objeto ou um grafo inteiro de objetos conectados, de ou para o corpo de uma mensagem do Enfileiramento de Mensagens, usando um formato binário.

public ref class BinaryMessageFormatter : ICloneable, System::Messaging::IMessageFormatter
public class BinaryMessageFormatter : ICloneable, System.Messaging.IMessageFormatter
type BinaryMessageFormatter = class
    interface IMessageFormatter
    interface ICloneable
Public Class BinaryMessageFormatter
Implements ICloneable, IMessageFormatter
Herança
BinaryMessageFormatter
Implementações

Exemplos

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an image to a queue, using the BinaryMessageFormatter.
        //**************************************************
        
        public void SendMessage()
        {
            try{

                // Create a new bitmap.
                // The file must be in the \bin\debug or \bin\retail folder, or
                // you must give a full path to its location.
                Image myImage = Bitmap.FromFile("SentImage.bmp");

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");
                
                Message myMessage = new Message(myImage, new BinaryMessageFormatter());

                // Send the image to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an image.
        //**************************************************
        
        public  void ReceiveMessage()
        {
                        
            try
            {

                // Connect to the a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Set the formatter to indicate body contains an Order.
                myQueue.Formatter = new BinaryMessageFormatter();

                // Receive and format the message.
                System.Messaging.Message myMessage = myQueue.Receive();
                Bitmap myImage = (Bitmap)myMessage.Body;
                
                // This will be saved in the \bin\debug or \bin\retail folder.
                myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }

            catch (IOException e)
            {
                // Handle file access exceptions.
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}
Imports System.Messaging
Imports System.Drawing
Imports System.IO


Namespace MyProj
    _
   
   
   Public Class MyNewQueue
      
      
      '**************************************************
      ' Provides an entry point into the application.
      '		 
      ' This example sends and receives a message from
      ' a queue.
      '**************************************************
      Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create a queue on the local computer.
         CreateQueue(".\myQueue")
         
         ' Send a message to a queue.
         myNewQueue.SendMessage()
         
         ' Receive a message from a queue.
         myNewQueue.ReceiveMessage()
         
         Return
      End Sub
      
      
      '**************************************************
      ' Creates a new queue.
      '**************************************************
      Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
      End Sub
       
      
      '**************************************************
      ' Sends an image to a queue, using the BinaryMessageFormatter.
      '**************************************************
      Public Sub SendMessage()
         Try
            
            ' Create a new bitmap.
            ' The file must be in the \bin\debug or \bin\retail folder, or
            ' you must give a full path to its location.
            Dim myImage As Image = Bitmap.FromFile("SentImage.bmp")
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            Dim myMessage As New Message(myImage, New BinaryMessageFormatter())
            
            ' Send the image to the queue.
            myQueue.Send(myMessage)
         Catch e As ArgumentException
            Console.WriteLine(e.Message)
         End Try 
         
         Return
      End Sub
      
      
      
      '**************************************************
      ' Receives a message containing an image.
      '**************************************************
      Public Sub ReceiveMessage()
         
         Try
            
            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New BinaryMessageFormatter()
            
            ' Receive and format the message. 
            Dim myMessage As System.Messaging.Message = myQueue.Receive()
            Dim myImage As Bitmap = CType(myMessage.Body, Bitmap)
            
            ' This will be saved in the \bin\debug or \bin\retail folder.
            myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp)
         
         
         
         'Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         
         Catch e As IOException
         End Try
         ' Handle file access exceptions.
         
         ' Catch other exceptions as necessary.
         Return
      End Sub
   End Class
End Namespace 'MyProj

Comentários

Importante

Chamar métodos desta classe quando você tiver dados não confiáveis é um risco à segurança. Chame os métodos dessa classe somente quando você tiver dados confiáveis. Para obter mais informações, consulte Validar todas as entradas.

O BinaryMessageFormatter é muito eficiente e pode ser usado para serializar a maioria dos objetos. O resultado é muito compacto e rápido de analisar, mas não permite mensagens vagamente acopladas como o XmlMessageFormatter faz. Acoplado livremente significa que o cliente e o servidor podem versão independente do tipo que é enviado e recebido.

Quando o aplicativo envia uma mensagem para a fila usando uma instância da MessageQueue classe , o formatador serializa o objeto em um fluxo e insere-o no corpo da mensagem. Ao ler de uma fila usando um MessageQueue, o formatador desserializa os dados da mensagem na Body propriedade de um Message.

BinaryMessageFormatter fornece uma taxa de transferência mais rápida do que o XmlMessageFormatter. Use o BinaryMessageFormatter quando a velocidade pura em vez de mensagens acopladas vagamente for desejada.

Construtores

BinaryMessageFormatter()

Inicializa uma nova instância da classe BinaryMessageFormatter sem especificar um estilo de tipo ou estilo de assembly de objeto superior.

BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle)

Inicializa uma nova instância da classe BinaryMessageFormatter, especificando os formatos do objeto raiz e as descrições de tipo.

Propriedades

TopObjectFormat

Obtém ou define um valor que fine como o objeto superior (raiz) de um gráfico é desserializado em relação ao encontro e carregamento de seu assembly.

TypeFormat

Obtém ou define um valor que define como as descrições de tipo são dispostas no fluxo serializado.

Métodos

CanRead(Message)

Determina se o formatador pode desserializar o conteúdo da mensagem.

Clone()

Cria uma instância da classe BinaryMessageFormatter cujas propriedades de leitura/gravação (o objeto raiz e os formatos de descrição de tipo) são as mesmos que o BinaryMessageFormatter atual.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
Read(Message)

Lê o conteúdo de determinada mensagem e cria um objeto que contém a mensagem desserializada.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
Write(Message, Object)

Serializa um objeto no corpo da mensagem.

Aplica-se a

Confira também