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ázvu cesty. 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 .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 běžícím v různých časech komunikovat v heterogenních sítích a systémech, které mohou být dočasně offline. Aplikace odesílají, přijímají nebo prohlédnou (číst bez odebrání) zpráv z front. Ří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álka 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 vést k mírně odlišnému 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. V konstruktoru MessageQueue můžete zadat cestu pro připojení k existujícímu prostředku nebo můžete vytvořit novou frontu na serveru. Než budete moci volat Send(Object), Peeknebo Receive, musíte přidružit novou instanci MessageQueue třídy k existující frontě. V tomto okamžiku můžete manipulovat s vlastnostmi fronty, například Category a Label.

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

Když vytvoříte novou instanci MessageQueue třídy, nevytvoříte novou frontu služby Řízení front zpráv. Místo toho můžete použít Create(String), Delete(String)a Purge metody pro správu 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 jedním ze tří názvů: popisným názvem, popisným FormatNamenázvem nebo objektem Label. Popisný název definovaný frontou a vlastnostmi fronty MachineName je MachineName\QueueName určený pro veřejnou frontu a MachineNameQueueName\\Private$pro soukromou frontu.QueueName Tato FormatName vlastnost umožňuje offline přístup k frontám zpráv. Nakonec můžete vlastnost fronty Label použít k nastavení fronty Path.

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

Konstruktory

Name	Description
MessageQueue()	Inicializuje novou instanci MessageQueue třídy. Jakmile konstruktor bez parametrů inicializuje novou instanci, musíte před použitím instance nastavit Path vlastnost instance.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String, Boolean, Boolean)	Inicializuje novou instanci MessageQueue třídy.
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, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String)	Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě.

Pole

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

Vlastnosti

