MessageQueue Klasa

Definicja

Przestrzeń nazw:

System.Messaging

Zestaw:

System.Messaging.dll

Zapewnia dostęp do kolejki na serwerze kolejkowania komunikatów.

public ref 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

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

Public Class MessageQueue
Inherits Component
Implements IEnumerable

Dziedziczenie

Object

MarshalByRefObject

Component

MessageQueue

Atrybuty

TypeConverterAttribute MessagingDescriptionAttribute

Implementuje

IEnumerable

Przykłady

Poniższy przykład kodu tworzy nowe MessageQueue obiekty przy użyciu różnych typów składni nazw ścieżek. W każdym przypadku wysyła komunikat do kolejki, której ścieżka jest zdefiniowana w konstruktorze.

#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.

#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 heterogenicznymi sieciami i systemami, które mogą być tymczasowo w trybie offline. Aplikacje wysyłają, odbierają lub podglądu (odczytu bez usuwania) komunikatów z kolejek. Kolejkowanie komunikatów jest opcjonalnym składnikiem systemu Windows 2000 i Windows NT i musi być zainstalowany oddzielnie.

Klasa MessageQueue jest otoką wokół kolejkowania komunikatów. Istnieje wiele wersji kolejkowania komunikatów, a użycie MessageQueue klasy może spowodować nieco inne zachowanie w zależności od używanego systemu operacyjnego.

Klasa MessageQueue zawiera odwołanie do kolejki kolejkowania komunikatów. Możesz określić ścieżkę w konstruktorze MessageQueue , aby nawiązać połączenie z istniejącym zasobem, lub utworzyć nową kolejkę na serwerze. Przed wywołaniem Send(Object)metody , Peeklub Receivenależy skojarzyć nowe wystąpienie MessageQueue klasy z istniejącą kolejką. W tym momencie można manipulować właściwościami kolejki, takimi jak Category i Label.

MessageQueue Obsługuje dwa typy pobierania komunikatów: synchroniczne i asynchroniczne. Metody synchroniczne i Receive, powodują, Peek że wątek procesu czeka określony interwał czasu na nadejście nowego komunikatu do kolejki. Metody BeginPeek asynchroniczne i BeginReceiveumożliwiają kontynuowanie głównych zadań aplikacji w osobnym wątku do momentu nadejścia komunikatu do kolejki. Te metody działają przy użyciu obiektów wywołania zwrotnego i obiektów stanu w celu komunikowania informacji między wątkami.

Podczas tworzenia nowego wystąpienia MessageQueue klasy nie tworzysz nowej kolejki kolejki kolejkowania komunikatów. Zamiast tego można użyć Create(String)metod , Delete(String)i Purge do zarządzania kolejkami na serwerze.

W przeciwieństwie do Purgeelementów i Create(String)Delete(String) są static elementami członkowskimi, więc można je wywołać bez tworzenia nowego wystąpienia MessageQueue klasy.

Właściwość obiektu można ustawić MessageQueue z jedną z trzech nazw: przyjazną nazwą, FormatName, lub Label.Path Przyjazna nazwa, która jest definiowana MachineName przez właściwości i QueueName kolejki, jest\MachineNameQueueName dla kolejki publicznej iQueueNameMachineName\Private$\dla kolejki prywatnej. Właściwość FormatName umożliwia dostęp w trybie offline do kolejek komunikatów. Na koniec możesz użyć właściwości kolejkiLabel, aby ustawić kolejkę .Path

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia MessageQueueklasy , zobacz MessageQueue konstruktor.

Konstruktory

MessageQueue()	Inicjuje nowe wystąpienie klasy MessageQueue. Gdy konstruktor bez parametrów inicjuje nowe wystąpienie, należy ustawić właściwość wystąpienia Path przed użyciem wystąpienia.
MessageQueue(String)	Inicjuje MessageQueue nowe wystąpienie klasy odwołującej się do kolejki kolejki kolejkowania komunikatów w określonej ścieżce.
MessageQueue(String, Boolean)	Inicjuje nowe wystąpienie MessageQueue klasy, które odwołuje się do kolejki kolejki kolejki komunikatów w określonej ścieżce i z określonym ograniczeniem dostępu do odczytu.
MessageQueue(String, Boolean, Boolean)	Inicjuje nowe wystąpienie klasy MessageQueue.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicjuje nowe wystąpienie klasy MessageQueue.
MessageQueue(String, QueueAccessMode)	Inicjuje nowe wystąpienie klasy MessageQueue.

