MessageQueue.BeginReceive Metoda

Reference

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zahájí asynchronní operaci příjmu tím, že službě Řízení front zpráv oznámí, aby začala přijímat zprávu, a po dokončení upozorní obslužnou rutinu události.

Přetížení

BeginReceive()	Inicializuje asynchronní operaci příjmu, která nemá žádný časový limit. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě.
BeginReceive(TimeSpan)	Inicializuje asynchronní příjem operace, která má zadaný časový limit. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object)	Inicializuje asynchronní příjem operaci, která má zadaný časový limit a zadaný stav objektu, který poskytuje přidružené informace po celou dobu životnosti operace. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicializuje asynchronní příjem operaci, která má zadaný časový limit a zadaný stav objektu, který poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení prostřednictvím zpětného volání obdrží oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud zpráva nebude k dispozici ve frontě nebo dokud nedojde k vypršení časového limitu.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Inicializuje asynchronní příjem operace, která má zadaný časový limit a používá zadaný kurzor a zadaný stav objektu. Objekt stavu poskytuje přidružené informace po celou dobu životnosti operace. Toto přetížení prostřednictvím zpětného volání obdrží oznámení o identitě obslužné rutiny události pro operaci. Operace není dokončena, dokud zpráva nebude k dispozici 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 zpráva nebude k dispozici ve frontě.

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive ();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Návraty

IAsyncResult

, IAsyncResult který identifikuje zaúčtované asynchronní požadavek.

Výjimky

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu zřetěžuje asynchronní požadavky. Předpokládá, že v místním počítači existuje fronta s názvem "myQueue". Funkce Main zahájí asynchronní operaci, kterou rutina MyReceiveCompleted zpracovává. MyReceiveCompleted zpracuje aktuální zprávu a zahájí novou operaci asynchronního příjmu.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Následující příklad kódu zařadí asynchronní požadavky do fronty. Volání BeginReceive používá ve své návratové hodnotě AsyncWaitHandle hodnotu . Rutina Main před ukončením čeká na dokončení všech asynchronních operací.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

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

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()

            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Poznámky

Při asynchronním zpracování se používá BeginReceive k vyvolání ReceiveCompleted události, když byla zpráva odebrána z fronty.

ReceiveCompleted vyvolá se také v případě, že zpráva již ve frontě existuje.

Pokud chcete použít BeginReceive, vytvořte obslužnou rutinu události, která zpracuje výsledky asynchronní operace a přidruží ji k delegátovi události. BeginReceive iniciuje asynchronní operaci příjmu; je MessageQueue upozorněn prostřednictvím vyvolání ReceiveCompleted události, když do fronty dorazí zpráva. Pak MessageQueue může ke zprávě získat přístup voláním EndReceive(IAsyncResult)metody .

Metoda BeginReceive vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu BeginReceive , že je asynchronní, můžete ji volat, abyste přijali zprávu z fronty bez blokování aktuálního vlákna provádění. Pokud chcete zprávu přijímat synchronně, použijte metodu Receive .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste mohli dál přijímat oznámení.

BeginReceive Vrácený IAsyncResult objekt identifikuje asynchronní operaci, kterou metoda spustila. Můžete ji IAsyncResult používat po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndReceive(IAsyncResult) ji nezavoláte. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V takovém případě použijete AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

Pokud CanRead je false, vyvolá se událost dokončení, ale při volání EndReceive(IAsyncResult)se vyvolá výjimka .

Nepoužívejte asynchronní volání BeginReceive s transakcemi. Pokud chcete provést transakční asynchronní operaci, zavolejte BeginPeeka vložte transakci a (synchronní) Receive metodu v obslužné rutině události, kterou vytvoříte pro operaci náhledu. Vaše obslužná rutina události může obsahovat funkce, jak je znázorněno v následujícím kódu jazyka C#.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny	K dispozici.
Místní počítač	Yes
Název místního počítače a přímého formátu	Yes
Vzdálený počítač	No
Název vzdáleného počítače a přímého formátu	Yes

