BinaryMessageFormatter Classe

Definizione

Spazio dei nomi:

System.Messaging

Assembly:

System.Messaging.dll

Serializza o deserializza un oggetto o un intero grafico di oggetti collegati, nel o dal corpo di un messaggio di Accodamento messaggi, utilizzando un formato binario.

C#

public class BinaryMessageFormatter : ICloneable, System.Messaging.IMessageFormatter

Ereditarietà

Object

BinaryMessageFormatter

Implementazioni

ICloneable IMessageFormatter

Esempio

C#

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

Commenti

Importante

La chiamata a metodi da questa classe con dati non attendibili costituisce un rischio per la sicurezza. Chiamare i metodi da questa classe solo con dati attendibili. Per altre informazioni, vedere Convalidare tutti gli input.

L'oggetto BinaryMessageFormatter è molto efficiente e può essere usato per serializzare la maggior parte degli oggetti. Il risultato è molto compatto e veloce da analizzare, ma non consente la messaggistica in modo libero come avviee.XmlMessageFormatter Il client e il server possono versione indipendente del tipo inviato e ricevuto.

Quando l'applicazione invia un messaggio alla coda usando un'istanza della MessageQueue classe, il formattatore serializza l'oggetto in un flusso e lo inserisce nel corpo del messaggio. Quando si legge da una coda usando un MessageQueue, il formattatore deserializza i dati del messaggio nella Body proprietà di un Messageoggetto .

BinaryMessageFormatter fornisce una velocità effettiva più rapida rispetto a XmlMessageFormatter. Usare l'oggetto BinaryMessageFormatter quando la velocità pura anziché la messaggistica a coppia libera è desiderata.

Costruttori

BinaryMessageFormatter()	Inizializza una nuova istanza della classe BinaryMessageFormatter, senza specificare uno stile per il tipo o per l'assembly di oggetti Top.
BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle)	Inizializza una nuova istanza della classe BinaryMessageFormatter che specifica i formati dell'oggetto di primo livello e le descrizioni dei tipi.

Proprietà

TopObjectFormat	Ottiene o imposta un valore che definisce il modo in cui l'oggetto di primo livello viene deserializzato rispetto all'individuazione e al caricamento dell'assembly.
TypeFormat	Ottiene o imposta un valore che definisce le modalità di disposizione delle descrizioni dei tipi all'interno del flusso serializzato.

Metodi

CanRead(Message)	Determina se il formattatore può deserializzare il contenuto del messaggio.
Clone()	Crea un'istanza della classe BinaryMessageFormatter le cui proprietà di lettura/scrittura (i formati di descrizione dei tipi e dell'oggetto di primo livello) siano identiche a quelle del BinaryMessageFormatter corrente.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Read(Message)	Legge il contenuto del messaggio indicato e crea un oggetto contenente il messaggio deserializzato.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Write(Message, Object)	Serializza un oggetto nel corpo del messaggio.

Si applica a

Vedi anche

• XmlMessageFormatter
• ActiveXMessageFormatter
• Formatter
• Formatter