Pola

InfiniteQueueSize	Określa, że nie istnieje ograniczenie rozmiaru dla kolejki.
InfiniteTimeout	Określa, że nie istnieje limit czasu dla metod, które podejrzyją lub odbierają komunikaty.

Właściwości

AccessMode	Pobiera wartość wskazującą tryb dostępu dla kolejki.
Authenticate	Pobiera lub ustawia wartość wskazującą, czy kolejka akceptuje tylko uwierzytelnione komunikaty.
BasePriority	Pobiera lub ustawia podstawowy priorytet usługi kolejkowania komunikatów używanych do kierowania komunikatów kolejki publicznej za pośrednictwem sieci.
CanRaiseEvents	Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie. (Odziedziczone po Component)
CanRead	Pobiera wartość wskazującą, czy MessageQueue można go odczytać.
CanWrite	Pobiera wartość wskazującą, czy MessageQueue element można zapisać.
Category	Pobiera lub ustawia kategorię kolejki.
Container	Pobiera element IContainer zawierający element Component. (Odziedziczone po Component)
CreateTime	Pobiera godzinę i datę utworzenia kolejki w kolejce komunikatów.
DefaultPropertiesToSend	Pobiera lub ustawia wartości właściwości komunikatu, które mają być używane domyślnie, gdy aplikacja wysyła komunikaty do kolejki.
DenySharedReceive	Pobiera lub ustawia wartość wskazującą, czy ma on MessageQueue wyłączny dostęp do odbierania komunikatów z kolejki kolejkowania komunikatów.
DesignMode	Pobiera wartość wskazującą, czy Component element jest obecnie w trybie projektowania. (Odziedziczone po Component)
EnableConnectionCache	Pobiera lub ustawia wartość wskazującą, czy pamięć podręczna połączeń będzie utrzymywana przez aplikację.
EncryptionRequired	Pobiera lub ustawia wartość wskazującą, czy kolejka akceptuje tylko komunikaty inne niż prywatne (niezaszyfrowane).
Events	Pobiera listę programów obsługi zdarzeń dołączonych do tego Componentelementu . (Odziedziczone po Component)
FormatName	Pobiera unikatową nazwę kolejki, która jest generowana przez kolejkę w momencie tworzenia kolejki.
Formatter	Pobiera lub ustawia formater używany do serializacji obiektu do lub deserializacji obiektu z treści komunikatu odczytanego lub zapisanego w kolejce.
Id	Pobiera unikatowy identyfikator kolejkowania komunikatów.
Label	Pobiera lub ustawia opis kolejki.
LastModifyTime	Pobiera ostatni raz właściwości kolejki zostały zmodyfikowane.
MachineName	Pobiera lub ustawia nazwę komputera, na którym znajduje się kolejka kolejki komunikatów.
MaximumJournalSize	Pobiera lub ustawia maksymalny rozmiar kolejki dziennika.
MaximumQueueSize	Pobiera lub ustawia maksymalny rozmiar kolejki.
MessageReadPropertyFilter	Pobiera lub ustawia filtr właściwości do odbierania lub podglądu komunikatów.
MulticastAddress	Wprowadzono w programie MSMQ 3.0. Pobiera lub ustawia adres multiemisji skojarzony z kolejką.
Path	Pobiera lub ustawia ścieżkę kolejki. Path Ustawianie przyczyn MessageQueue wskazywania nowej kolejki.
QueueName	Pobiera lub ustawia przyjazną nazwę identyfikującą kolejkę.
ReadHandle	Pobiera natywny uchwyt używany do odczytywania komunikatów z kolejki komunikatów.
Site	Pobiera lub ustawia wartość ISite .Component (Odziedziczone po Component)
SynchronizingObject	Pobiera lub ustawia obiekt, który marshalsuje wywołanie procedury obsługi zdarzeń wynikające z zdarzenia ReceiveCompleted lub PeekCompleted .
Transactional	Pobiera wartość wskazującą, czy kolejka akceptuje tylko transakcje.
UseJournalQueue	Pobiera lub ustawia wartość wskazującą, czy odebrane komunikaty są kopiowane do kolejki dziennika.
WriteHandle	Pobiera natywny uchwyt używany do wysyłania komunikatów do kolejki komunikatów.

Metody

