Message Klasa

Definicja

Zapewnia dostęp do właściwości wymaganych do zdefiniowania komunikatu usługi kolejkowania komunikatów.Provides access to the properties needed to define a Message Queuing message.

public ref class Message : System::ComponentModel::Component
public class Message : System.ComponentModel.Component
type Message = class
    inherit Component
Public Class Message
Inherits Component
Dziedziczenie

Przykłady

Poniższy przykład kodu demonstruje formatowanie treści komunikatu przy użyciu BinaryMessageFormatter .The following code example demonstrates formatting a message body using BinaryMessageFormatter.

#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

Poniższy przykład kodu demonstruje formatowanie treści komunikatu przy użyciu XmlMessageFormatter .The following code example demonstrates formatting a message body using XmlMessageFormatter.

#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;
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};

ref class MyNewQueue
{
public:
   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 );
      }

   }

   void SendMessage()
   {
      try
      {
         // Create a new order and set values.
         Order^ sentOrder = gcnew Order;
         sentOrder->orderId = 3;
         sentOrder->orderTime = DateTime::Now;

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

         // Create the new order.
         Message^ myMessage = gcnew Message( sentOrder );

         // Send the order to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }

   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = dynamic_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

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
{

    // The following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <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 Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            try
            {

                // Create a new order and set values.
                Order sentOrder = new Order();
                sentOrder.orderId = 3;
                sentOrder.orderTime = DateTime.Now;

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

                // Create the new order.
                Message myMessage = new Message(sentOrder);

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

            return;
        }

        //**************************************************
        // Receives a message containing an order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // 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 XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

                // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

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



   
' The following example 
' sends to a queue and receives from a queue.
Public Class Order
      Public orderId As Integer
      Public orderTime As DateTime
End Class

   
  
' Provides a container class for the example.

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 Order to a queue.

   Public Sub SendMessage()
      Try
            
            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            
            
            ' Create the new order.
            Dim myMessage As New Message(sentOrder)
            
            ' Send the order to the queue.
            myQueue.Send(myMessage)
      Catch e As ArgumentException
            Console.WriteLine(e.Message)
      End Try 
         
      Return
   End Sub
      
      
      
 
      ' Receives a message containing an order.
 
   Public Sub ReceiveMessage()
         ' 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 XmlMessageFormatter(New Type() {GetType(Order)})
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            Dim myOrder As Order = CType(myMessage.Body, Order)
            
            ' Display message information.
            Console.WriteLine(("Order ID: " + myOrder.orderId.ToString()))
            Console.WriteLine(("Sent: " + myOrder.orderTime.ToString()))
         
  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
   End Sub
End Class

Uwagi

Użyj Message klasy w celu wglądu lub odbierania komunikatów z kolejki lub w celu uzyskania dokładnej kontroli nad właściwościami komunikatów podczas wysyłania komunikatu do kolejki.Use the Message class to peek or receive messages from a queue, or to have fine control over message properties when sending a message to a queue.

MessageQueue używa Message klasy podczas wglądu lub odbierania komunikatów z kolejek, ponieważ obie MessageQueue.Peek MessageQueue.Receive metody i tworzą nowe wystąpienie Message klasy i ustawiają właściwości wystąpienia.MessageQueue uses the Message class when it peeks or receives messages from queues, because both the MessageQueue.Peek and MessageQueue.Receive methods create a new instance of the Message class and set the instance's properties. MessageWłaściwości tylko do odczytu klasy dotyczą pobierania komunikatów z kolejki, podczas gdy właściwości do odczytu/zapisu dotyczą wysyłania i pobierania komunikatów.The Message class's read-only properties apply to retrieving messages from a queue, while the read/write properties apply to sending and retrieving messages. Gdy MessageQueue Pobiera lub odbiera komunikat z kolejki, jego MessageReadPropertyFilter Właściwość określa, które właściwości komunikatu są pobierane.When MessageQueue peeks or receives a message from a queue, its MessageReadPropertyFilter property determines which of the message's properties are retrieved.

MessageQueue Send Metoda klasy umożliwia określenie dowolnego typu obiektu dla wiadomości wysyłanej do kolejki.The MessageQueue class's Send method allows you to specify any object type for a message being sent to that queue. Można użyć MessageQueue Właściwości wystąpienia, DefaultPropertiesToSend Aby określić ustawienia dla komunikatów ogólnych wysyłanych do kolejki.You can use the MessageQueue instance's DefaultPropertiesToSend property to specify settings for generic messages sent to the queue. Typy ustawień to program formatujący, etykieta, szyfrowanie i uwierzytelnianie.The types of settings include formatter, label, encryption, and authentication. Możesz również określić wartości dla odpowiednich członków, DefaultPropertiesToSend gdy koordynujesz aplikację do obsługi wiadomości, aby odpowiedzieć na potwierdzenie i komunikaty raportu.You can also specify values for the appropriate DefaultPropertiesToSend members when you coordinate your messaging application to respond to acknowledgment and report messages. Użycie Message wystąpienia do wysłania wiadomości do kolejki zapewnia elastyczność dostępu i modyfikacji wielu z tych właściwości — zarówno w przypadku pojedynczego komunikatu, jak i komunikatów na podstawie komunikatów.Using a Message instance to send a message to the queue gives you the flexibility to access and modify many of these properties - either for a single message or on a message-by-message basis. Message właściwości mają pierwszeństwo przed DefaultPropertiesToSend .Message properties take precedence over DefaultPropertiesToSend.

Dane komunikatu są przechowywane we Body właściwości i w mniejszym zakresie, AppSpecific Extension właściwości i.Message data is stored in the Body property and to a lesser extent, the AppSpecific and Extension properties. Gdy dane komunikatu są szyfrowane, serializowane lub deserializowane, wpływają tylko na zawartość Body właściwości.When message data is encrypted, serialized, or deserialized, only the contents of the Body property are affected.

Zawartość Body właściwości jest serializowana, gdy komunikat jest wysyłany przy użyciu Formatter określonej właściwości.The contents of the Body property are serialized when the message is sent, using the Formatter property you specify. Serializowana zawartość znajduje się we BodyStream właściwości.The serialized contents are found in the BodyStream property. Możesz również ustawić BodyStream Właściwość bezpośrednio, na przykład, aby wysłać plik jako zawartość danych wiadomości.You can also set the BodyStream property directly, for example, to send a file as the data content of a message. Można zmienić Body Formatter właściwości lub w dowolnym momencie przed wysłaniem komunikatu, a dane zostaną odpowiednio zserializowane po wywołaniu Send .You can change the Body or Formatter properties at any time before sending the message, and the data will be serialized appropriately when you call Send.

Właściwości zdefiniowane przez MessageQueue.DefaultPropertiesToSend Właściwość mają zastosowanie tylko do wiadomości, które nie są typu Message .The properties defined by the MessageQueue.DefaultPropertiesToSend property apply only to messages that are not of type Message. Jeśli określisz DefaultPropertiesToSend Właściwość MessageQueue obiektu, właściwości o identycznej nazwie w Message wystąpieniu wysłanym do tej kolejki powodują Ignorowanie tych domyślnych właściwości.If you specify the DefaultPropertiesToSend property for a MessageQueue, the identically named properties in a Message instance sent to that queue cause these default properties to be ignored.

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia Message , zobacz Message Konstruktor.For a list of initial property values for an instance of Message, see the Message constructor.

Konstruktory

Message()

Inicjuje nowe wystąpienie Message klasy z pustą treścią.Initializes a new instance of the Message class with an empty body.

Message(Object)

Inicjuje nowe wystąpienie Message klasy, używając XmlMessageFormatter do serializacji określonego obiektu w treści wiadomości.Initializes a new instance of the Message class, using the XmlMessageFormatter to serialize the specified object into the body of the message.

Message(Object, IMessageFormatter)

Inicjuje nowe wystąpienie Message klasy przy użyciu określonego programu formatującego do serializacji określonego obiektu w treści wiadomości.Initializes a new instance of the Message class using the specified formatter to serialize the specified object into the body of the message.

Pola

InfiniteTimeout

Określa, że limit czasu nie istnieje.Specifies that no time-out exists.

Właściwości

AcknowledgeType

Pobiera lub ustawia typ komunikatu potwierdzającego do zwrócenia do aplikacji wysyłającej.Gets or sets the type of acknowledgment message to be returned to the sending application.

Acknowledgment

Pobiera klasyfikację potwierdzenia, że ta wiadomość reprezentuje.Gets the classification of acknowledgment that this message represents.

AdministrationQueue

Pobiera lub ustawia kolejkę odbierającą komunikaty potwierdzające generowane przez usługę kolejkowania komunikatów.Gets or sets the queue that receives the acknowledgement messages that Message Queuing generates.

AppSpecific

Pobiera lub ustawia dodatkowe informacje specyficzne dla aplikacji.Gets or sets additional, application-specific information.

ArrivedTime

Pobiera godzinę odebrania komunikatu w kolejce docelowej.Gets the time that the message arrived in the destination queue.

AttachSenderId

Pobiera lub ustawia wartość wskazującą, czy identyfikator nadawcy powinien zostać dołączony do wiadomości.Gets or sets a value that indicates whether the sender ID should be attached to the message.

Authenticated

Pobiera wartość wskazującą, czy wiadomość została uwierzytelniona.Gets a value that indicates whether the message was authenticated.

AuthenticationProviderName

Pobiera lub ustawia nazwę dostawcy usług kryptograficznych używanego do generowania podpisu cyfrowego wiadomości.Gets or sets the name of the cryptographic provider used to generate the digital signature of the message.

AuthenticationProviderType

Pobiera lub ustawia typ dostawcy usług kryptograficznych używanego do generowania podpisu cyfrowego wiadomości.Gets or sets the type of cryptographic provider used to generate the digital signature of the message.

Body

Pobiera lub ustawia zawartość wiadomości.Gets or sets the content of the message.

BodyStream

Pobiera lub ustawia informacje w treści wiadomości.Gets or sets the information in the body of the message.

BodyType

Pobiera lub ustawia typ danych, które zawiera treść wiadomości.Gets or sets the type of data that the message body contains.

CanRaiseEvents

Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie.Gets a value indicating whether the component can raise an event.

(Odziedziczone po Component)
ConnectorType

Pobiera lub ustawia wartość wskazującą, że niektóre właściwości komunikatów zwykle ustawiane przez usługę kolejkowania komunikatów były ustawiane przez aplikację wysyłającą.Gets or sets a value that indicates that some message properties typically set by Message Queuing were set by the sending application.

Container

Pobiera IContainer , który zawiera Component .Gets the IContainer that contains the Component.

(Odziedziczone po Component)
CorrelationId

Pobiera lub ustawia identyfikator komunikatu używany przez potwierdzenia, raport i komunikaty odpowiedzi, aby odwołać się do oryginalnej wiadomości.Gets or sets the message identifier used by acknowledgment, report, and response messages to reference the original message.

DesignMode

Pobiera wartość wskazującą, czy Component jest aktualnie w trybie projektowania.Gets a value that indicates whether the Component is currently in design mode.

(Odziedziczone po Component)
DestinationQueue

Pobiera zaplanowaną kolejkę docelową dla wiadomości.Gets the intended destination queue for a message.

DestinationSymmetricKey

Pobiera lub ustawia klucz symetryczny używany do szyfrowania komunikatów szyfrowanych przez aplikacje lub komunikatów wysyłanych do kolejek obcych.Gets or sets the symmetric key used to encrypt application-encrypted messages or messages sent to foreign queues.

DigitalSignature

Pobiera lub ustawia podpis cyfrowy wykorzystywany przez usługę kolejkowania komunikatów do uwierzytelniania wiadomości.Gets or sets the digital signature that Message Queuing uses to authenticate the message.

EncryptionAlgorithm

Pobiera lub ustawia algorytm szyfrowania używany do szyfrowania treści wiadomości prywatnej.Gets or sets the encryption algorithm used to encrypt the body of a private message.

Events

Pobiera listę programów obsługi zdarzeń, które są dołączone do tego elementu Component .Gets the list of event handlers that are attached to this Component.

(Odziedziczone po Component)
Extension

Pobiera lub ustawia dodatkowe zdefiniowane przez aplikację informacje skojarzone z wiadomością.Gets or sets additional, application-defined information associated with the message.

Formatter

Pobiera lub ustawia program formatujący służący do serializacji obiektu do lub deserializacji obiektu z treści komunikatu.Gets or sets the formatter used to serialize an object into or deserialize an object from the message body.

HashAlgorithm

Pobiera lub ustawia algorytm wyznaczania wartości skrótu używany przez usługę kolejkowania komunikatów podczas uwierzytelniania wiadomości lub tworzenia podpisu cyfrowego wiadomości.Gets or sets the hashing algorithm that Message Queuing uses when authenticating a message or creating a digital signature for a message.

Id

Pobiera identyfikator wiadomości.Gets the message's identifier.

IsFirstInTransaction

Pobiera wartość wskazującą, czy wiadomość była pierwszą wiadomością wysłaną w transakcji.Gets a value that indicates whether the message was the first message sent in a transaction.

IsLastInTransaction

Pobiera wartość wskazującą, czy wiadomość była ostatnią wiadomością wysłaną w transakcji.Gets a value that indicates whether the message was the last message sent in a transaction.

Label

Pobiera lub ustawia ciąg Unicode zdefiniowany przez aplikację, który opisuje komunikat.Gets or sets an application-defined Unicode string that describes the message.

LookupId

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Pobiera identyfikator wyszukiwania wiadomości.Gets the message's lookup identifier.

MessageType

Pobiera typ komunikatu: Normal , Acknowledgment , lub Report .Gets the message type: Normal, Acknowledgment, or Report.

Priority

Pobiera lub ustawia priorytet wiadomości, który określa, gdzie w kolejce zostanie umieszczony komunikat.Gets or sets the message priority, which determines where in the queue the message is placed.

Recoverable

Pobiera lub ustawia wartość wskazującą, czy komunikat ma być dostarczany w przypadku awarii komputera lub problemu z siecią.Gets or sets a value that indicates whether the message is guaranteed to be delivered in the event of a computer failure or network problem.

ResponseQueue

Pobiera lub ustawia kolejkę odbierającą komunikaty odpowiedzi generowane przez aplikację.Gets or sets the queue that receives application-generated response messages.

SecurityContext

Pobiera lub ustawia kontekst zabezpieczeń wiadomości.Gets or sets the security context for a message.

SenderCertificate

Pobiera lub ustawia certyfikat zabezpieczeń używany do uwierzytelniania komunikatów.Gets or sets the security certificate used to authenticate messages.

SenderId

Pobiera identyfikator użytkownika wysyłającego.Gets the identifier of the sending user.

SenderVersion

Pobiera wersję usługi kolejkowania komunikatów używaną do wysłania wiadomości.Gets the version of Message Queuing used to send the message.

SentTime

Pobiera datę i godzinę komputera wysyłającego, który komunikat został wysłany przez Menedżera kolejki źródłowej.Gets the date and time on the sending computer that the message was sent by the source queue manager.

Site

Pobiera lub ustawia wartość ISite Component .Gets or sets the ISite of the Component.

(Odziedziczone po Component)
SourceMachine

Pobiera komputer, z którego pochodzi wiadomość.Gets the computer from which the message originated.

TimeToBeReceived

Pobiera lub ustawia maksymalny czas odbierania wiadomości z kolejki docelowej.Gets or sets the maximum amount of time for the message to be received from the destination queue.

TimeToReachQueue

Pobiera lub ustawia maksymalny czas, przez jaki komunikat dociera do kolejki.Gets or sets the maximum amount of time for the message to reach the queue.

TransactionId

Pobiera identyfikator transakcji będącej częścią wiadomości.Gets the identifier for the transaction of which the message was a part.

TransactionStatusQueue

Pobiera kolejkę stanu transakcji na komputerze źródłowym.Gets the transaction status queue on the source computer.

UseAuthentication

Pobiera lub ustawia wartość wskazującą, czy wiadomość była (albo musi być) uwierzytelniona przed wysłaniem.Gets or sets a value that indicates whether the message was (or must be) authenticated before being sent.

UseDeadLetterQueue

Pobiera lub ustawia wartość wskazującą, czy kopia komunikatu, która nie mogła zostać dostarczona, powinna zostać wysłana do kolejki utraconych wiadomości.Gets or sets a value that indicates whether a copy of the message that could not be delivered should be sent to a dead-letter queue.

UseEncryption

Pobiera lub ustawia wartość wskazującą, czy komunikat ma być prywatny.Gets or sets a value that indicates whether to make the message private.

UseJournalQueue

Pobiera lub ustawia wartość wskazującą, czy kopia komunikatu powinna być przechowywana w dzienniku komputera na komputerze źródłowym.Gets or sets a value that indicates whether a copy of the message should be kept in a machine journal on the originating computer.

UseTracing

Pobiera lub ustawia wartość wskazującą, czy komunikat ma być śledzony w kierunku jego kolejki docelowej.Gets or sets a value that indicates whether to trace a message as it moves toward its destination queue.

Metody

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszelkie zasoby używane przez element Component.Releases all resources used by the Component.

(Odziedziczone po Component)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element Component i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Odziedziczone po Component)
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetService(Type)

Zwraca obiekt, który reprezentuje usługę dostarczoną przez Component lub przez Container .Returns an object that represents a service provided by the Component or by its Container.

(Odziedziczone po Component)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
ToString()

Zwraca wartość String zawierającą nazwę Component (jeśli istnieje).Returns a String containing the name of the Component, if any. Ta metoda nie powinna być przesłaniana.This method should not be overridden.

(Odziedziczone po Component)

Zdarzenia

Disposed

Występuje, gdy składnik zostanie usunięty przez wywołanie Dispose() metody.Occurs when the component is disposed by a call to the Dispose() method.

(Odziedziczone po Component)

Dotyczy

Zobacz też