Viz také

Platí pro

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.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive (TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parametry

timeout: TimeSpan

Hodnota TimeSpan označující časový interval čekání na zpřístupnění zprávy.

Návraty

IAsyncResult

Ten IAsyncResult , který identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná, pravděpodobně proto, že představuje záporné číslo.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří asynchronní operaci příjmu. Příklad kódu vytvoří obslužnou rutinu MyReceiveCompletedudálosti , a připojí ji k delegátu ReceiveCompleted obslužné rutiny události. Příklad kódu odešle zprávu do místní fronty zpráv a pak zavolá BeginReceive(TimeSpan)a předá hodnotu časového limitu deset sekund. Při vyvolání ReceiveCompleted události obslužná rutina události přijme zprávu a zapíše text zprávy na obrazovku.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message body: {0}", msg->Body);
    
    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}


using System;
using System.Messaging;

public class QueueExample
{
    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Poznámky

Při asynchronním zpracování se používá BeginReceive k vyvolání ReceiveCompleted události, když se zpráva zpřístupní ve frontě nebo když vyprší zadaný časový interval.

ReceiveCompleted vyvolá se také v případě, že zpráva již ve frontě existuje.

Pokud chcete použít BeginReceive, vytvořte obslužnou rutinu události, která zpracuje výsledky asynchronní operace a přidruží ji k delegátovi události. BeginReceive iniciuje asynchronní operaci příjmu; je MessageQueue upozorněn prostřednictvím vyvolání ReceiveCompleted události, když do fronty dorazí zpráva. Pak MessageQueue může získat přístup ke zprávě zavoláním EndReceive(IAsyncResult) nebo načtením výsledku ReceiveCompletedEventArgspomocí .

Metoda BeginReceive vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste mohli dál přijímat oznámení.

Pokud CanRead je false, vyvolá se událost dokončení, ale při volání EndReceive(IAsyncResult)se vyvolá výjimka .

Toto přetížení určuje časový limit. Pokud interval určený parametrem timeout vyprší, vyvolá tato komponenta ReceiveCompleted událost. Vzhledem k tomu, že žádná zpráva neexistuje, vyvolá následné volání EndReceive(IAsyncResult) výjimku.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny	K dispozici.
Místní počítač	Yes
Název místního počítače a přímého formátu	Yes
Vzdálený počítač	No
Název vzdáleného počítače a přímého formátu	Yes

Viz také

Platí pro

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.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);

public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject);

member this.BeginReceive : TimeSpan * obj -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parametry

timeout: TimeSpan

A TimeSpan označující interval čekání na zpřístupnění zprávy.

stateObject: Object

Objekt stavu určený aplikací, který obsahuje informace přidružené k asynchronní operaci.

Návraty

IAsyncResult

Ten IAsyncResult , který identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří asynchronní operaci příjmu. Příklad kódu vytvoří obslužnou rutinu MyReceiveCompletedudálosti a připojí ji k delegátovi ReceiveCompleted obslužné rutiny události. Příklad kódu odešle zprávu do místní fronty zpráv a pak zavolá BeginReceive(TimeSpan, Object), předá hodnotu časového limitu deset sekund a jedinečné celé číslo, které identifikuje danou konkrétní zprávu. Při vyvolání ReceiveCompleted události obslužná rutina události přijme zprávu a zapíše text zprávy a identifikátor celočíselné zprávy na obrazovku.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", e->AsyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}",
            (int)asyncResult.AsyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Poznámky

Při asynchronním zpracování se používá BeginReceive k vyvolání ReceiveCompleted události při zpřístupnění zprávy ve frontě nebo při vypršení zadaného časového intervalu.

ReceiveCompleted vyvolá se také v případě, že ve frontě již existuje zpráva.

