共用方式為

MessageQueue.BeginReceive 方法

  • 參考

定義

命名空間:
System.Messaging
組件:
System.Messaging.dll

啟始非同步接收作業，方法是告知訊息佇列開始接收訊息，並在完成時告知事件處理常式。

多載

BeginReceive()

啟始沒有逾時的非同步接收作業。作業要等到訊息可以在佇列中使用之後才算完成。
BeginReceive(TimeSpan)

啟始具有指定逾時的非同步接收作業。作業要等到訊息可在佇列中使用，或發生逾時之後才算完成。
BeginReceive(TimeSpan, Object)

啟始有指定逾時和指定狀態物件的非同步接收作業，會在作業的整個存留期內提供相關的資訊。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。
BeginReceive(TimeSpan, Object, AsyncCallback)

啟始有指定逾時和指定狀態物件的非同步接收作業，會在作業的整個存留期內提供相關的資訊。 這個多載會透過回呼，接收作業的事件處理常式的識別通知。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

初始化非同步接收作業，該作業具有指定的逾時，並使用指定的游標和指定的狀態物件。 狀態物件提供整個作業存留期的相關聯資訊。 這個多載會透過回呼，接收作業的事件處理常式的識別通知。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。

BeginReceive()

啟始沒有逾時的非同步接收作業。作業要等到訊息可以在佇列中使用之後才算完成。

public:
 IAsyncResult ^ BeginReceive();
public IAsyncResult BeginReceive ();
member this.BeginReceive : unit -> IAsyncResult
Public Function BeginReceive () As IAsyncResult

傳回

IAsyncResult

識別傳送的非同步要求的 IAsyncResult。

例外狀況

MessageQueueException

存取訊息佇列方法時發生錯誤。

範例

下列程式代碼範例會鏈結異步要求。 它假設本機電腦上有一個名為 「myQueue」 的佇列。 函 Main 式會開始由例程處理的 MyReceiveCompleted 異步操作。 MyReceiveCompleted 會處理目前的訊息，並開始新的異步接收作業。

#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

下列程式代碼範例會將異步要求排入佇列。 的呼叫 BeginReceive 會在其 AsyncWaitHandle 傳回值中使用 。 Main例程會等候所有異步操作在結束之前完成。

#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

備註

在異步處理中，您會在從佇列中移除訊息時，用來 BeginReceive 引發 ReceiveCompleted 事件。

ReceiveCompleted 如果佇列中已經有訊息，也會引發 。

若要使用 BeginReceive，請建立事件處理程式來處理異步操作的結果，並將它與您的事件委派產生關聯。 BeginReceive 起始異步接收作業; MessageQueue 當訊息送達佇列時，會透過引發 ReceiveCompleted 事件來通知 。 MessageQueue接著，可以藉由呼叫 EndReceive(IAsyncResult)來存取訊息。

方法 BeginReceive 會立即傳回，但在呼叫事件處理程式之前，異步操作不會完成。

因為 BeginReceive 是異步的，所以您可以呼叫它來接收來自佇列的訊息，而不會封鎖目前的執行線程。 若要同步接收訊息，請使用 Receive 方法。

異步操作完成後，您可以在事件處理程式中呼叫 或 BeginReceive 再次呼叫 BeginPeek ，以保留接收通知。

，IAsyncResultBeginReceive會識別方法啟動的異步操作。 您可以在作業的整個存留期內使用此 IAsyncResult 項目，雖然您通常不會在呼叫之前 EndReceive(IAsyncResult) 使用它。 不過，如果您啟動數個異步操作，您可以將其 IAsyncResult 值放在陣列中，並指定是否要等候所有作業或任何作業完成。 在此情況下，您會使用 AsyncWaitHandle 的 IAsyncResult 屬性來識別已完成的作業。

如果 CanRead 為 false，則會引發完成事件，但呼叫 EndReceive(IAsyncResult)時會擲回例外狀況。

