MessageQueue Klasa

Definicja

Zapewnia dostęp do kolejki na serwerze usługi kolejkowania komunikatów.Provides access to a queue on a Message Queuing server.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable
[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable
[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu tworzy nowe obiekty MessageQueue przy użyciu różnych typów składni nazw ścieżek.The following code example creates new MessageQueue objects using various path name syntax types. W każdym przypadku wysyła komunikat do kolejki, której ścieżka jest zdefiniowana w konstruktorze.In each case, it sends a message to the queue whose path is defined in the constructor.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		 
        // This example demonstrates several ways to set
        // a queue's path.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();

            return;
        }
        
        // References public queues.
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        }

        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new 
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new 
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" + 
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new 
                MessageQueue(".\\Journal$");
            while(true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new 
                MessageQueue(".\\myQueue\\Journal$");
            while(true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }
        
        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new 
                MessageQueue(".\\DeadLetter$");
            while(true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new 
                MessageQueue(".\\XactDeadLetter$");
            while(true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.
            }
        }
    }
}
Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example demonstrates several ways to set
        ' a queue's path.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            myNewQueue.SendPublic()
            myNewQueue.SendPrivate()
            myNewQueue.SendByLabel()
            myNewQueue.SendByFormatName()
            myNewQueue.MonitorComputerJournal()
            myNewQueue.MonitorQueueJournal()
            myNewQueue.MonitorDeadLetter()
            myNewQueue.MonitorTransactionalDeadLetter()

            Return

        End Sub


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub

End Class

Poniższy przykład kodu wysyła komunikat do kolejki i odbiera komunikat z kolejki przy użyciu klasy specyficznej dla aplikacji o nazwie Order.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called Order.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


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

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // 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" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   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 = static_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;
   }
};

//*************************************************
// 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;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}
using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object 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();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

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

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            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

    ' This class represents an object 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


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' 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")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            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 the 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()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Uwagi

Technologia kolejkowania komunikatów umożliwia aplikacjom działającym w różnym czasie komunikowanie się między niejednorodnymi sieciami i systemami, które mogą być tymczasowo w trybie offline.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Aplikacje wysyłają, odbierają lub wkraczają (odczytu bez usuwania) komunikatów z kolejek.Applications send, receive, or peek (read without removing) messages from queues. Usługa kolejkowania komunikatów jest opcjonalnym składnikiem Windows 2000Windows 2000 i Windows NT i należy zainstalować oddzielnie.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

Klasa MessageQueue jest otoką dookoła usługi kolejkowania komunikatów.The MessageQueue class is a wrapper around Message Queuing. Istnieje wiele wersji usługi kolejkowania komunikatów, a korzystanie z klasy MessageQueue może spowodować nieco inne zachowanie, w zależności od używanego systemu operacyjnego.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. Aby uzyskać informacje o konkretnych funkcjach poszczególnych wersji usługi kolejkowania komunikatów, zobacz temat "co nowego w usłudze kolejkowania komunikatów" w zestawie SDK platformy w witrynie MSDN.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

Klasa MessageQueue zawiera odwołanie do kolejki usługi kolejkowania komunikatów.The MessageQueue class provides a reference to a Message Queuing queue. Możesz określić ścieżkę w konstruktorze MessageQueue, aby połączyć się z istniejącym zasobem lub utworzyć nową kolejkę na serwerze.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. Przed wywołaniem Send(Object), Peeklub Receivenależy skojarzyć nowe wystąpienie klasy MessageQueue z istniejącą kolejką.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. W tym momencie można manipulować właściwościami kolejki, takimi jak Category i Label.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueue obsługuje dwa typy pobieranych komunikatów: synchroniczne i asynchroniczne.MessageQueue supports two types of message retrieval: synchronous and asynchronous. Metody synchroniczne, Peek i Receive, powodują, że wątek procesu oczekuje określonego przedziału czasu na nadejście nowej wiadomości w kolejce.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. Metody asynchroniczne, BeginPeek i BeginReceiveumożliwiają wykonywanie głównych zadań aplikacji w osobnym wątku do momentu odebrania komunikatu w kolejce.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Metody te działają przy użyciu obiektów wywołania zwrotnego i obiektów stanu do przekazywania informacji między wątkami.These methods work by using callback objects and state objects to communicate information between threads.