Name	Description
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 služby Řízení front zpráv používá ke směrování zpráv veřejné fronty přes síť.
CanRaiseEvents	Získá hodnotu urč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á určuje, zda MessageQueue lze zapisovat do.
Category	Získá nebo nastaví kategorii fronty.
Container	Získá ten IContainer , který obsahuje Component. (Zděděno od Component)
CreateTime	Získá čas a datum vytvoření fronty ve službě Řízení front zpráv.
DefaultPropertiesToSend	Získá nebo nastaví hodnoty vlastnosti zprávy, které se mají použít ve výchozím nastavení při odesílání zpráv do fronty.
DenySharedReceive	Získá nebo nastaví hodnotu, která označuje, zda má výhradní MessageQueue přístup k příjmu zpráv z fronty služby Řízení front zpráv.
DesignMode	Získá hodnotu, která označuje, zda Component je aktuálně v režimu návrhu. (Zděděno od Component)
EnableConnectionCache	Získá nebo nastaví hodnotu, která určuje, zda bude mezipaměť připojení udržována aplikací.
EncryptionRequired	Získá nebo nastaví hodnotu, která označuje, zda fronta přijímá pouze nesoukromého (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 deserializace objektu z těla 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á čas poslední změny vlastností fronty.
MachineName	Získá nebo nastaví název počítače, kde je umístěna 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	Získá nebo nastaví adresu vícesměrového vysílání přidružené k frontě.
Path	Získá nebo nastaví cestu fronty. Path Nastavení příčin odkazování na novou frontu MessageQueue
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 .Component (Zděděno od Component)
SynchronizingObject	Získá nebo nastaví objekt, který zařazuje volání obslužné rutiny události, která je výsledkem ReceiveCompleted nebo PeekCompleted událost.
Transactional	Získá hodnotu, která určuje, zda fronta přijímá pouze transakce.
UseJournalQueue	Získá nebo nastaví hodnotu, která označuje, zda přijaté zprávy jsou zkopírovány do fronty deníku.
WriteHandle	Získá nativní popisovač použitý k odesílání zpráv do fronty zpráv.

Metody

Name	Description
BeginPeek()	Inicializuje asynchronní náhled operace, která nemá časový limit. Operace není dokončena, dokud se ve frontě nezobrazí zpráva.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a používá zadaný kurzor, zadanou náhledovou akci a zadaný stavový objekt. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek(TimeSpan, Object)	Inicializuje asynchronní náhled operace, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginPeek(TimeSpan)	Inicializuje asynchronní náhled operace, která má zadaný časový limit. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginReceive()	Inicializuje asynchronní operaci příjmu, která nemá časový limit. Operace není dokončena, dokud se ve frontě nezobrazí zpráva.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Iniciuje asynchronní operaci příjmu, která má zadaný časový limit a používá zadaný kurzor a zadaný stav objekt. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení obdrží oznámení prostřednictvím zpětného volání identity obslužné rutiny události pro operaci. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit a zadaný stav objekt, který poskytuje přidružené informace po celou dobu životnosti operace. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
BeginReceive(TimeSpan)	Inicializuje asynchronní operaci příjmu, která má zadaný časový limit. Operace se nedokončuje, dokud se ve frontě nezobrazí zpráva nebo dojde k vypršení časového limitu.
ClearConnectionCache()	Vymaže mezipaměť připojení.
Close()	Uvolní všechny prostředky přidělené MessageQueuenástrojem .
Create(String, Boolean)	Vytvoří transakční nebo neaktuální frontu služby Řízení front zpráv v zadané cestě.
Create(String)	Vytvoří neaktuální frontu služby Řízení front zpráv v zadané cestě.
CreateCursor()	Vytvoří novou Cursor pro aktuální frontu zpráv.
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužící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é nástrojem MessageQueue.
EndPeek(IAsyncResult)	Dokončí zadanou asynchronní operaci náhledu.
EndReceive(IAsyncResult)	Dokončí zadanou asynchronní operaci příjmu.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Exists(String)	Určuje, zda fronta služby Řízení front zpráv existuje v 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() by měl být použit místo toho.
GetHashCode()	Slouží jako výchozí funkce hash. (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ém je umístěna fronta odkazovaná tímto MessageQueue objektem.
GetMessageEnumerator()	Zastaralé. Vytvoří objekt enumerátoru pro všechny zprávy ve frontě. GetMessageEnumerator() je zastaralá. GetMessageEnumerator2() by měl být použit místo toho.
GetMessageEnumerator2()	Vytvoří objekt enumerátoru pro všechny zprávy ve frontě.
GetMessageQueueEnumerator()	Poskytuje sémantiku kurzoru jen pro předávání pro výčet všech veřejných front v síti.
GetMessageQueueEnumerator(MessageQueueCriteria)	Poskytuje sémantiku kurzoru určenou jen pro předávání, která se má vypsat prostřednictvím všech veřejných front v síti, které splňují zadaná kritéria.
GetPrivateQueuesByMachine(String)	Načte všechny soukromé 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ý 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 jeho Container. (Zděděno od Component)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (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 tato MessageQueuezpráva odkazuje . Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud nebude k dispozici zpráva.
Peek(TimeSpan, Cursor, PeekAction)	Vrátí 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 zpráva nebude k dispozici nebo dojde k zadanému vypršení časového limitu.
Peek(TimeSpan)	Vrátí bez odebrání (náhledů) první zprávy ve frontě, na kterou tato MessageQueuezpráva odkazuje . Metoda Peek() je synchronní, takže blokuje aktuální vlákno, dokud zpráva nebude k dispozici nebo dojde k zadanému vypršení časového limitu.
PeekByCorrelationId(String, TimeSpan)	Zobrazí zprávu, která odpovídá danému identifikátoru korelace, a počká, dokud ve frontě nebude dostupná zpráva se zadaným identifikátorem korelace nebo vyprší časový limit.
PeekByCorrelationId(String)	Zobrazí 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.
PeekById(String, TimeSpan)	Zobrazí zprávu, jejíž identifikátor zprávy odpovídá parametru id . Počká, dokud se zpráva nezobrazí ve frontě nebo dojde k vypršení časového limitu.
PeekById(String)	Zobrazí zprávu, jejíž identifikátor zprávy odpovídá parametru id .
PeekByLookupId(Int64)	Zavedeno v MSMQ 3.0. Zobrazí náhled zprávy, která odpovídá danému vyhledávacímu identifikátoru z neaktuální fronty.
PeekByLookupId(MessageLookupAction, Int64)	Zavedeno v MSMQ 3.0. Zobrazí se náhled konkrétní zprávy z fronty. Zprávu lze zadat pomocí identifikátoru vyhledávání nebo podle jeho pozice na přední nebo koncové straně fronty.
Purge()	Odstraní všechny zprávy obsažené ve frontě.
Receive()	Přijme první zprávu dostupnou ve frontě, na kterou odkazuje MessageQueue. Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud nebude k dispozici zpráva.
Receive(MessageQueueTransaction)	Přijme první zprávu dostupnou v transakční frontě odkazované na MessageQueue. Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud nebude k dispozici zpráva.
Receive(MessageQueueTransactionType)	Přijme první zprávu dostupnou ve frontě, na kterou odkazuje MessageQueue. Toto volání je synchronní a blokuje aktuální vlákno spuštění, dokud nebude k dispozici zpráva.
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 k dispozici zpráva nebo vyprší časový limit.
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 k dispozici zpráva nebo vyprší časový limit.
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 k dispozici zpráva nebo vyprší časový limit.
Receive(TimeSpan, MessageQueueTransaction)	Přijme první zprávu dostupnou v transakční frontě, na kterou MessageQueue odkazuje a čeká, dokud ve frontě není k dispozici zpráva, nebo vyprší časový limit.
Receive(TimeSpan, MessageQueueTransactionType)	Přijme první zprávu dostupnou ve frontě, na kterou odkazuje MessageQueue. Toto volání je synchronní a čeká na dostupnost zprávy ve frontě nebo vypršení časového limitu.
Receive(TimeSpan)	Obdrží první zprávu dostupnou ve frontě, na kterou MessageQueue odkazuje, a čeká, dokud ve frontě není dostupná zpráva, nebo vyprší časový limit.
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)	Obdrží 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, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z transakční fronty) a počká, dokud ve frontě není dostupná zpráva se zadaným identifikátorem korelace nebo vyprší časový limit.
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 vyprší časový limit.
ReceiveByCorrelationId(String, TimeSpan)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z neaktuální fronty) a počká, dokud ve frontě není k dispozici zpráva se zadaným identifikátorem korelace nebo vyprší časový limit.
ReceiveByCorrelationId(String)	Přijme zprávu, která odpovídá danému identifikátoru korelace (z neaktuální fronty), a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem korelace.
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, MessageQueueTransaction)	Přijme zprávu, která odpovídá danému identifikátoru (z transakční fronty) a počká, dokud ve frontě není dostupná zpráva se zadaným identifikátorem nebo vyprší časový limit.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Obdrží zprávu, která odpovídá danému identifikátoru, a počká, dokud nebude dostupná zpráva se zadaným identifikátorem ve frontě nebo vypršení časového limitu.
ReceiveById(String, TimeSpan)	Přijme zprávu, která odpovídá danému identifikátoru (z neaktuální fronty) a počká, až bude zpráva se zadaným identifikátorem k dispozici ve frontě nebo vyprší časový limit.
ReceiveById(String)	Přijme zprávu, která odpovídá danému identifikátoru z neaktuální fronty, a okamžitě vyvolá výjimku, pokud ve frontě aktuálně neexistuje žádná zpráva se zadaným identifikátorem.
ReceiveByLookupId(Int64)	Zavedeno v MSMQ 3.0. Přijme zprávu, která odpovídá danému vyhledávacímu identifikátoru z neaktuální fronty.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Zavedeno v MSMQ 3.0. Přijme konkrétní zprávu z transakční fronty. Zprávu lze zadat pomocí identifikátoru vyhledávání nebo podle jeho pozice na přední nebo koncové straně fronty.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Zavedeno v MSMQ 3.0. Přijme konkrétní zprávu z fronty pomocí zadaného kontextu transakce. Zprávu lze zadat pomocí identifikátoru vyhledávání nebo podle jeho pozice na přední nebo koncové straně fronty.
Refresh()	Aktualizuje vlastnosti prezentované MessageQueue podle aktuálního stavu 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, MessageQueueTransaction)	Odešle objekt do transakční fronty odkazované tímto MessageQueueobjektem .
Send(Object, MessageQueueTransactionType)	Odešle objekt do fronty odkazované tímto MessageQueueobjektem .
Send(Object, String, MessageQueueTransaction)	Odešle objekt do transakční fronty odkazované tímto MessageQueue objektem a určuje popisek zprávy.
Send(Object, String, MessageQueueTransactionType)	Odešle objekt do fronty odkazované tímto MessageQueue objektem a určuje popisek zprávy.
Send(Object, String)	Odešle objekt do neaktuální fronty odkazované tímto MessageQueue objektem a určuje popisek zprávy.
Send(Object)	Odešle objekt do neaktuální fronty odkazované tímto MessageQueueobjektem .
SetPermissions(AccessControlList)	Přiřadí přístupová práva k frontě na základě obsahu seznamu řízení přístupu.
SetPermissions(MessageQueueAccessControlEntry)	Přiřadí frontě přístupová práva na základě obsahu položky řízení přístupu.
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).
SetPermissions(String, MessageQueueAccessRights)	Udělí počítači, skupině nebo uživateli zadaná přístupová práva.
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

Name	Description
Disposed	Nastane, když komponenta je uvolněna voláním Dispose() metody. (Zděděno od Component)
PeekCompleted	Nastane, když se zpráva přečte, aniž by byla odebrána z fronty. To je výsledek asynchronní operace, BeginPeek().
ReceiveCompleted	Nastane, když byla zpráva odebrána z fronty. Tato událost je vyvolána asynchronní operací , BeginReceive().

Metody rozšíření

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

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

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

Viz také

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