BeginPeek()	Inicjuje asynchroniczną operację wglądu, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.
BeginPeek(TimeSpan)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i która używa określonego kursora, określonej akcji podglądu i określonego obiektu stanu. Obiekt stanu dostarcza skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek(TimeSpan, Object)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w okresie istnienia operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicjuje asynchroniczną operację wglądu, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginReceive()	Inicjuje asynchroniczną operację odbierania, która nie ma limitu czasu. Operacja nie zostanie ukończona, dopóki komunikat nie stanie się dostępny w kolejce.
BeginReceive(TimeSpan)	Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
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. Obiekt stanu dostarcza skojarzone informacje przez cały okres istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginReceive(TimeSpan, Object)	Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicjuje asynchroniczną operację odbierania, która ma określony limit czasu i określony obiekt stanu, który dostarcza skojarzone informacje w całym okresie istnienia operacji. To przeciążenie odbiera powiadomienie za pośrednictwem wywołania zwrotnego tożsamości programu obsługi zdarzeń dla operacji. Operacja nie zostanie ukończona do momentu udostępnienia komunikatu w kolejce lub przekroczenia limitu czasu.
ClearConnectionCache()	Czyści pamięć podręczną połączeń.
Close()	Zwalnia wszystkie zasoby przydzielone przez element MessageQueue.
Create(String)	Tworzy kolejkę kolejki kolejkowania komunikatów nie transakcyjnych w określonej ścieżce.
Create(String, Boolean)	Tworzy transakcyjną lub nie transakcyjną kolejkę kolejkowania komunikatów w określonej ścieżce.
CreateCursor()	Tworzy nowy Cursor dla bieżącej kolejki komunikatów.
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
Delete(String)	Usuwa kolejkę na serwerze kolejkowania komunikatów.
Dispose()	Zwalnia wszelkie zasoby używane przez element Component. (Odziedziczone po Component)
Dispose(Boolean)	Usuwa zasoby (inne niż pamięć) używane przez program MessageQueue.
EndPeek(IAsyncResult)	Kończy określoną operację asynchronicznego wglądu.
EndReceive(IAsyncResult)	Kończy określoną asynchroniczną operację odbierania.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Exists(String)	Określa, czy kolejka kolejki kolejkowania komunikatów istnieje w określonej ścieżce.
GetAllMessages()	Zwraca wszystkie komunikaty, które znajdują się w kolejce.
GetEnumerator()	Przestarzałe. Wylicza komunikaty w kolejce. GetEnumerator() jest przestarzały. GetMessageEnumerator2() Zamiast tego należy użyć polecenia .
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetMachineId(String)	Pobiera identyfikator komputera, na którym znajduje się kolejka, do której odwołuje się ta MessageQueue kolejka.
GetMessageEnumerator()	Przestarzałe. Tworzy obiekt modułu wyliczającego dla wszystkich komunikatów w kolejce. GetMessageEnumerator() jest przestarzały. GetMessageEnumerator2() Zamiast tego należy użyć polecenia .
GetMessageEnumerator2()	Tworzy obiekt modułu wyliczającego dla wszystkich komunikatów w kolejce.
GetMessageQueueEnumerator()	Zapewnia semantyka kursorów tylko do przekazywania do wyliczania za pośrednictwem wszystkich kolejek publicznych w sieci.
GetMessageQueueEnumerator(MessageQueueCriteria)	Udostępnia semantyka kursorów tylko do przekazywania do wyliczania za pośrednictwem wszystkich kolejek publicznych w sieci, które spełniają określone kryteria.
GetPrivateQueuesByMachine(String)	Pobiera wszystkie kolejki prywatne na określonym komputerze.
GetPublicQueues()	Pobiera wszystkie kolejki publiczne w sieci.
GetPublicQueues(MessageQueueCriteria)	Pobiera wszystkie kolejki publiczne w sieci, które spełniają określone kryteria.
GetPublicQueuesByCategory(Guid)	Pobiera wszystkie kolejki publiczne w sieci, które należą do określonej kategorii.
GetPublicQueuesByLabel(String)	Pobiera wszystkie kolejki publiczne w sieci, które mają określoną etykietę.
GetPublicQueuesByMachine(String)	Pobiera wszystkie kolejki publiczne, które znajdują się na określonym komputerze.
GetSecurityContext()	Pobiera kontekst zabezpieczeń skojarzony przez usługę MSMQ z bieżącym użytkownikiem (tożsamością wątku) w momencie tego wywołania.
GetService(Type)	Zwraca obiekt, który reprezentuje usługę dostarczaną przez Component obiekt lub przez element Container. (Odziedziczone po Component)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
Peek()	Zwraca wartość bez usuwania (zobacz) pierwszy komunikat w kolejce, do której odwołuje się ten MessageQueueelement . Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu.
Peek(TimeSpan)	Zwraca wartość bez usuwania (zobacz) pierwszy komunikat w kolejce, do której odwołuje się ten MessageQueueelement . Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub przekroczenia określonego limitu czasu.
Peek(TimeSpan, Cursor, PeekAction)	Zwraca wartość bez usuwania (wglądu) bieżącego lub następnego komunikatu w kolejce przy użyciu określonego kursora. Metoda Peek() jest synchroniczna, dlatego blokuje bieżący wątek do momentu udostępnienia komunikatu lub przekroczenia określonego limitu czasu.
PeekByCorrelationId(String)	Wyświetla komunikat zgodny z danym identyfikatorem korelacji i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
PeekByCorrelationId(String, TimeSpan)	Wyjrzy komunikat zgodny z danym identyfikatorem korelacji i czeka, aż komunikat z określonym identyfikatorem korelacji będzie dostępny w kolejce lub limit czasu wygasa.
PeekById(String)	Wyświetla komunikat, którego identyfikator komunikatu jest zgodny z parametrem id .
PeekById(String, TimeSpan)	Wyświetla komunikat, którego identyfikator komunikatu jest zgodny z parametrem id . Czeka na wyświetlenie komunikatu w kolejce lub przekroczenie limitu czasu.
PeekByLookupId(Int64)	Wprowadzono w programie MSMQ 3.0. Przyjrzyj się komunikatowi zgodnego z danym identyfikatorem odnośnika z kolejki nie transakcyjnej.
PeekByLookupId(MessageLookupAction, Int64)	Wprowadzono w programie MSMQ 3.0. Przyjrzyj się konkretnego komunikatu z kolejki. Komunikat może być określony przez identyfikator odnośnika lub jego położenie na początku lub na końcu kolejki.
Purge()	Usuwa wszystkie komunikaty zawarte w kolejce.
Receive()	Odbiera pierwszy komunikat dostępny w kolejce, do której MessageQueueodwołuje się element . To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania do momentu udostępnienia komunikatu.
Receive(MessageQueueTransaction)	Odbiera pierwszy komunikat dostępny w kolejce transakcyjnej, do której odwołuje się element MessageQueue. To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania do momentu udostępnienia komunikatu.
Receive(MessageQueueTransactionType)	Odbiera pierwszy komunikat dostępny w kolejce, do której MessageQueueodwołuje się element . To wywołanie jest synchroniczne i blokuje bieżący wątek wykonywania do momentu udostępnienia komunikatu.
Receive(TimeSpan)	Odbiera pierwszy komunikat dostępny w kolejce, do której odwołuje się MessageQueue element i czeka, aż komunikat będzie dostępny w kolejce lub upłynął limit czasu.
Receive(TimeSpan, Cursor)	Odbiera bieżący komunikat w kolejce przy użyciu określonego kursora. Jeśli komunikat nie jest dostępny, ta metoda czeka, aż komunikat będzie dostępny lub limit czasu wygaśnie.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Odbiera bieżący komunikat w kolejce przy użyciu określonego kursora. Jeśli komunikat nie jest dostępny, ta metoda czeka, aż komunikat będzie dostępny lub limit czasu wygaśnie.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Odbiera bieżący komunikat w kolejce przy użyciu określonego kursora. Jeśli komunikat nie jest dostępny, ta metoda czeka, aż komunikat będzie dostępny lub limit czasu wygaśnie.
Receive(TimeSpan, MessageQueueTransaction)	Odbiera pierwszy komunikat dostępny w kolejce transakcyjnej, do której odwołuje się MessageQueue element i czeka, aż komunikat będzie dostępny w kolejce lub limit czasu wygaśnie.
Receive(TimeSpan, MessageQueueTransactionType)	Odbiera pierwszy komunikat dostępny w kolejce, do której MessageQueueodwołuje się element . To wywołanie jest synchroniczne i czeka na dostępność komunikatu w kolejce lub wygaśnięcie limitu czasu.
ReceiveByCorrelationId(String)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki nie transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem korelacji i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze korelacji.
ReceiveByCorrelationId(String, TimeSpan)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki nie transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem korelacji (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub limit czasu wygasa.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem korelacji i czeka, aż komunikat o określonym identyfikatorze korelacji będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveById(String)	Odbiera komunikat zgodny z danym identyfikatorem z kolejki nie transakcyjnej i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze.
ReceiveById(String, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem (z kolejki transakcyjnej) i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze.
ReceiveById(String, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem i natychmiast zgłasza wyjątek, jeśli w kolejce nie istnieje żaden komunikat o określonym identyfikatorze.
ReceiveById(String, TimeSpan)	Odbiera komunikat zgodny z danym identyfikatorem (z kolejki nie transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Odbiera komunikat zgodny z danym identyfikatorem (z kolejki transakcyjnej) i czeka, aż komunikat o określonym identyfikatorze będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Odbiera komunikat zgodny z danym identyfikatorem i czeka, aż komunikat o określonym identyfikatorze będzie dostępny w kolejce lub upłynął limit czasu.
ReceiveByLookupId(Int64)	Wprowadzono w programie MSMQ 3.0. Odbiera komunikat zgodny z danym identyfikatorem odnośnika z kolejki nie transakcyjnej.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Wprowadzono w programie MSMQ 3.0. Odbiera określony komunikat z kolejki transakcyjnej. Komunikat może być określony przez identyfikator odnośnika lub jego położenie na początku lub na końcu kolejki.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Wprowadzono w programie MSMQ 3.0. Odbiera określony komunikat z kolejki przy użyciu określonego kontekstu transakcji. Komunikat może być określony przez identyfikator odnośnika lub jego położenie na początku lub na końcu kolejki.
Refresh()	Odświeża właściwości przedstawione przez element , MessageQueue aby odzwierciedlić bieżący stan zasobu.
ResetPermissions()	Resetuje listę uprawnień do wartości domyślnych systemu operacyjnego. Usuwa wszystkie uprawnienia kolejki, które zostały dołączone do listy domyślnej.
Send(Object)	Wysyła obiekt do kolejki nie transakcyjnej, do których odwołuje się ten MessageQueueobiekt .
Send(Object, MessageQueueTransaction)	Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ten MessageQueueobiekt .
Send(Object, MessageQueueTransactionType)	Wysyła obiekt do kolejki, do których odwołuje się ten MessageQueueobiekt .
Send(Object, String)	Wysyła obiekt do kolejki nie transakcyjnej, do których odwołuje się ten MessageQueue komunikat, i określa etykietę komunikatu.
Send(Object, String, MessageQueueTransaction)	Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ten MessageQueue komunikat, i określa etykietę komunikatu.
Send(Object, String, MessageQueueTransactionType)	Wysyła obiekt do kolejki, do których odwołuje się ten MessageQueue element, i określa etykietę komunikatu.
SetPermissions(AccessControlList)	Przypisuje prawa dostępu do kolejki na podstawie zawartości listy kontroli dostępu.
SetPermissions(MessageQueueAccessControlEntry)	Przypisuje prawa dostępu do kolejki na podstawie zawartości wpisu kontroli dostępu.
SetPermissions(String, MessageQueueAccessRights)	Nadaje komputerowi, grupie lub użytkownikowi określone prawa dostępu.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Nadaje komputerowi, grupie lub użytkownikowi określone prawa dostępu z określonym typem kontroli dostępu (zezwalaj, odmów, odwoływanie lub ustawianie).
ToString()	Zwraca wartość String zawierającą nazwę Componentobiektu , jeśli istnieje. Ta metoda nie powinna być zastępowana. (Odziedziczone po Component)

Zdarzenia

Disposed	Występuje, gdy składnik jest usuwany przez wywołanie Dispose() metody . (Odziedziczone po Component)
PeekCompleted	Występuje, gdy komunikat jest odczytywany bez usuwania z kolejki. Jest to wynik operacji asynchronicznej , BeginPeek().
ReceiveCompleted	Występuje, gdy komunikat został usunięty z kolejki. To zdarzenie jest wywoływane przez operację asynchroniczną , BeginReceive().

Metody rozszerzania

Cast<TResult>(IEnumerable)	Rzutuje elementy obiektu IEnumerable na określony typ.
OfType<TResult>(IEnumerable)	Filtruje elementy IEnumerable elementu na podstawie określonego typu.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje element IEnumerable na .IQueryable

Bezpieczeństwo wątkowe

GetAllMessages() Tylko metoda jest bezpieczna wątkiem.

Zobacz też

• Message
• DefaultPropertiesToSend
• MessageQueueException
• MessageQueue()
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()
• Path
• Label
• FormatName
• QueueName
• MachineName