通过

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 方法。

异步操作完成后，可以在事件处理程序中再次调用 BeginPeek 或 BeginReceive 以继续接收通知。

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 方法。

异步操作完成后，可以在事件处理程序中再次调用 BeginPeek 或 BeginReceive 以继续接收通知。

如果 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)，并传入 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 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 方法。

异步操作完成后，可以在事件处理程序中再次调用 BeginPeek 或 BeginReceive 以继续接收通知。

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

注解

使用此重载时，当消息在队列中可用或指定的时间间隔已过期时，将直接调用 callback 参数中指定的回调; ReceiveCompleted 未引发 事件。 的其他重载 BeginReceive 依赖于此组件来引发 ReceiveCompleted 事件。

ReceiveCompleted 如果队列中已存在消息，也会引发 。

若要使用 BeginReceive，请创建一个事件处理程序来处理异步操作的结果，并将其与事件委托相关联。 BeginReceive 启动异步接收操作; MessageQueue 当消息到达队列时，将通过引发 ReceiveCompleted 事件来通知 。 然后，可以通过 MessageQueue 使用 调用 EndReceive(IAsyncResult) 或检索结果来 ReceiveCompletedEventArgs访问消息。

方法 BeginReceive 会立即返回，但异步操作在调用事件处理程序之前不会完成。

由于 BeginReceive 是异步的，因此可以调用它以从队列接收消息，而不会阻止当前执行线程。 若要同步接收消息，请使用 Receive 方法。

异步操作完成后，可以在事件处理程序中再次调用 BeginPeek 或 BeginReceive 以继续接收通知。

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 方法。

异步操作完成后，可以在事件处理程序中再次调用 BeginPeek 或 BeginReceive 以继续接收通知。

IAsyncResultBeginReceive返回的 标识方法启动的异步操作。 可以在操作的整个生存期内使用它 IAsyncResult ，尽管在调用 之前 EndReceive(IAsyncResult) 通常不会使用它。 但是，如果启动多个异步操作，则可以将其 IAsyncResult 值放在数组中，并指定是等待所有操作完成还是等待任何操作完成。 在这种情况下，请使用 AsyncWaitHandle 的 IAsyncResult 属性来标识已完成的操作。

状态对象将状态信息与操作相关联。 例如，如果多次调用 BeginReceive 以启动多个操作，则可以通过定义的单独状态对象来标识每个操作。

还可以使用 state 对象跨进程线程传递信息。 如果线程已启动，但回调位于异步方案中的不同线程上，则会封送状态对象，并连同事件中的信息一起传递回来。

不要对事务使用异步调用 BeginReceive 。 如果要执行事务异步操作，请调用 BeginPeek，并将事务和 (同步) Receive 方法放在为速览操作创建的事件处理程序中。 事件处理程序可能包含以下 C# 代码中所示的功能。

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

下表显示了此方法是否在各种工作组模式下可用。

工作组模式 可用
本地计算机 是
本地计算机和直接格式名称 是
远程计算机 否
远程计算机和直接格式名称 是

另请参阅

适用于

线程安全性

方法不是线程安全的。