Gdy tworzysz nowe wystąpienie klasy MessageQueue, nie tworzysz nowej kolejki usługi kolejkowania komunikatów.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. Zamiast tego można użyć metod Create(String), Delete(String)i Purge do zarządzania kolejkami na serwerze.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

W przeciwieństwie do Purge, Create(String) i Delete(String) są elementami członkowskimi static, więc można je wywoływać bez tworzenia nowego wystąpienia klasy MessageQueue.Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

Właściwość Path obiektu MessageQueue można ustawić na jedną z trzech nazw: przyjazną nazwę, FormatNamelub Label.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. Przyjazna nazwa, która jest definiowana przez właściwości MachineName i QueueName kolejki, jest MachineName\QueueName dla kolejki publicznej i MachineName\Private$\, QueueName w przypadku kolejki prywatnej.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. Właściwość FormatName zezwala na dostęp w trybie offline do kolejek komunikatów.The FormatName property allows offline access to message queues. Na koniec można użyć właściwości Label kolejki, aby ustawić Pathkolejki.Lastly, you can use the queue's Label property to set the queue's Path.

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia MessageQueue, zapoznaj się z konstruktorem MessageQueue.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Konstruktory

MessageQueue()

Inicjuje nowe wystąpienie klasy MessageQueue.Initializes a new instance of the MessageQueue class. Gdy Konstruktor bez parametrów Inicjuje nowe wystąpienie, należy ustawić właściwość Path wystąpienia, aby można było użyć wystąpienia.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

MessageQueue(String)

Inicjuje nowe wystąpienie klasy MessageQueue, która odwołuje się do kolejki usługi kolejkowania komunikatów w określonej ścieżce.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

MessageQueue(String, Boolean)

Inicjuje nowe wystąpienie klasy MessageQueue, która odwołuje się do kolejki usługi kolejkowania komunikatów w określonej ścieżce i z określonym ograniczeniem dostępu do odczytu.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean)

Inicjuje nowe wystąpienie klasy MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inicjuje nowe wystąpienie klasy MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, QueueAccessMode)

Inicjuje nowe wystąpienie klasy MessageQueue.Initializes a new instance of the MessageQueue class.

Pola

InfiniteQueueSize

Określa, że dla kolejki nie istnieje ograniczenie rozmiaru.Specifies that no size restriction exists for a queue.

InfiniteTimeout

Określa, że limit czasu nie istnieje dla metod, które pobierają lub odbierają wiadomości.Specifies that no time-out exists for methods that peek or receive messages.

Właściwości

AccessMode

Pobiera wartość wskazującą tryb dostępu dla kolejki.Gets a value that indicates the access mode for the queue.

Authenticate

Pobiera lub ustawia wartość wskazującą, czy kolejka akceptuje tylko wiadomości uwierzytelnione.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority

Pobiera lub ustawia usługę kolejkowania komunikatów Priorytet podstawowy, która używa do kierowania komunikatów w kolejce publicznej za pośrednictwem sieci.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

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)
CanRead

Pobiera wartość wskazującą, czy MessageQueue można odczytać.Gets a value that indicates whether the MessageQueue can be read.

CanWrite

Pobiera wartość wskazującą, czy MessageQueue może być zapisywana.Gets a value that indicates whether the MessageQueue can be written to.

Category

Pobiera lub ustawia kategorię kolejki.Gets or sets the queue category.

Container

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

(Odziedziczone po Component)
CreateTime

Pobiera datę i godzinę utworzenia kolejki w usłudze kolejkowania komunikatów.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend

Pobiera lub ustawia wartości właściwości komunikatów, które mają być używane domyślnie, gdy aplikacja wysyła komunikaty do kolejki.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive

Pobiera lub ustawia wartość wskazującą, czy ten MessageQueue ma wyłączny dostęp do odbierania komunikatów z kolejki usługi kolejkowania komunikatów.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode

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

(Odziedziczone po Component)
EnableConnectionCache

Pobiera lub ustawia wartość wskazującą, czy pamięć podręczna połączeń będzie obsługiwana przez aplikację.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired

Pobiera lub ustawia wartość wskazującą, czy kolejka akceptuje tylko nieprywatne (nieszyfrowane) komunikaty.Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events

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

(Odziedziczone po Component)
FormatName

