MessageQueue Třída

Definice

Obor názvů:

System.Messaging

Sestavení:

System.Messaging.dll

Poskytuje přístup k frontě na serveru služby Řízení front zpráv.

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

Dědičnost

Object

MarshalByRefObject

Component

MessageQueue

Atributy

TypeConverterAttribute MessagingDescriptionAttribute

Implementuje

IEnumerable

Příklady

Následující příklad kódu vytvoří nové MessageQueue objekty pomocí různých typů syntaxe názvů cest. V každém případě odešle zprávu do fronty, jejíž cesta je definována v konstruktoru.

#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

Následující příklad kódu odešle zprávu do fronty a přijme zprávu z fronty pomocí třídy specifické pro aplikaci s názvem 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

Poznámky

Technologie Řízení front zpráv umožňuje aplikacím spuštěným v různých časech komunikovat napříč heterogenními sítěmi a systémy, které mohou být dočasně offline. Aplikace odesílají, přijímají nebo prohlédnou (čtou bez odebrání) zprávy z front. Služba Řízení front zpráv je volitelná součást systému Windows 2000 a Windows NT a musí být nainstalována samostatně.

Třída MessageQueue je obálkou kolem služby Řízení front zpráv. Existuje více verzí služby Řízení front zpráv a použití MessageQueue třídy může mít za následek mírně odlišné chování v závislosti na používaném operačním systému.

Třída MessageQueue poskytuje odkaz na frontu služby Řízení front zpráv. Můžete zadat cestu v konstruktoru MessageQueue pro připojení k existujícímu prostředku nebo můžete vytvořit novou frontu na serveru. Před voláním Send(Object), Peeknebo Receivemusíte přidružit novou instanci MessageQueue třídy k existující frontě. V tomto okamžiku můžete manipulovat s vlastnostmi fronty, jako Category jsou a Label.

MessageQueue podporuje dva typy načítání zpráv: synchronní a asynchronní. Synchronní metody a Receivezpůsobí, Peek že vlákno procesu čeká v zadaném časovém intervalu, než do fronty dorazí nová zpráva. Asynchronní metody BeginPeek a BeginReceiveumožňují, aby hlavní úlohy aplikace pokračovaly v samostatném vlákně, dokud do fronty nedorazí zpráva. Tyto metody fungují pomocí objektů zpětného volání a stavových objektů ke komunikaci informací mezi vlákny.

Když vytváříte novou instanci MessageQueue třídy, nevytváříte novou frontu služby Řízení front zpráv. Místo toho můžete použít Create(String)metody , Delete(String)a Purge ke správě front na serveru.

Na rozdíl od Purgea Create(String)Delete(String) jsou static členy, takže je můžete volat bez vytvoření nové instance MessageQueue třídy.

Vlastnost objektu MessageQueuePath můžete nastavit s jedním ze tří názvů: popisný název, FormatName, nebo Label. Popisný název, který je definován vlastnostmi a vlastnostmi frontyMachineName, je MachineNameQueueName\určený pro veřejnou frontu a MachineNameQueueName\\Private$pro soukromou frontu.QueueName Vlastnost FormatName umožňuje offline přístup k frontám zpráv. Nakonec můžete použít vlastnost fronty Label k nastavení fronty Path.

Seznam počátečních hodnot vlastností pro instanci MessageQueuenástroje najdete v konstruktoru MessageQueue .

Konstruktory

MessageQueue()	Inicializuje novou instanci MessageQueue třídy. Jakmile konstruktor bez parametrů inicializuje novou instanci, musíte před použitím instance nastavit vlastnost instance Path .
MessageQueue(String)	Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě.
MessageQueue(String, Boolean)	Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě a se zadaným omezením přístupu pro čtení.
MessageQueue(String, Boolean, Boolean)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.

Pole

InfiniteQueueSize	Určuje, že pro frontu neexistuje žádné omezení velikosti.
InfiniteTimeout	Určuje, že neexistuje časový limit pro metody, které zobrazují nebo přijímají zprávy.

Vlastnosti