請勿搭配交易使用異步呼叫 BeginReceive 。 如果您想要執行交易異步操作，請呼叫 BeginPeek，並將交易和 (同步) Receive 方法放在您為查看作業建立的事件處理程式中。 事件處理程式可能包含如下列 C# 程式代碼所示的功能。

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

下表顯示這個方法是否可在各種工作組模式中使用。

工作組模式 可用
本機電腦 是
本機計算機和直接格式名稱 是
遠端電腦 否
遠端電腦和直接格式名稱 是

另請參閱

適用於

BeginReceive(TimeSpan)

啟始具有指定逾時的非同步接收作業。作業要等到訊息可在佇列中使用，或發生逾時之後才算完成。

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);
public IAsyncResult BeginReceive (TimeSpan timeout);
member this.BeginReceive : TimeSpan -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

參數

timeout
TimeSpan

TimeSpan，指出等待訊息變成可以使用的時間間隔。

傳回

IAsyncResult

識別傳送的非同步要求的 IAsyncResult。

例外狀況

ArgumentException

timeout 參數所指定的值無效，可能是因為它表示負數。

MessageQueueException

存取訊息佇列方法時發生錯誤。

範例

下列程式代碼範例會建立異步接收作業。 程式代碼範例會建立事件處理程式 ， MyReceiveCompleted並將它附加至 ReceiveCompleted 事件處理程式委派。 程式代碼範例會將訊息傳送至本機消息佇列，然後呼叫 BeginReceive(TimeSpan)，並傳入逾時值為 10 秒。 ReceiveCompleted引發事件時，事件處理程式會接收訊息，並將訊息本文寫入畫面。

#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);
    }
}

備註

在異步處理中，當訊息在佇列中可用或指定的時間間隔過期時，您可用來 BeginReceive 引發 ReceiveCompleted 事件。

ReceiveCompleted 如果佇列中已經有訊息，也會引發 。

若要使用 BeginReceive，請建立事件處理程式來處理異步操作的結果，並將它與您的事件委派產生關聯。 BeginReceive 起始異步接收作業; MessageQueue 當訊息送達佇列時，會透過引發 ReceiveCompleted 事件來通知 。 MessageQueue接著，可以使用呼叫EndReceive(IAsyncResult)或擷取結果ReceiveCompletedEventArgs來存取訊息。

方法 BeginReceive 會立即傳回，但在呼叫事件處理程式之前，異步操作不會完成。

因為 BeginReceive 是異步的，所以您可以呼叫它來接收來自佇列的訊息，而不會封鎖目前的執行線程。 若要同步接收訊息，請使用 Receive 方法。

異步操作完成後，您可以在事件處理程式中呼叫 或 BeginReceive 再次呼叫 BeginPeek ，以保留接收通知。

如果 CanRead 為 false，則會引發完成事件，但呼叫 EndReceive(IAsyncResult)時會擲回例外狀況。

，IAsyncResultBeginReceive會識別方法啟動的異步操作。 您可以在作業的整個存留期內使用此 IAsyncResult 項目，雖然您通常不會在呼叫之前 EndReceive(IAsyncResult) 使用它。 不過，如果您啟動數個異步操作，您可以將其 IAsyncResult 值放在陣列中，並指定是否要等候所有作業或任何作業完成。 在此情況下，您會使用 AsyncWaitHandle 的 IAsyncResult 屬性來識別已完成的作業。

此多載會指定逾時。如果參數指定的 timeout 間隔過期，此元件就會 ReceiveCompleted 引發 事件。 因為沒有任何訊息存在，後續呼叫 EndReceive(IAsyncResult) 將會擲回例外狀況。

請勿搭配交易使用異步呼叫 BeginReceive 。 如果您想要執行交易異步操作，請呼叫 BeginPeek，並將交易和 (同步) Receive 方法放在您為查看作業建立的事件處理程式中。 事件處理程式可能包含如下列 C# 程式代碼所示的功能。

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

下表顯示這個方法是否可在各種工作組模式中使用。