Pobiera unikatową nazwę kolejki, która jest generowana przez usługę kolejkowania komunikatów w momencie tworzenia kolejki.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter

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

Id

Pobiera unikatowy identyfikator usługi kolejkowania komunikatów w kolejce.Gets the unique Message Queuing identifier of the queue.

Label

Pobiera lub ustawia opis kolejki.Gets or sets the queue description.

LastModifyTime

Pobiera czas ostatniej modyfikacji właściwości kolejki.Gets the last time the properties of a queue were modified.

MachineName

Pobiera lub ustawia nazwę komputera, na którym znajduje się kolejka usługi kolejkowania komunikatów.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize

Pobiera lub ustawia maksymalny rozmiar kolejki dziennika.Gets or sets the maximum size of the journal queue.

MaximumQueueSize

Pobiera lub ustawia maksymalny rozmiar kolejki.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter

Pobiera lub ustawia filtr właściwości na potrzeby otrzymywania lub wglądu w wiadomości.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Pobiera lub ustawia adres multiemisji skojarzony z kolejką.Gets or sets the multicast address associated with the queue.

Path

Pobiera lub ustawia ścieżkę kolejki.Gets or sets the queue's path. Ustawienie Path powoduje, że MessageQueue wskazują nową kolejkę.Setting the Path causes the MessageQueue to point to a new queue.

QueueName

Pobiera lub ustawia przyjazną nazwę, która identyfikuje kolejkę.Gets or sets the friendly name that identifies the queue.

ReadHandle

Pobiera natywny uchwyt używany do odczytywania wiadomości z kolejki komunikatów.Gets the native handle used to read messages from the message queue.

Site

Pobiera lub ustawia ISite Component.Gets or sets the ISite of the Component.

(Odziedziczone po Component)
SynchronizingObject

Pobiera lub ustawia obiekt, który kierujący wywołanie procedury obsługi zdarzeń, wynikający ze zdarzenia ReceiveCompleted lub PeekCompleted.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional

Pobiera wartość wskazującą, czy kolejka akceptuje tylko transakcje.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue

Pobiera lub ustawia wartość wskazującą, czy odebrane komunikaty są kopiowane do kolejki dziennika.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle

Pobiera uchwyt macierzysty używany do wysyłania komunikatów do kolejki komunikatów.Gets the native handle used to send messages to the message queue.

Metody

BeginPeek()

Inicjuje asynchroniczną operację wglądu, która nie ma limitu czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i używa określonego kursora, określonej akcji wglądu i określonego obiektu stanu.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. Obiekt State zawiera powiązane informacje w okresie istnienia operacji.The state object provides associated information throughout the lifetime of the operation. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt State, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt State, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive()

Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i używa określonego kursora i określonego obiektu stanu.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. Obiekt State zawiera powiązane informacje w okresie istnienia operacji.The state object provides associated information throughout the lifetime of the operation. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback)

Inicjuje asynchroniczne operacje odbierania z określonym limitem czasu i określonym obiektem stanu, który zawiera skojarzone informacje w okresie istnienia operacji.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. To Przeciążenie odbiera powiadomienie przy użyciu wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji.This overload receives notification, through a callback, of the identity of the event handler for the operation. Operacja nie zostanie zakończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

ClearConnectionCache()

Czyści pamięć podręczną połączeń.Clears the connection cache.

Close()

Zwalnia wszystkie zasoby przydzielone przez MessageQueue.Frees all resources allocated by the MessageQueue.

Create(String)

Tworzy nietransakcyjną kolejkę kolejkowania komunikatów w określonej ścieżce.Creates a non-transactional Message Queuing queue at the specified path.

Create(String, Boolean)

Tworzy transakcyjną lub nietransakcyjną kolejkę kolejkowania komunikatów w określonej ścieżce.Creates a transactional or non-transactional Message Queuing queue at the specified path.

CreateCursor()

Tworzy nowy Cursor dla bieżącej kolejki komunikatów.Creates a new Cursor for the current message queue.

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)
Delete(String)

Usuwa kolejkę na serwerze usługi kolejkowania komunikatów.Deletes a queue on a Message Queuing server.

Dispose()

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

(Odziedziczone po Component)
Dispose(Boolean)

Usuwa zasoby (inne niż pamięć) używane przez MessageQueue.Disposes of the resources (other than memory) used by the MessageQueue.

