Export (0) Print
Expand All

MessageQueue.BeginPeek Method

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

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

public IAsyncResult BeginPeek()

Return Value

Type: System.IAsyncResult
The IAsyncResult that identifies the posted asynchronous request.

ExceptionCondition
MessageQueueException

An error occurred when accessing a Message Queuing method.

In asynchronous processing, you use BeginPeek to raise the PeekCompleted event when a message becomes available in the queue.

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.

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

Available

Local computer

Yes

Local computer and direct format name

Yes

Remote computer

No

Remote computer and direct format name

Yes

The following code example creates an event handler named MyPeekCompleted, attaches it to the PeekCompleted event handler delegate, and calls BeginPeek to initiate an asynchronous peek operation on the queue that is located at the path ".\myQueue". When a PeekCompleted event is raised, the example peeks the message and writes its body to the screen. The example then calls BeginPeek again to initiate a new asynchronous peek operation.

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[]
				{typeof(String)});

			// Add an event handler for the PeekCompleted event.
			myQueue.PeekCompleted += new 
				PeekCompletedEventHandler(MyPeekCompleted);
			
			// Begin the asynchronous peek operation.
			myQueue.BeginPeek();
			
			// Do other work on the current thread. 

			return;
		}


		//************************************************** 
		// 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.
			mq.BeginPeek();
			
			return; 
		}
	}
}

.NET Framework

Supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Show:
© 2014 Microsoft