Bagikan melalui


BinaryMessageFormatter Kelas

Definisi

Menserialisasikan atau mendeserialisasi objek, atau seluruh grafik objek yang tersambung, ke atau dari isi pesan Antrean Pesan, menggunakan format biner.

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
Warisan
BinaryMessageFormatter
Penerapan

Contoh

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

Keterangan

Penting

Metode panggilan dari kelas ini dengan data yang tidak tepercaya adalah risiko keamanan. Panggil metode dari kelas ini hanya dengan data tepercaya. Untuk informasi selengkapnya, lihat Memvalidasi Semua Input.

BinaryMessageFormatter sangat efisien dan dapat digunakan untuk membuat serialisasi sebagian besar objek. Hasilnya sangat ringkas dan cepat diurai, tetapi tidak memungkinkan olahpesan yang digabungkan secara longgar seperti yang XmlMessageFormatter dilakukan. Digabungkan secara longgar berarti bahwa klien dan server dapat secara independen membuat versi jenis yang dikirim dan diterima.

Ketika aplikasi mengirim pesan ke antrean menggunakan instans MessageQueue kelas , pemformat menserialisasikan objek ke dalam aliran dan menyisipkannya ke dalam isi pesan. Saat membaca dari antrean menggunakan MessageQueue, pemformat mendeserialisasi data pesan ke Body dalam properti dari Message.

BinaryMessageFormatter memberikan throughput yang lebih cepat daripada XmlMessageFormatter. BinaryMessageFormatter Gunakan saat kecepatan murni daripada pesan yang digabungkan secara longgar diinginkan.

Konstruktor

BinaryMessageFormatter()

Menginisialisasi instans BinaryMessageFormatter baru kelas tanpa menentukan gaya jenis atau gaya rakitan objek atas.

BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle)

Menginisialisasi instans BinaryMessageFormatter baru kelas, menentukan format objek akar dan deskripsi jenis.

Properti

TopObjectFormat

Mendapatkan atau menetapkan nilai yang menentukan bagaimana objek atas (akar) grafik dideserialisasi sehubungan dengan menemukan dan memuat rakitannya.

TypeFormat

Mendapatkan atau menetapkan nilai yang menentukan bagaimana deskripsi jenis ditata dalam aliran berseri.

Metode

CanRead(Message)

Menentukan apakah pemformat dapat mendeserialisasi konten pesan.

Clone()

Membuat instans BinaryMessageFormatter kelas yang properti baca/tulisnya (objek akar dan format deskripsi jenis) sama dengan saat ini BinaryMessageFormatter.

Equals(Object)

Menentukan apakah objek yang ditentukan sama dengan objek saat ini.

(Diperoleh dari Object)
GetHashCode()

Berfungsi sebagai fungsi hash default.

(Diperoleh dari Object)
GetType()

Mendapatkan dari instans Type saat ini.

(Diperoleh dari Object)
MemberwiseClone()

Membuat salinan dangkal dari saat ini Object.

(Diperoleh dari Object)
Read(Message)

Membaca konten dari pesan yang diberikan dan membuat objek yang berisi pesan yang dideserialisasi.

ToString()

Mengembalikan string yang mewakili objek saat ini.

(Diperoleh dari Object)
Write(Message, Object)

Menserialisasikan objek ke dalam isi pesan.

Berlaku untuk

Lihat juga