EndPeek(IAsyncResult)

Kończy określoną asynchroniczną operację wglądu.Completes the specified asynchronous peek operation.

EndReceive(IAsyncResult)

Kończy określoną asynchroniczną operację odbierania.Completes the specified asynchronous receive operation.

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)
Exists(String)

Określa, czy kolejka usługi kolejkowania komunikatów istnieje w określonej ścieżce.Determines whether a Message Queuing queue exists at the specified path.

GetAllMessages()

Zwraca wszystkie komunikaty znajdujące się w kolejce.Returns all the messages that are in the queue.

GetEnumerator()

Wylicza komunikaty w kolejce.Enumerates the messages in a queue. GetEnumerator() jest przestarzały.GetEnumerator() is deprecated. Zamiast tego należy użyć GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetHashCode()

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

(Odziedziczone po Object)
GetLifetimeService()

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)
GetMachineId(String)

Pobiera identyfikator komputera, na którym znajduje się kolejka, do której odwołuje się ten MessageQueue.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

GetMessageEnumerator()

Tworzy obiekt modułu wyliczającego dla wszystkich komunikatów w kolejce.Creates an enumerator object for all the messages in the queue. GetMessageEnumerator() jest przestarzały.GetMessageEnumerator() is deprecated. Zamiast tego należy użyć GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetMessageEnumerator2()

Tworzy obiekt modułu wyliczającego dla wszystkich komunikatów w kolejce.Creates an enumerator object for all the messages in the queue.

GetMessageQueueEnumerator()

Zapewnia semantykę kursora tylko do przodu, aby wyliczyć wszystkie kolejki publiczne w sieci.Provides forward-only cursor semantics to enumerate through all public queues on the network.

GetMessageQueueEnumerator(MessageQueueCriteria)

Zapewnia semantykę kursora tylko do przodu, aby wyliczyć wszystkie kolejki publiczne w sieci spełniające określone kryteria.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String)

Pobiera wszystkie kolejki prywatne na określonym komputerze.Retrieves all the private queues on the specified computer.

GetPublicQueues()

Pobiera wszystkie kolejki publiczne w sieci.Retrieves all the public queues on the network.

GetPublicQueues(MessageQueueCriteria)

Pobiera wszystkie kolejki publiczne w sieci spełniające określone kryteria.Retrieves all the public queues on the network that meet the specified criteria.

GetPublicQueuesByCategory(Guid)

Pobiera wszystkie kolejki publiczne w sieci należące do określonej kategorii.Retrieves all the public queues on the network that belong to the specified category.

GetPublicQueuesByLabel(String)

Pobiera wszystkie kolejki publiczne w sieci, które zawierają określoną etykietę.Retrieves all the public queues on the network that carry the specified label.

GetPublicQueuesByMachine(String)

Pobiera wszystkie kolejki publiczne, które znajdują się na określonym komputerze.Retrieves all the public queues that reside on the specified computer.

GetSecurityContext()

Pobiera kontekst zabezpieczeń, który usługa MSMQ kojarzy z bieżącym użytkownikiem (tożsamość wątku) w czasie tego wywołania.Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type)

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

(Odziedziczone po Component)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()

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 Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

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

(Odziedziczone po MarshalByRefObject)
Peek()

Zwraca bez usuwania (wglądu) pierwszy komunikat w kolejce, do którego odwołuje się ten MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu, gdy wiadomość nie zostanie udostępniona.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

Peek(TimeSpan)

Zwraca bez usuwania (wglądu) pierwszy komunikat w kolejce, do którego odwołuje się ten MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub określonego limitu czasu.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

Peek(TimeSpan, Cursor, PeekAction)

Zwraca bez usuwania (wglądu) bieżącą lub następną wiadomość w kolejce przy użyciu określonego kursora.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub określonego limitu czasu.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

PeekByCorrelationId(String)

Wgląd w komunikat, który pasuje do podanego identyfikatora korelacji, i natychmiast wywołuje wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

PeekByCorrelationId(String, TimeSpan)

Wgląd w komunikat, który odpowiada danemu identyfikatorowi korelacji i czeka, aż komunikat o określonym identyfikatorze korelacji jest dostępny w kolejce lub limit czasu wygaśnie.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String)