AccessMode	Získá hodnotu, která označuje režim přístupu pro frontu.
Authenticate	Získá nebo nastaví hodnotu, která označuje, zda fronta přijímá pouze ověřené zprávy.
BasePriority	Získá nebo nastaví základní prioritu řízení front zpráv používá ke směrování zpráv veřejné fronty přes síť.
CanRaiseEvents	Získá hodnotu označující, zda komponenta může vyvolat událost. (Zděděno od Component)
CanRead	Získá hodnotu, která označuje, zda MessageQueue lze číst.
CanWrite	Získá hodnotu, která označuje, zda MessageQueue lze zapisovat do.
Category	Získá nebo nastaví kategorii fronty.
Container	Získá objekt IContainer , který obsahuje Component. (Zděděno od Component)
CreateTime	Získá čas a datum vytvoření fronty v řízení front zpráv.
DefaultPropertiesToSend	Získá nebo nastaví hodnoty vlastnosti zprávy, které mají být použity ve výchozím nastavení, když aplikace odesílá zprávy do fronty.
DenySharedReceive	Získá nebo nastaví hodnotu, která označuje, zda MessageQueue má výhradní přístup k příjmu zpráv z fronty služby Řízení front zpráv.
DesignMode	Získá hodnotu, která označuje, zda je aktuálně v režimu návrhu Component . (Zděděno od Component)
EnableConnectionCache	Získá nebo nastaví hodnotu, která označuje, zda mezipaměť připojení bude udržována aplikace.
EncryptionRequired	Získá nebo nastaví hodnotu, která označuje, zda fronta přijímá pouze ne-soukromé (nešifrované) zprávy.
Events	Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component. (Zděděno od Component)
FormatName	Získá jedinečný název fronty, který služba Řízení front zpráv vygenerovala v době vytvoření fronty.
Formatter	Získá nebo nastaví formátovací modul použitý k serializaci objektu do nebo deserializovat objekt z textu zprávy přečtené nebo zapsané do fronty.
Id	Získá jedinečný identifikátor služby Řízení front zpráv fronty.
Label	Získá nebo nastaví popis fronty.
LastModifyTime	Získá poslední změnu vlastností fronty.
MachineName	Získá nebo nastaví název počítače, kde se nachází fronta služby Řízení front zpráv.
MaximumJournalSize	Získá nebo nastaví maximální velikost fronty deníku.
MaximumQueueSize	Získá nebo nastaví maximální velikost fronty.
MessageReadPropertyFilter	Získá nebo nastaví filtr vlastností pro příjem nebo náhled zpráv.
MulticastAddress	Zavedeno v MSMQ 3.0. Získá nebo nastaví adresu vícesměrového vysílání přidruženou k frontě.
Path	Získá nebo nastaví cestu fronty. Nastavení způsobí Path , že MessageQueue objekt bude odkazovat na novou frontu.
QueueName	Získá nebo nastaví popisný název, který identifikuje frontu.
ReadHandle	Získá nativní popisovač používaný ke čtení zpráv z fronty zpráv.
Site	Získá nebo nastaví ISite hodnotu Component. (Zděděno od Component)
SynchronizingObject	Získá nebo nastaví objekt, který zařazuje volání obslužné rutiny události vyplývající z ReceiveCompleted události nebo PeekCompleted .
Transactional	Získá hodnotu, která označuje, zda fronta přijímá pouze transakce.
UseJournalQueue	Získá nebo nastaví hodnotu, která označuje, zda jsou přijaté zprávy zkopírovány do fronty deníku.
WriteHandle	Získá nativní popisovač používaný k odesílání zpráv do fronty zpráv.

Metody