工作組模式 可用
本機電腦 是
本機計算機和直接格式名稱 是
遠端電腦 否
遠端電腦和直接格式名稱 是

另請參閱

適用於

BeginReceive(TimeSpan, Object)

啟始有指定逾時和指定狀態物件的非同步接收作業，會在作業的整個存留期內提供相關的資訊。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。

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

參數

timeout
TimeSpan

TimeSpan，指出等待訊息變成可以使用的時間間隔。

stateObject
Object

應用程式指定的狀態物件，包含與非同步作業相關的資訊。

傳回

IAsyncResult

識別傳送的非同步要求的 IAsyncResult。

例外狀況

ArgumentException

指定給 timeout 參數的值無效。

MessageQueueException

存取訊息佇列方法時發生錯誤。

範例

下列程式代碼範例會建立異步接收作業。 程式代碼範例會建立事件處理程式 ， MyReceiveCompleted並將它附加至 ReceiveCompleted 事件處理程式委派。 程式代碼範例會將訊息傳送至本機消息佇列，然後呼叫 BeginReceive(TimeSpan, Object)，並傳入十秒的逾時值，以及識別該特定訊息的唯一整數。 ReceiveCompleted引發事件時，事件處理程式會接收訊息，並將訊息本文和整數訊息標識碼寫入畫面。

#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);
    }
}

備註

在異步處理中，當訊息在佇列中可用或指定的時間間隔過期時，您可用來 BeginReceive 引發 ReceiveCompleted 事件。

ReceiveCompleted 如果佇列中已經有訊息，也會引發 。

使用此多載，將資訊與將在整個作業存留期間保留的作業產生關聯。 事件處理程式可以藉由查看 AsyncState 與作業相關聯的 屬性 IAsyncResult 來偵測這項資訊。

若要使用 BeginReceive，請建立事件處理程式來處理異步操作的結果，並將它與您的事件委派產生關聯。 BeginReceive 起始異步接收作業; MessageQueue 當訊息送達佇列時，會透過引發 ReceiveCompleted 事件來通知 。 MessageQueue接著，可以使用呼叫EndReceive(IAsyncResult)或擷取結果ReceiveCompletedEventArgs來存取訊息。

方法 BeginReceive 會立即傳回，但在呼叫事件處理程式之前，異步操作不會完成。

因為 BeginReceive 是異步的，所以您可以呼叫它來接收來自佇列的訊息，而不會封鎖目前的執行線程。 若要同步接收訊息，請使用 Receive 方法。

異步操作完成後，您可以在事件處理程式中呼叫 或 BeginReceive 再次呼叫 BeginPeek ，以保留接收通知。

，IAsyncResultBeginReceive會識別方法啟動的異步操作。 您可以在作業的整個存留期內使用此 IAsyncResult 項目，雖然您通常不會在呼叫之前 EndReceive(IAsyncResult) 使用它。 不過，如果您啟動數個異步操作，您可以將其 IAsyncResult 值放在陣列中，並指定是否要等候所有作業或任何作業完成。 在此情況下，您會使用 AsyncWaitHandle 的 IAsyncResult 屬性來識別已完成的作業。

此多載會指定逾時和狀態物件。 如果參數指定的 timeout 間隔過期，此元件就會 ReceiveCompleted 引發 事件。 因為沒有任何訊息存在，後續呼叫 EndReceive(IAsyncResult) 將會擲回例外狀況。

狀態物件會將狀態資訊與作業產生關聯。 例如，如果您呼叫 BeginReceive 多次來起始多個作業，您可以透過您定義的個別狀態對象來識別每個作業。

您也可以使用狀態物件，跨進程線程傳遞資訊。 如果線程已啟動，但回呼位於異步案例中的不同線程上，狀態物件會封送處理並傳回事件的資訊。

請勿搭配交易使用異步呼叫 BeginReceive 。 如果您想要執行交易異步操作，請呼叫 BeginPeek，並將交易和 (同步) Receive 方法放在您為查看作業建立的事件處理程式中。 事件處理程式可能包含如下列 C# 程式代碼所示的功能。

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

