MessageQueue.BeginPeek Method (TimeSpan)


Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

Namespace:   System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public IAsyncResult BeginPeek(
	TimeSpan timeout


Type: System.TimeSpan

A TimeSpan that indicates the interval of time to wait for a message to become available.

Return Value

Type: System.IAsyncResult

The IAsyncResult that identifies the posted asynchronous request.

Exception Condition

The value specified for the timeout parameter is not valid.


An error occurred when accessing a Message Queuing method.

.NET Framework
Available since 1.1

The method is not thread safe.

In asynchronous processing, you use BeginPeek to raise the PeekCompleted event when a message becomes available in the queue or when the specified interval of time has expired.

PeekCompleted is also raised if a message already exists in the queue.

To use BeginPeek, create an event handler that processes the results of the asynchronous operation, and associate it with your event delegate. BeginPeek initiates an asynchronous peek operation; the MessageQueue is notified, through the raising of the PeekCompleted event, when a message arrives in the queue. The MessageQueue can then access the message by calling EndPeek(IAsyncResult) or by retrieving the result using the PeekCompletedEventArgs.

The BeginPeek method returns immediately, but the asynchronous operation is not completed until the event handler is called.

Because BeginPeek is asynchronous, you can call it to peek the queue without blocking the current thread of execution. To synchronously peek the queue, use the Peek method.

Once an asynchronous operation completes, you can call BeginPeek or BeginReceive again in the event handler to keep receiving notifications.

The IAsyncResult that BeginPeek returns identifies the asynchronous operation that the method started. You can use this IAsyncResult throughout the lifetime of the operation, although you generally do not use it until EndPeek(IAsyncResult) is called. However, if you start several asynchronous operations, you can place their IAsyncResult values in an array and specify whether to wait for all operations or any operation to complete. In this case, you use the AsyncWaitHandle property of the IAsyncResult to identify the completed operation.

This overload specifies a time-out. If the interval specified by the timeout parameter expires, this component raises the PeekCompleted event. Because no message exists, a subsequent call to EndPeek(IAsyncResult) will throw an exception.

If CanRead is false, the completion event is raised, but an exception will be thrown when calling EndPeek(IAsyncResult).

The following table shows whether this method is available in various Workgroup modes.

Workgroup mode


Local computer


Local computer and direct format name


Remote computer


Remote computer and direct format name


The following code example creates an asynchronous peek operation, using the queue path ".\myQueue". It creates an event handler, MyPeekCompleted, and attaches it to the PeekCompleted event handler delegate. BeginPeek is called with a time-out of one minute, to initiate the asynchronous peek operation. When a PeekCompleted event is raised or the time-out expires, the message is retrieved if one exists, and its body is written to the screen. Then BeginPeek is called again to initiate a new asynchronous peek operation with the same time-out.

using System;
using System.Messaging;

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

		// Provides an entry point into the application.
		// This example performs asynchronous peek 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[]

			// Add an event handler for the PeekCompleted event.
			myQueue.PeekCompleted += new 

			// Begin the asynchronous peek operation with a time-out 
			// of one minute.
			myQueue.BeginPeek(new TimeSpan(0,1,0));

			// Do other work on the current thread.


		// Provides an event handler for the PeekCompleted
		// event.

		private static void MyPeekCompleted(Object source, 
			PeekCompletedEventArgs asyncResult)
				// Connect to the queue.
				MessageQueue mq = (MessageQueue)source;

				// End the asynchronous peek operation.
				Message m = mq.EndPeek(asyncResult.AsyncResult);

				// Display message information on the screen.
				Console.WriteLine("Message: " + (string)m.Body);

				// Restart the asynchronous peek operation, with the 
				// same time-out.
				mq.BeginPeek(new TimeSpan(0,1,0));


			catch(MessageQueueException e)
				if (e.MessageQueueErrorCode == 

				// Handle other sources of MessageQueueException.

			// Handle other exceptions.

Return to top