BeginPeek()	Inicializuje asynchronní operaci náhledu, která nemá žádný časový limit. Operace není dokončena, dokud nebude ve frontě k dispozici zpráva.
BeginPeek(TimeSpan)	Inicializuje asynchronní operaci náhledu, která má zadaný časový limit. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a která používá zadaný kurzor, zadanou akci náhledu a zadaný objekt stavu. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object)	Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní operaci náhledu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive()	Inicializuje asynchronní operaci příjmu, která nemá žádný časový limit. Operace není dokončena, dokud nebude ve frontě k dispozici zpráva.
BeginReceive(TimeSpan)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit a používá zadaný kurzor a zadaný objekt stavu. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit a zadaný objekt stavu, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží prostřednictvím zpětného volání oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud nebude zpráva dostupná ve frontě nebo dokud nedojde k vypršení časového limitu.
ClearConnectionCache()	Vymaže mezipaměť připojení.
Close()	Uvolní všechny prostředky přidělené nástrojem MessageQueue.
Create(String)	Vytvoří neaktuální frontu služby Řízení front zpráv v zadané cestě.
Create(String, Boolean)	Vytvoří transakční nebo neaktuální frontu služby Řízení front zpráv v zadané cestě.
CreateCursor()	Vytvoří nový Cursor pro aktuální frontu zpráv.
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Delete(String)	Odstraní frontu na serveru služby Řízení front zpráv.
Dispose()	Uvolní všechny prostředky používané nástrojem Component. (Zděděno od Component)
Dispose(Boolean)	Odstraní prostředky (jiné než paměť) používané objektem MessageQueue.
EndPeek(IAsyncResult)	Dokončí zadanou asynchronní operaci náhledu.
EndReceive(IAsyncResult)	Dokončí zadanou asynchronní operaci příjmu.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Exists(String)	Určuje, zda fronta služby Řízení front zpráv existuje na zadané cestě.
GetAllMessages()	Vrátí všechny zprávy, které jsou ve frontě.
GetEnumerator()	Zastaralé. Vytvoří výčet zpráv ve frontě. GetEnumerator() je zastaralý. GetMessageEnumerator2() místo toho by měl být použit.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetMachineId(String)	Získá identifikátor počítače, na který se nachází fronta, na kterou odkazuje.MessageQueue
GetMessageEnumerator()	Zastaralé. Vytvoří objekt enumerátoru pro všechny zprávy ve frontě. GetMessageEnumerator() je zastaralý. GetMessageEnumerator2() místo toho by měl být použit.
GetMessageEnumerator2()	Vytvoří objekt enumerátoru pro všechny zprávy ve frontě.
GetMessageQueueEnumerator()	Poskytuje sémantiku kurzoru pouze pro předávání pro výčet všech veřejných front v síti.
GetMessageQueueEnumerator(MessageQueueCriteria)	Poskytuje sémantiku kurzoru pouze pro předávání pro výčet všech veřejných front v síti, které splňují zadaná kritéria.
GetPrivateQueuesByMachine(String)	Načte všechny privátní fronty v zadaném počítači.
GetPublicQueues()	Načte všechny veřejné fronty v síti.
GetPublicQueues(MessageQueueCriteria)	Načte všechny veřejné fronty v síti, které splňují zadaná kritéria.
GetPublicQueuesByCategory(Guid)	Načte všechny veřejné fronty v síti, které patří do zadané kategorie.
GetPublicQueuesByLabel(String)	Načte všechny veřejné fronty v síti, které mají zadaný popisek.
GetPublicQueuesByMachine(String)	Načte všechny veřejné fronty, které se nacházejí v zadaném počítači.
GetSecurityContext()	Načte kontext zabezpečení, který služba MSMQ přidruží k aktuálnímu uživateli (identitě vlákna) v době tohoto volání.
GetService(Type)	Vrátí objekt, který představuje službu poskytovanou objektem Component nebo jejím Containerobjektem . (Zděděno od Component)
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
Peek()	Vrátí bez odebrání (náhled) první zprávy ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva.
Peek(TimeSpan)	Vrátí bez odebrání (náhled) první zprávy ve frontě, na kterou odkazuje .MessageQueue Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo nedojde k zadanému vypršení časového limitu.
Peek(TimeSpan, Cursor, PeekAction)	Vrátí hodnotu bez odebrání (náhled) aktuální nebo další zprávy ve frontě pomocí zadaného kurzoru. Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva nebo nedojde k zadanému vypršení časového limitu.
PeekByCorrelationId(String)	Zobrazí náhled zprávy, která odpovídá danému identifikátoru korelace, a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem korelace.
PeekByCorrelationId(String, TimeSpan)	Zobrazí náhled zprávy, která odpovídá danému identifikátoru korelace, a počká, dokud nebude zpráva se zadaným identifikátorem korelace k dispozici ve frontě nebo dokud časový limit nevyprší.
PeekById(String)	Zobrazí náhled zprávy, jejíž identifikátor zprávy odpovídá parametru id .
PeekById(String, TimeSpan)	Zobrazí náhled zprávy, jejíž identifikátor zprávy odpovídá parametru id . Počká, dokud se zpráva nezobrazí ve frontě nebo nedojde k vypršení časového limitu.
PeekByLookupId(Int64)	Zavedeno v MSMQ 3.0. Zobrazí náhled zprávy, která odpovídá danému identifikátoru vyhledávání z neakční fronty.
PeekByLookupId(MessageLookupAction, Int64)	Zavedeno v MSMQ 3.0. Zobrazí náhled konkrétní zprávy z fronty. Zpráva může být určena vyhledávacím identifikátorem nebo umístěním na začátku nebo na konci fronty.
Purge()	Odstraní všechny zprávy obsažené ve frontě.
Receive()	Obdrží první zprávu dostupnou ve frontě, na kterou MessageQueueodkazuje . Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud není k dispozici zpráva.
Receive(MessageQueueTransaction)	Obdrží první zprávu dostupnou v transakční frontě, na kterou MessageQueueodkazuje . Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud není k dispozici zpráva.
Receive(MessageQueueTransactionType)	Obdrží první zprávu dostupnou ve frontě, na kterou MessageQueueodkazuje . Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud není k dispozici zpráva.
Receive(TimeSpan)	Přijme první zprávu dostupnou ve frontě, na kterou MessageQueue odkazuje, a počká, dokud nebude zpráva ve frontě k dispozici nebo časový limit vyprší.
Receive(TimeSpan, Cursor)	Přijme aktuální zprávu ve frontě pomocí zadaného kurzoru. Pokud není k dispozici žádná zpráva, tato metoda počká, dokud nebude zpráva k dispozici nebo časový limit vyprší.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Přijme aktuální zprávu ve frontě pomocí zadaného kurzoru. Pokud není k dispozici žádná zpráva, tato metoda počká, dokud nebude zpráva k dispozici nebo časový limit vyprší.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Přijme aktuální zprávu ve frontě pomocí zadaného kurzoru. Pokud není k dispozici žádná zpráva, tato metoda počká, dokud nebude zpráva k dispozici nebo časový limit vyprší.
Receive(TimeSpan, MessageQueueTransaction)	Přijme první zprávu dostupnou v transakční frontě, na kterou MessageQueue odkazuje, a počká, dokud nebude zpráva ve frontě k dispozici, nebo dokud nevyprší časový limit.
Receive(TimeSpan, MessageQueueTransactionType)	Obdrží první zprávu dostupnou ve frontě, na kterou MessageQueueodkazuje . Toto volání je synchronní a čeká na dostupnost zprávy ve frontě nebo vypršení časového limitu.
ReceiveByCorrelationId(String)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z neakční fronty), a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem korelace.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z transakční fronty), a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem korelace.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Přijme zprávu, která odpovídá danému identifikátoru korelace, a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem korelace.
ReceiveByCorrelationId(String, TimeSpan)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z neakční fronty), a počká, dokud nebude ve frontě k dispozici zpráva se zadaným identifikátorem korelace nebo časový limit vyprší.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z transakční fronty), a počká, dokud nebude ve frontě k dispozici zpráva se zadaným identifikátorem korelace, nebo časový limit vyprší.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Přijme zprávu, která odpovídá danému identifikátoru korelace, a počká, dokud nebude ve frontě k dispozici zpráva se zadaným identifikátorem korelace nebo časový limit vyprší.
ReceiveById(String)	Přijme zprávu, která odpovídá danému identifikátoru z neakční fronty, a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem.
ReceiveById(String, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru (z transakční fronty), a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem.
ReceiveById(String, MessageQueueTransactionType)	Přijme zprávu, která odpovídá danému identifikátoru, a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem.
ReceiveById(String, TimeSpan)	Přijme zprávu, která odpovídá danému identifikátoru (z neakční fronty), a počká, dokud nebude zpráva se zadaným identifikátorem k dispozici ve frontě nebo časový limit vyprší.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru (z transakční fronty), a počká, dokud nebude ve frontě k dispozici zpráva se zadaným identifikátorem nebo časový limit vyprší.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Přijme zprávu, která odpovídá danému identifikátoru, a počká, dokud nebude zpráva se zadaným identifikátorem k dispozici ve frontě nebo dokud nevyprší časový limit.
ReceiveByLookupId(Int64)	Zavedeno v MSMQ 3.0. Přijme zprávu, která odpovídá danému identifikátoru vyhledávání z neakční fronty.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Zavedeno v MSMQ 3.0. Přijme určitou zprávu z transakční fronty. Zpráva může být určena vyhledávacím identifikátorem nebo umístěním na začátku nebo na konci fronty.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Zavedeno v MSMQ 3.0. Přijme určitou zprávu z fronty pomocí zadaného kontextu transakce. Zpráva může být určena vyhledávacím identifikátorem nebo umístěním na začátku nebo na konci fronty.
Refresh()	Aktualizuje vlastnosti prezentované objektem , MessageQueue aby odrážely aktuální stav prostředku.
ResetPermissions()	Obnoví seznam oprávnění na výchozí hodnoty operačního systému. Odebere všechna oprávnění fronty, která jste připojili k výchozímu seznamu.
Send(Object)	Odešle objekt do neaktuální fronty odkazované tímto MessageQueueobjektem .
Send(Object, MessageQueueTransaction)	Odešle objekt do transakční fronty, na kterou odkazuje tento MessageQueueobjekt .
Send(Object, MessageQueueTransactionType)	Odešle objekt do fronty odkazované tímto MessageQueueobjektem .
Send(Object, String)	Odešle objekt do neaktuální fronty, na kterou odkazuje tato MessageQueue fronta, a určí popisek zprávy.
Send(Object, String, MessageQueueTransaction)	Odešle objekt do transakční fronty, na kterou odkazuje, MessageQueue a určuje popisek zprávy.
Send(Object, String, MessageQueueTransactionType)	Odešle objekt do fronty, na kterou se odkazuje, MessageQueue a určí popisek zprávy.
SetPermissions(AccessControlList)	Přiřadí přístupová práva k frontě na základě obsahu seznamu řízení přístupu.
SetPermissions(MessageQueueAccessControlEntry)	Přiřadí přístupová práva k frontě na základě obsahu položky řízení přístupu.
SetPermissions(String, MessageQueueAccessRights)	Poskytne počítači, skupině nebo uživateli zadaná přístupová práva.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Poskytne počítači, skupině nebo uživateli zadaná přístupová práva se zadaným typem řízení přístupu (povolit, odepřít, odvolat nebo nastavit).
ToString()	String Vrátí hodnotu obsahující název Component, pokud existuje. Tato metoda by neměla být přepsána. (Zděděno od Component)

Událost

Disposed	Nastane, když je komponenta odstraněna voláním Dispose() metody. (Zděděno od Component)
PeekCompleted	Vyvolá se při čtení zprávy bez odebrání z fronty. Jedná se o výsledek asynchronní operace BeginPeek().
ReceiveCompleted	Vyvolá se při odebrání zprávy z fronty. Tato událost je vyvolána asynchronní operací BeginReceive().

Metody rozšíření

Cast<TResult>(IEnumerable)	Přetypuje prvky objektu na IEnumerable zadaný typ.
OfType<TResult>(IEnumerable)	Filtruje prvky objektu IEnumerable na základě zadaného typu.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede objekt na IEnumerableIQueryable.

Bezpečný přístup z více vláken

Pouze metoda GetAllMessages() je bezpečná z více vláken.

Viz také

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