下表顯示這個方法是否可在各種工作組模式中使用。

工作組模式 可用
本機電腦 是
本機計算機和直接格式名稱 是
遠端電腦 否
遠端電腦和直接格式名稱 是

另請參閱

適用於

BeginReceive(TimeSpan, Object, AsyncCallback)

啟始有指定逾時和指定狀態物件的非同步接收作業，會在作業的整個存留期內提供相關的資訊。 這個多載會透過回呼，接收作業的事件處理常式的識別通知。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。

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

參數

timeout
TimeSpan

TimeSpan，指出等待訊息變成可以使用的時間間隔。

stateObject
Object

應用程式指定的狀態物件，包含與非同步作業相關的資訊。

callback
AsyncCallback

會接收非同步作業完成通知的 AsyncCallback。

傳回

IAsyncResult

識別傳送的非同步要求的 IAsyncResult。

例外狀況

ArgumentException

指定給 timeout 參數的值無效。

MessageQueueException

存取訊息佇列方法時發生錯誤。

範例

下列程式代碼範例會建立異步接收作業。 程式代碼範例會將訊息傳送至本機消息佇列，然後呼叫 BeginReceive(TimeSpan, Object, AsyncCallback)，並傳入：逾時值 10 秒、識別該特定訊息的唯一整數，以及識別事件處理程式MyReceiveCompleted的新實例AsyncCallback。 ReceiveCompleted引發事件時，事件處理程式會接收訊息，並將訊息本文和整數訊息標識碼寫入畫面。

#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);
    }
}

備註

當您使用此多載時，直接叫用回呼參數中指定的回呼時，會在佇列中提供訊息或指定的時間間隔過期時叫用; ReceiveCompleted 不會引發事件。 的其他多載 BeginReceive 會依賴此元件來引發 ReceiveCompleted 事件。

ReceiveCompleted 如果佇列中已經有訊息，也會引發 。

若要使用 BeginReceive，請建立事件處理程式來處理異步操作的結果，並將它與您的事件委派產生關聯。 BeginReceive 起始異步接收作業; MessageQueue 當訊息送達佇列時，會透過引發 ReceiveCompleted 事件來通知 。 MessageQueue接著，可以使用呼叫EndReceive(IAsyncResult)或擷取結果ReceiveCompletedEventArgs來存取訊息。

方法 BeginReceive 會立即傳回，但在呼叫事件處理程式之前，異步操作不會完成。

因為 BeginReceive 是異步的，所以您可以呼叫它來接收來自佇列的訊息，而不會封鎖目前的執行線程。 若要同步接收訊息，請使用 Receive 方法。

異步操作完成後，您可以在事件處理程式中呼叫 或 BeginReceive 再次呼叫 BeginPeek ，以保留接收通知。

，IAsyncResultBeginReceive會識別方法啟動的異步操作。 您可以在作業的整個存留期內使用此 IAsyncResult 項目，雖然您通常不會在呼叫之前 EndReceive(IAsyncResult) 使用它。 不過，如果您啟動數個異步操作，您可以將其 IAsyncResult 值放在陣列中，並指定是否要等候所有作業或任何作業完成。 在此情況下，您會使用 AsyncWaitHandle 的 IAsyncResult 屬性來識別已完成的作業。

狀態物件會將狀態資訊與作業產生關聯。 例如，如果您呼叫 BeginReceive 多次來起始多個作業，您可以透過您定義的個別狀態對象來識別每個作業。

您也可以使用狀態物件，跨進程線程傳遞資訊。 如果線程已啟動，但回呼位於異步案例中的不同線程上，狀態物件會封送處理並傳回事件的資訊。

請勿搭配交易使用異步呼叫 BeginReceive 。 如果您想要執行交易異步操作，請呼叫 BeginPeek，並將交易和 (同步) Receive 方法放在您為查看作業建立的事件處理程式中。 事件處理程式可能包含如下列 C# 程式代碼所示的功能。

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

