BeginPeek Method (TimeSpan, Object)

MessageQueue.BeginPeek Method (TimeSpan, Object)

 

Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. 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,
	object stateObject
)

Parameters

timeout
Type: System.TimeSpan

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

stateObject
Type: System.Object

A state object, specified by the application, that contains information associated with the asynchronous operation.

Return Value

Type: System.IAsyncResult

The IAsyncResult that identifies the posted asynchronous request.

Exception Condition
ArgumentException

The value specified for the timeout parameter is not valid.

MessageQueueException

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.

Use this overload to associate information with the operation that will be preserved throughout the operation's lifetime. The event handler can access this information by looking at the AsyncState property of the IAsyncResult that is associated with the operation.

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.

BeginPeek returns a IAsyncResult that 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 and a state object. 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.

The state object associates state information with the operation. For example, if you call BeginPeek multiple times to initiate multiple operations, you can identify each operation through a separate state object that you define. For an illustration of this scenario, see the Example section.

You can also use the state object to pass information across process threads. If a thread is started but the callback is on a different thread in an asynchronous scenario, the state object is marshaled and passed back along with information from the event.

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 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. Each call to BeginPeek has a unique associated integer that identifies that particular operation. When a PeekCompleted event is raised or the time-out expired, the message, if one exists, is retrieved and its body and the operation-specific integer identifier are written to the screen. Then BeginPeek is called again to initiate a new asynchronous peek operation with the same time-out and the associated integer of the just completed operation.

using System;
using System.Messaging;

namespace MyProject
{
	/// <summary>
	/// Provides a container class for the example.
	/// </summary>
	public class MyNewQueue
	{
		// Represents a state object associated with each message.
		static int messageNumber = 0;

		//**************************************************
		// 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 with a time-out 
			// of one minute.
			myQueue.BeginPeek(new TimeSpan(0,1,0), messageNumber++);

			// Do other work on the current thread.

			return;
		}


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

		private static void MyPeekCompleted(Object source, 
			PeekCompletedEventArgs asyncResult)
		{
			try
			{
				// 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, 
				// including the message number (state object).
				Console.WriteLine("Message: " + 
					(int)asyncResult.AsyncResult.AsyncState + " " 
					+(string)m.Body);

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

			}

			catch(MessageQueueException e)
			{
				if (e.MessageQueueErrorCode == 
					MessageQueueErrorCode.IOTimeout)
				{
					Console.WriteLine(e.ToString());
				}

				// Handle other sources of MessageQueueException.
			}

			// Handle other exceptions.

			return; 
		}
	}
}
Return to top
Show:
© 2016 Microsoft