BinaryMessageFormatter BinaryMessageFormatter BinaryMessageFormatter BinaryMessageFormatter Class

Definition

Serialisiert bzw. deserialisiert ein Objekt oder ein ganzes Diagramm verbundener Objekte unter Verwendung eines binären Formats in bzw. aus dem Text einer Message Queuing-Meldung.Serializes or deserializes an object, or an entire graph of connected objects, to or from the body of a Message Queuing message, using a binary format.

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
Vererbung
BinaryMessageFormatterBinaryMessageFormatterBinaryMessageFormatterBinaryMessageFormatter
Implementiert

Beispiele

#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;

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

   //*************************************************
   // Creates a new queue.
   //*************************************************
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }


   //*************************************************
   // Sends an image to a queue, using the BinaryMessageFormatter.
   //*************************************************
   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 = gcnew MessageQueue( ".\\myQueue" );
         Message^ myMessage = gcnew Message( myImage,gcnew BinaryMessageFormatter );
         
         // Send the image to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }


   //*************************************************
   // Receives a message containing an image.
   //*************************************************
   void ReceiveMessage()
   {
      try
      {
         
         // Connect to the a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
         
         // Set the formatter to indicate body contains an Order.
         myQueue->Formatter = gcnew BinaryMessageFormatter;
         
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Bitmap^ myImage = static_cast<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;
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );
   
   // Send a message to a queue.
   myNewQueue->SendMessage();
   
   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

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

Hinweise

Wichtig

Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten stellt ein Sicherheitsrisiko dar.Calling methods from this class with untrusted data is a security risk. Rufen Sie die Methoden aus dieser Klasse nur mit vertrauenswürdigen Daten auf.Call the methods from this class only with trusted data. Weitere Informationen finden Sie unter Data Validation (Datenüberprüfung).For more information, see Data Validation.

Der BinaryMessageFormatter ist sehr effizient und kann verwendet werden, um die meisten Objekte zu serialisieren.The BinaryMessageFormatter is very efficient and can be used to serialize most objects. Das Ergebnis ist sehr kompakt und schnell zu analysieren, lässt jedoch das XmlMessageFormatter lose gekoppelte Messaging nicht zu.The result is very compact and fast to parse, but does not allow for loosely coupled messaging as the XmlMessageFormatter does. Lose gekoppelt bedeutet, dass der Client und der Server den gesendeten und empfangenen Typ unabhängig voneinander versieren können.Loosely coupled means that the client and the server can independently version the type that is sent and received.

Wenn die Anwendung eine Nachricht mithilfe einer Instanz der MessageQueue -Klasse an die Warteschlange sendet, serialisiert der Formatierer das Objekt in einen Stream und fügt es in den Nachrichtentext ein.When the application sends a message to the queue using an instance of the MessageQueue class, the formatter serializes the object into a stream and inserts it into the message body. Beim Lesen aus einer Warteschlange mit MessageQueueeinem deserialisiert der Formatierer die Nachrichten Daten in die Body -Eigenschaft eines Message.When reading from a queue using a MessageQueue, the formatter deserializes the message data into the Body property of a Message.

BinaryMessageFormatterbietet einen schnelleren Durchsatz als XmlMessageFormatter.BinaryMessageFormatter provides faster throughput than the XmlMessageFormatter. Verwenden Sie, wenn reine Geschwindigkeit anstelle von locker gekoppeltem Messaging gewünscht ist. BinaryMessageFormatterUse the BinaryMessageFormatter when pure speed rather than loosely coupled messaging is desired.

Konstruktoren

BinaryMessageFormatter() BinaryMessageFormatter() BinaryMessageFormatter() BinaryMessageFormatter()

Initialisiert eine neue Instanz der BinaryMessageFormatter-Klasse ohne Angabe eines Typ- oder Assemblyformats für das oberste Objekt.Initializes a new instance of the BinaryMessageFormatter class without specifying a type style or top object assembly style.

BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle) BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle) BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle) BinaryMessageFormatter(FormatterAssemblyStyle, FormatterTypeStyle)

Initialisiert eine neue Instanz der BinaryMessageFormatter-Klasse, wobei das Format für das Stammobjekt und die Typbeschreibungen angegeben wird.Initializes a new instance of the BinaryMessageFormatter class, specifying the formats of the root object and the type descriptions.

Eigenschaften

TopObjectFormat TopObjectFormat TopObjectFormat TopObjectFormat

Ruft einen Wert ab oder legt ihn fest, der definiert, wie das oberste Objekt (Stammobjekt) eines Diagramms bezüglich des Suchens und Ladens seiner Assembly deserialisiert wird.Gets or sets a value that defines how the top (root) object of a graph is deserialized with regards to finding and loading its assembly.

TypeFormat TypeFormat TypeFormat TypeFormat

Ruft einen Wert ab, der das Layout von Typbeschreibungen im serialisierten Stream definiert, oder legt diesen fest.Gets or sets a value that defines how type descriptions are laid out in the serialized stream.

Methoden

CanRead(Message) CanRead(Message) CanRead(Message) CanRead(Message)

Bestimmt, ob das Formatierungsprogramm den Inhalt der Meldung deserialisieren kann.Determines whether the formatter can deserialize the contents of the message.

Clone() Clone() Clone() Clone()

Erstellt eine Instanz der BinaryMessageFormatter-Klasse, deren Lese-und Schreibeigenschaften (die Formate für Stammobjekt und Typbeschreibung) mit denen des aktuellen BinaryMessageFormatter übereinstimmen.Creates an instance of the BinaryMessageFormatter class whose read/write properties (the root object and type description formats) are the same as the current BinaryMessageFormatter.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Read(Message) Read(Message) Read(Message) Read(Message)

Liest den Inhalt aus der angegebenen Meldung und erstellt ein Objekt, das die deserialisierte Meldung enthält.Reads the contents from the given message and creates an object that contains the deserialized message.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
Write(Message, Object) Write(Message, Object) Write(Message, Object) Write(Message, Object)

Serialisiert ein Objekt in den Textkörper der Meldung.Serializes an object into the body of the message.

Gilt für:

Siehe auch