MessageQueue Klasa

Definicja

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))]
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
[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
type MessageQueue = class
    inherit Component
    interface 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
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu tworzy nowe MessageQueue obiekty przy użyciu różnych typów składni nazw ścieżki. 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óżnych momentach komunikację między heterogenicznymi sieciami i systemami, które mogą być tymczasowo w trybie offline. Aplikacje wysyłają, odbierają lub podglądu (odczytywane bez usuwania) komunikaty z kolejek. Kolejkowanie komunikatów to opcjonalny składnik Windows 2000 i Windows NT i musi być zainstalowany oddzielnie.

Klasa MessageQueue jest otoką kolejkowania komunikatów. Istnieje wiele wersji kolejkowania komunikatów i 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 kolejki kolejkowania komunikatów. Możesz określić ścieżkę w konstruktorze MessageQueue w celu nawiązania połączenia z istniejącym zasobem lub utworzyć nową kolejkę na serwerze. Aby można było wywołać metodę Send(Object), Peeklub Receive, należ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 BeginReceive, umożliwiają kontynuowanie głównych zadań aplikacji w osobnym wątku do momentu nadejścia komunikatu w kolejce. 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 Purgeelementu i Create(String) Delete(String)static elementami członkowskimi, dzięki czemu można wywoływać je bez tworzenia nowego wystąpienia MessageQueue klasy.

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

Aby uzyskać listę początkowych wartości właściwości dla wystąpienia programu MessageQueue, 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 MessageQueue nowe wystąpienie klasy odwołującej się do kolejki kolejki kolejkowania 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 dla kolejki nie istnieje żadne ograniczenie rozmiaru.

InfiniteTimeout

Określa, że nie istnieje limit czasu dla metod, które podglądają 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 można je 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 kolejki 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ę, która identyfikuje kolejkę.

ReadHandle

Pobiera natywny uchwyt używany do odczytywania komunikatów z kolejki komunikatów.

Site

Pobiera lub ustawia ISite element .Component

(Odziedziczone po Component)
SynchronizingObject

Pobiera lub ustawia obiekt, który marshaluje 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ę podglą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ę podglą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 używa określonego kursora, określonej akcji podglądu i określonego obiektu stanu. Obiekt stanu udostępnia 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 całym 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 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.

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 usługę MessageQueue.

Create(String)

Tworzy kolejkę kolejki kolejkowania komunikatów innych niż transakcyjne w określonej ścieżce.

Create(String, Boolean)

Tworzy transakcyjną lub nie transakcyjną kolejkę kolejkowania komunikatów w określonej ścieżce.

CreateCursor()

Tworzy nową 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()
Nieaktualne.
Nieaktualne.

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()
Nieaktualne.

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()
Nieaktualne.
Nieaktualne.

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

Udostępnia semantyka kursora tylko do przodu, aby wyliczać wszystkie kolejki publiczne w sieci.

GetMessageQueueEnumerator(MessageQueueCriteria)

Udostępnia semantyka kursora tylko do przodu, aby wyliczać wszystkie kolejki publiczne 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 noszą określoną etykietę.

GetPublicQueuesByMachine(String)

Pobiera wszystkie publiczne kolejki znajdujące się na określonym komputerze.

GetSecurityContext()

Pobiera kontekst zabezpieczeń, który MSMQ kojarzy z bieżącym użytkownikiem (tożsamością wątku) w momencie tego wywołania.

GetService(Type)

Zwraca obiekt reprezentujący usługę dostarczaną przez Component obiekt lub przez obiekt Container.

(Odziedziczone po Component)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

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)

Podgląd komunikatu zgodnego z podanym identyfikatorem korelacji i czeka na udostępnienie komunikatu o określonym identyfikatorze korelacji w kolejce lub upłynięciu limitu czasu.

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. Zapoznaj się z komunikatem zgodnym z danym identyfikatorem odnośnika z kolejki innej niż transakcyjna.

PeekByLookupId(MessageLookupAction, Int64)

Wprowadzono w programie MSMQ 3.0. Przyjrzyj się określonej wiadomości 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 MessageQueueodwołuje się element . 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 na udostępnienie komunikatu lub upłynął limit czasu.

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 udostępnienie komunikatu w kolejce lub przekroczenie 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 podanym identyfikatorem korelacji (z kolejki innej niż transakcyjna) 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 upłynął limit czasu.

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 podanym identyfikatorem z kolejki innej niż transakcyjna 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 podanym identyfikatorem odnośnika z kolejki innej niż transakcyjna.

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 domyślnych wartości systemu operacyjnego. Usuwa wszystkie uprawnienia kolejki, które zostały dołączone do listy domyślnej.

Send(Object)

Wysyła obiekt do kolejki innej niż transakcyjna, 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 innej niż transakcyjna, do których odwołuje się ta MessageQueue funkcja, i określa etykietę komunikatu.

Send(Object, String, MessageQueueTransaction)

Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ta MessageQueue funkcja, 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)

Daje komputer, grupę lub użytkownika 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, odmawiaj, 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 elementu 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

Dotyczy

Bezpieczeństwo wątkowe

GetAllMessages() Tylko metoda jest bezpieczna wątkiem.

Zobacz też