Wgląd w komunikat, którego identyfikator wiadomości pasuje do parametru id.Peeks the message whose message identifier matches the id parameter.

PeekById(String, TimeSpan)

Wgląd w komunikat, którego identyfikator wiadomości pasuje do parametru id.Peeks the message whose message identifier matches the id parameter. Czeka, aż komunikat pojawi się w kolejce lub przekroczy limit czasu.Waits until the message appears in the queue or a time-out occurs.

PeekByLookupId(Int64)

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Wgląd w komunikat, który pasuje do podanego identyfikatora wyszukiwania z kolejki nietransakcyjnej.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64)

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Dokonuje wglądu w określoną wiadomość z kolejki.Peeks at a specific message from the queue. Komunikat może być określony przez identyfikator wyszukiwania lub przez jego pozycję na wierzchu lub na końcu kolejki.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge()

Usuwa wszystkie komunikaty znajdujące się w kolejce.Deletes all the messages contained in the queue.

Receive()

Odbiera pierwszą wiadomość dostępną w kolejce, do której odwołuje się MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania, dopóki komunikat nie będzie dostępny.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction)

Odbiera pierwszą wiadomość dostępną w kolejce transakcyjnej, do której odwołuje się MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania, dopóki komunikat nie będzie dostępny.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType)

Odbiera pierwszą wiadomość dostępną w kolejce, do której odwołuje się MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania, dopóki komunikat nie będzie dostępny.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan)

Odbiera pierwszą wiadomość dostępną w kolejce, do której odwołuje się MessageQueue i czeka, aż do momentu udostępnienia komunikatu w kolejce lub upływu limitu czasu.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor)

Odbiera bieżącą wiadomość w kolejce przy użyciu określonego kursora.Receives the current message in the queue, using a specified cursor. Jeśli żaden komunikat nie jest dostępny, ta metoda czeka, aż wiadomość zostanie udostępniona lub limit czasu wygaśnie.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Odbiera bieżącą wiadomość w kolejce przy użyciu określonego kursora.Receives the current message in the queue, using a specified cursor. Jeśli żaden komunikat nie jest dostępny, ta metoda czeka, aż wiadomość zostanie udostępniona lub limit czasu wygaśnie.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Odbiera bieżącą wiadomość w kolejce przy użyciu określonego kursora.Receives the current message in the queue, using a specified cursor. Jeśli żaden komunikat nie jest dostępny, ta metoda czeka, aż wiadomość zostanie udostępniona lub limit czasu wygaśnie.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction)

Odbiera pierwszy komunikat dostępny w kolejce transakcyjnej, do której odwołuje się MessageQueue i czeka, aż do momentu udostępnienia komunikatu w kolejce lub upływu limitu czasu.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType)

Odbiera pierwszą wiadomość dostępną w kolejce, do której odwołuje się MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. To wywołanie jest synchroniczne i czeka, aż do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String)

Odbiera komunikat, który pasuje do podanego identyfikatora korelacji (z kolejki nietransakcyjnej) i natychmiast wywołuje wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransaction)

Odbiera komunikat pasujący do podanego identyfikatora korelacji (z kolejki transakcyjnej) i natychmiast wywołuje wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransactionType)

Odbiera komunikat pasujący do podanego identyfikatora korelacji i natychmiast wywołuje wyjątek, jeśli w kolejce nie istnieje komunikat o określonym identyfikatorze korelacji.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, TimeSpan)

Odbiera komunikat pasujący do podanego identyfikatora korelacji (z kolejki nietransakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji jest dostępny w kolejce lub limit czasu wygaśnie.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

Odbiera komunikat pasujący do podanego identyfikatora korelacji (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji jest dostępny w kolejce lub limit czasu wygaśnie.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

Odbiera komunikat pasujący do podanego identyfikatora korelacji i czeka, aż komunikat o określonym identyfikatorze korelacji jest dostępny w kolejce lub limit czasu wygaśnie.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveById(String)

Odbiera komunikat pasujący do podanego identyfikatora z kolejki nietransakcyjnej i natychmiast wywołuje wyjątek, jeśli żaden komunikat o określonym identyfikatorze nie istnieje w kolejce.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransaction)

Odbiera komunikat pasujący do podanego identyfikatora (z kolejki transakcyjnej) i natychmiast wywołuje wyjątek, jeśli żaden komunikat o określonym identyfikatorze nie istnieje w kolejce.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransactionType)