Toto přetížení slouží k přidružení informací k operaci, která se zachová po celou dobu životnosti operace. Obslužná rutina události může tyto informace zjistit na základě AsyncState vlastnosti IAsyncResult , která je přidružena k operaci.

Pokud chcete použít BeginReceive, vytvořte obslužnou rutinu události, která zpracuje výsledky asynchronní operace a přidruží ji k delegátovi události. BeginReceive inicializuje asynchronní operaci příjmu; je MessageQueue prostřednictvím vyvolání ReceiveCompleted události upozorněn, když do fronty dorazí zpráva. K MessageQueue této zprávě pak může získat přístup voláním EndReceive(IAsyncResult) nebo načtením výsledku ReceiveCompletedEventArgspomocí .

Metoda BeginReceive vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Vzhledem k tomu, že BeginReceive je asynchronní, můžete ji volat a přijmout zprávu z fronty bez blokování aktuálního vlákna provádění. Pokud chcete synchronně přijímat zprávu, použijte metodu Receive .

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste dál dostávali oznámení.

BeginReceive Vrátí IAsyncResult identifikuje asynchronní operaci, kterou metoda spustila. Můžete ho používat IAsyncResult po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndReceive(IAsyncResult) se nevolá. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V tomto případě použijete AsyncWaitHandle vlastnost objektu IAsyncResult k identifikaci dokončené operace.

Toto přetížení určuje časový limit a objekt stavu. Pokud interval určený parametrem timeout vyprší, tato komponenta ReceiveCompleted vyvolá událost. Vzhledem k tomu, že neexistuje žádná zpráva, vyvolá následné volání EndReceive(IAsyncResult) výjimku.

Objekt stavu přidruží informace o stavu k operaci. Pokud například zavoláte BeginReceive vícekrát, abyste zahájili více operací, můžete každou operaci identifikovat prostřednictvím samostatného objektu stavu, který definujete.

Objekt stavu můžete také použít k předávání informací mezi vlákny procesu. Pokud je vlákno spuštěno, ale zpětné volání je v jiném vlákně v asynchronním scénáři, stavový objekt je zařazován a předán zpět spolu s informacemi z události.

Nepoužívejte asynchronní volání BeginReceive s transakcemi. Pokud chcete provést transakční asynchronní operaci, zavolejte BeginPeeka vložte transakci a (synchronní) Receive metodu do obslužné rutiny události, kterou vytvoříte pro operaci náhledu. Obslužná rutina události může obsahovat funkce, jak je znázorněno v následujícím kódu jazyka C#.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny	K dispozici.
Místní počítač	Yes
Název místního počítače a přímého formátu	Yes
Vzdálený počítač	No
Název vzdáleného počítače a přímého formátu	Yes

Viz také

Platí pro

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.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject, AsyncCallback callback);

member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parametry

timeout: TimeSpan

A TimeSpan označující interval čekání na zpřístupnění zprávy.

stateObject: Object

Objekt stavu určený aplikací, který obsahuje informace přidružené k asynchronní operaci.

callback: AsyncCallback

Objekt AsyncCallback , který obdrží oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

Ten IAsyncResult , který identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Příklady