下表顯示這個方法是否可在各種工作組模式中使用。

工作組模式 可用
本機電腦 是
本機計算機和直接格式名稱 是
遠端電腦 否
遠端電腦和直接格式名稱 是

另請參閱

適用於

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

初始化非同步接收作業，該作業具有指定的逾時，並使用指定的游標和指定的狀態物件。 狀態物件提供整個作業存留期的相關聯資訊。 這個多載會透過回呼，接收作業的事件處理常式的識別通知。 在訊息可以於佇列中使用或發生逾時之後，作業才會完成。

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

參數

timeout
TimeSpan

TimeSpan，指出等待訊息變成可以使用的時間間隔。

cursor
Cursor

Cursor，保留訊息佇列中的特定位置。

state
Object

應用程式指定的狀態物件，包含與非同步作業相關的資訊。

callback
AsyncCallback

AsyncCallback，接收非同步作業的完成通知。

傳回

IAsyncResult

識別傳送的非同步要求的 IAsyncResult。

例外狀況

ArgumentNullException

cursor 參數為 null。

ArgumentException

指定給 timeout 參數的值無效。

MessageQueueException

存取訊息佇列方法時發生錯誤。

備註

當您使用此多載時，會在佇列中使用訊息或指定的時間間隔過期時，直接叫用回呼參數中指定的回呼; ReceiveCompleted 未引發事件。 的其他多載 BeginReceive 會依賴此元件來引發 ReceiveCompleted 事件。

ReceiveCompleted 如果佇列中已有訊息，也會引發 。

若要使用 BeginReceive，請建立事件處理程式來處理異步操作的結果，並將它與您的事件委派產生關聯。 BeginReceive 起始異步接收作業; MessageQueue 當訊息抵達佇列時，會透過引發 ReceiveCompleted 事件來通知 。 MessageQueue接著，可以使用呼叫EndReceive(IAsyncResult)或擷取結果ReceiveCompletedEventArgs來存取訊息。

方法 BeginReceive 會立即傳回，但在呼叫事件處理程式之前，不會完成異步操作。

因為 BeginReceive 是異步的，所以您可以呼叫它，以接收佇列中的訊息，而不會封鎖目前的執行線程。 若要同步接收訊息，請使用 Receive 方法。

異步操作完成後，您可以在事件處理程式中呼叫 或 BeginReceive 再次呼叫 BeginPeek ，以保留接收通知。

，IAsyncResultBeginReceive會識別方法啟動的異步操作。 您可以在作業的整個存留期內使用此項目 IAsyncResult ，不過您通常不會在呼叫 之前 EndReceive(IAsyncResult) 使用它。 不過，如果您啟動數個異步操作，您可以將其 IAsyncResult 值放在陣列中，並指定是否等候所有作業或任何作業完成。 在此情況下，請使用 AsyncWaitHandle 的 IAsyncResult 屬性來識別已完成的作業。

狀態物件會將狀態資訊與作業產生關聯。 例如，如果您呼叫 BeginReceive 多次來起始多個作業，您可以透過您定義的個別狀態對象來識別每個作業。

您也可以使用狀態物件，跨進程線程傳遞資訊。 如果線程已啟動，但回呼在異步案例中的不同線程上，狀態物件會封送處理並傳回事件的資訊。

請勿搭配交易使用異步呼叫 BeginReceive 。 如果您想要執行交易異步操作，請呼叫 BeginPeek，並將交易和 (同步) Receive 方法放在您為查看作業建立的事件處理程式內。 事件處理程式可能包含如下列 C# 程式代碼所示的功能。

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

下表顯示此方法是否可在各種工作組模式中使用。

工作組模式 可用
本機電腦 是
本機計算機和直接格式名稱 是
遠端電腦 否
遠端電腦和直接格式名稱 是

另請參閱

適用於

執行緒安全性

方法不是安全線程。