Odbiera komunikat, który pasuje do podanego identyfikatora, i natychmiast wywołuje wyjątek, jeśli żaden komunikat o określonym identyfikatorze nie istnieje w kolejce.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, TimeSpan)

Odbiera komunikat pasujący do podanego identyfikatora (z kolejki nietransakcyjnej) i czeka, aż komunikat o określonym identyfikatorze jest dostępny w kolejce lub upłynie limit czasu.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransaction)

Odbiera komunikat pasujący do podanego identyfikatora (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze jest dostępny w kolejce lub upłynie limit czasu.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransactionType)

Odbiera komunikat pasujący do podanego identyfikatora i czeka, aż komunikat o określonym identyfikatorze jest dostępny w kolejce lub limit czasu wygaśnie.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64)

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Odbiera komunikat pasujący do podanego identyfikatora wyszukiwania z kolejki nietransakcyjnej.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Odbiera określoną wiadomość z kolejki transakcyjnej.Receives a specific message from a transactional queue. Komunikat może być określony przez identyfikator wyszukiwania lub przez jego pozycję na wierzchu lub na końcu kolejki.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

Wprowadzone w usłudze MSMQ 3,0.Introduced in MSMQ 3.0. Odbiera określoną wiadomość z kolejki przy użyciu określonego kontekstu transakcji.Receives a specific message from the queue, using the specified transaction context. Komunikat może być określony przez identyfikator wyszukiwania lub przez jego pozycję na wierzchu lub na końcu kolejki.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh()

Odświeża właściwości przedstawione przez MessageQueue w celu odzwierciedlenia bieżącego stanu zasobu.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

ResetPermissions()

Resetuje listę uprawnień do wartości domyślnych systemu operacyjnego.Resets the permission list to the operating system's default values. Usuwa wszystkie uprawnienia do kolejki, które zostały dołączone do listy domyślnej.Removes any queue permissions you have appended to the default list.

Send(Object)

Wysyła obiekt do kolejki nietransakcyjnej, do której odwołuje się ten MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction)

Wysyła obiekt do kolejki transakcyjnej, do której odwołuje się ten MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType)

Wysyła obiekt do kolejki, do której odwołuje się ten MessageQueue.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String)

Wysyła obiekt do kolejki nietransakcyjnej, do której odwołuje się ten MessageQueue i określa etykietę wiadomości.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction)

Wysyła obiekt do kolejki transakcyjnej, do której odwołuje się ten MessageQueue i określa etykietę wiadomości.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType)

Wysyła obiekt do kolejki, do której odwołuje się ten MessageQueue i określa etykietę wiadomości.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

SetPermissions(AccessControlList)

Przypisuje prawa dostępu do kolejki w oparciu o zawartość listy kontroli dostępu.Assigns access rights to the queue based on the contents of an access control list.

SetPermissions(MessageQueueAccessControlEntry)

Przypisuje prawa dostępu do kolejki na podstawie zawartości wpisu kontroli dostępu.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights)

Przyznaje komputerowi, grupie lub użytkownikowi określone prawa dostępu.Gives a computer, group, or user the specified access rights.

SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)

Przyznaje komputerowi, grupie lub użytkownikowi określone prawa dostępu, z określonym typem kontroli dostępu (Zezwalaj, Odmów, odwoływania lub ustawiania).Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString()

Zwraca String zawierający 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 metody Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Odziedziczone po Component)
PeekCompleted

Występuje, gdy komunikat zostanie odczytany bez usuwania z kolejki.Occurs when a message is read without being removed from the queue. Jest to wynik operacji asynchronicznej, BeginPeek().This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted

Występuje, gdy wiadomość została usunięta z kolejki.Occurs when a message has been removed from the queue. To zdarzenie jest wywoływane przez operację asynchroniczną, BeginReceive().This event is raised by the asynchronous operation, BeginReceive().

Metody rozszerzania

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konwertuje IEnumerable na IQueryable.Converts an IEnumerable to an IQueryable.

Dotyczy

Bezpieczeństwo wątkowe

Tylko Metoda GetAllMessages() jest bezpieczna wątkowo.Only the GetAllMessages() method is thread safe.

Zobacz też