BinaryMessageFormatter Osztály

Definíció

Névtér:: System.Messaging

Szerelvény:: System.Messaging.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Bináris formátumban szerializál vagy deszerializál egy objektumot vagy egy csatlakoztatott objektumok teljes gráfját egy Üzenetsor-üzenet törzsébe vagy törzséből.

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

Öröklődés: Object
BinaryMessageFormatter

Megvalósítás: ICloneable IMessageFormatter

Példák

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

Megjegyzések

Important

Az osztályból származó metódusok nem megbízható adatokkal való meghívása biztonsági kockázatot jelent. Csak megbízható adatokkal hívja meg ennek az osztálynak a metódusait. További információ: Minden bemenet ellenőrzése.

Ez BinaryMessageFormatter nagyon hatékony, és a legtöbb objektum szerializálására használható. Az eredmény nagyon kompakt és gyorsan elemezni, de nem teszi lehetővé a lazán összekapcsolt üzenetküldést, mint a XmlMessageFormatter . A lazán összekapcsolt eszköz azt jelenti, hogy az ügyfél és a kiszolgáló egymástól függetlenül verziószámozza az elküldött és fogadott típust.

Amikor az alkalmazás az osztály egy példányával küld üzenetet az MessageQueue üzenetsornak, a formázó szerializálja az objektumot egy streamben, és beszúrja az üzenettörzsbe. Üzenetsorból MessageQueueolvasáskor a formázó deszerializálja az üzenetadatokat egy Body Messagetulajdonságba.

BinaryMessageFormatter gyorsabb átviteli sebességet biztosít, mint a XmlMessageFormatter. A lazán összekapcsolt üzenetküldés helyett használja a BinaryMessageFormatter tiszta sebességet.

Konstruktorok

Name	Description
BinaryMessageFormatter()	Inicializálja az BinaryMessageFormatter osztály új példányát típusstílus vagy felső objektumszerelvény-stílus megadása nélkül.
BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle)	Inicializálja az BinaryMessageFormatter osztály új példányát, megadva a gyökérobjektum formátumát és a típusleírásokat.

Tulajdonságok

Name	Description
TopObjectFormat	Lekéri vagy beállít egy értéket, amely meghatározza a gráf felső (gyökér) objektumának deszerializálását a szerelvény megkeresése és betöltése szempontjából.
TypeFormat	Lekéri vagy beállít egy értéket, amely meghatározza a típusleírások szerializált streamben való lefektetése módját.

Metódusok

Name	Description
CanRead(Message)	Meghatározza, hogy a formázó képes-e deszerializálni az üzenet tartalmát.
Clone()	Létrehozza annak az osztálynak a BinaryMessageFormatter példányát, amelynek olvasási/írási tulajdonságai (a gyökérobjektum és a típusleírás formátuma) megegyeznek az aktuáliséval BinaryMessageFormatter.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Read(Message)	Beolvassa a tartalmat az adott üzenetből, és létrehoz egy objektumot, amely tartalmazza a deszerializált üzenetet.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Write(Message, Object)	Szerializál egy objektumot az üzenet törzsébe.

A következőre érvényes:

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?