Následující příklad kódu vytvoří asynchronní operaci příjmu. Příklad kódu odešle zprávu do místní fronty zpráv, pak zavolá BeginReceive(TimeSpan, Object, AsyncCallback), předání: hodnotu časového limitu deset sekund; jedinečné celé číslo, které identifikuje danou konkrétní zprávu; a novou instanci AsyncCallback , která identifikuje obslužnou rutinu události, MyReceiveCompleted. Při vyvolání ReceiveCompleted události obslužná rutina události přijme zprávu a zapíše text zprávy a identifikátor celočíselné zprávy na obrazovku.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if (!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Poznámky

Když použijete toto přetížení, zpětné volání zadané v parametru zpětného volání je vyvoláno přímo, když zpráva bude k dispozici ve frontě nebo když vypršela zadaný interval časového intervalu; událost ReceiveCompleted není vyvolána. Další přetížení BeginReceive závisí na této komponentě, aby vyvolala ReceiveCompleted událost.

ReceiveCompleted vyvolá se také v případě, že ve frontě již existuje zpráva.

Metoda BeginReceive vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste dál dostávali oznámení.

Nepoužívejte asynchronní volání BeginReceive s transakcemi. Pokud chcete provést transakční asynchronní operaci, zavolejte BeginPeeka vložte transakci a (synchronní) Receive metodu do obslužné rutiny události, kterou vytvoříte pro operaci náhledu. Obslužná rutina události může obsahovat funkce, jak je znázorněno v následujícím kódu jazyka C#.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny	K dispozici.
Místní počítač	Yes
Název místního počítače a přímého formátu	Yes
Vzdálený počítač	No
Název vzdáleného počítače a přímého formátu	Yes

Viz také

Platí pro

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.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);

public IAsyncResult BeginReceive (TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);

member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Parametry

timeout: TimeSpan

A TimeSpan označující interval čekání na zpřístupnění zprávy.

cursor: Cursor

A Cursor , který udržuje určitou pozici ve frontě zpráv.

state: Object

Objekt stavu určený aplikací, který obsahuje informace přidružené k asynchronní operaci.

callback: AsyncCallback

Objekt AsyncCallback , který obdrží oznámení o dokončení asynchronní operace.

Návraty

IAsyncResult

Ten IAsyncResult , který identifikuje publikovaný asynchronní požadavek.

Výjimky

ArgumentNullException

Parametr cursor je null.

ArgumentException

Hodnota zadaná pro timeout parametr není platná.

MessageQueueException

Při přístupu k metodě služby Řízení front zpráv došlo k chybě.

Poznámky

ReceiveCompleted vyvolá se také v případě, že ve frontě již existuje zpráva.

Metoda BeginReceive vrátí okamžitě, ale asynchronní operace není dokončena, dokud není volána obslužná rutina události.

Po dokončení asynchronní operace můžete v obslužné rutině události volat BeginPeek nebo BeginReceive znovu, abyste dál dostávali oznámení.

BeginReceive Vrátí IAsyncResult identifikuje asynchronní operaci, kterou metoda spustila. Můžete ho používat IAsyncResult po celou dobu životnosti operace, i když ji obvykle nepoužíváte, dokud EndReceive(IAsyncResult) se nevolá. Pokud však spustíte několik asynchronních operací, můžete jejich IAsyncResult hodnoty umístit do pole a určit, zda se mají čekat na dokončení všech operací nebo jakékoli operace. V tomto případě použijte AsyncWaitHandle vlastnost k IAsyncResult identifikaci dokončené operace.

Nepoužívejte asynchronní volání BeginReceive s transakcemi. Pokud chcete provést transakční asynchronní operaci, zavolejte BeginPeeka vložte transakci a (synchronní) Receive metodu do obslužné rutiny události, kterou vytvoříte pro operaci náhledu. Obslužná rutina události může obsahovat funkce, jak je znázorněno v následujícím kódu jazyka C#.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Následující tabulka ukazuje, zda je tato metoda k dispozici v různých režimech pracovní skupiny.

Režim pracovní skupiny	K dispozici.
Místní počítač	Yes
Název místního počítače a přímého formátu	Yes
Vzdálený počítač	No
Název vzdáleného počítače a přímého formátu	Yes

Viz také

Platí pro

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

Metoda není bezpečná pro přístup z více vláken.

Sdílet prostřednictvím

MessageQueue.BeginReceive Metoda

Definice

Přetížení

BeginReceive()

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginReceive(TimeSpan)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginReceive(TimeSpan, Object)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginReceive(TimeSpan, Object, AsyncCallback)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Další materiály