Export (0) Print
Expand All

MessageQueue.BeginPeek Method (TimeSpan, Object)

.NET Framework 1.1

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.

[Visual Basic]
Overloads Public Function BeginPeek( _
   ByVal timeout As TimeSpan, _
   ByVal stateObject As Object _
) As IAsyncResult
[C#]
public IAsyncResult BeginPeek(
 TimeSpan timeout,
 object stateObject
);
[C++]
public: IAsyncResult* BeginPeek(
 TimeSpan timeout,
 Object* stateObject
);
[JScript]
public function BeginPeek(
   timeout : TimeSpan,
 stateObject : Object
) : IAsyncResult;

Parameters

timeout
A TimeSpan that indicates the interval of time to wait for a message to become available.
stateObject
A state object, specified by the application, that contains information associated with the asynchronous operation.

Return Value

The IAsyncResult that identifies the posted asynchronous request.

Exceptions

Exception Type Condition
ArgumentException The value specified for the timeout parameter is invalid.
MessageQueueException An error occurred when accessing a Message Queuing API.

Remarks

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.

Note    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 or by retrieving the result using the PeekCompletedEventArgs.

Note   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 an 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 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, and the IsCompleted property of the operation's associated IAsyncResult is true. Because no message exists, a subsequent call to EndPeek 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.

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

Workgroup Mode Available
Local computer Yes
Local computer + direct format name Yes
Remote computer No
Remote computer + direct format name Yes

Example

[Visual Basic, C#, C++] The following 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.

[Visual Basic] 
Imports System
Imports System.Messaging


Namespace MyProject

    '/ <summary>
    '/ Provides a container class for the example.
    '/ </summary>
    Public Class MyNewQueue

        ' Represents a state object associated with each message.
        Private Shared messageNumber As Integer = 0


        '**************************************************
        ' Provides an entry point into the application.
        '         
        ' This example performs asynchronous peek 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 PeekCompleted event.
            AddHandler myQueue.PeekCompleted, AddressOf _
                MyPeekCompleted

            ' Begin the asynchronous peek operation with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
            messageNumber += 1

            ' Do other work on the current thread.
            Return
        End Sub 'Main


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

        Private Shared Sub MyPeekCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As _
            PeekCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = _
                    CType([source], MessageQueue)

                ' End the asynchronous peek operation.
                Dim m As Message = _
                    mq.EndPeek(asyncResult.AsyncResult)

                ' Display message information on the screen, 
                ' including(the) message number (state object).
                Console.WriteLine(("Message: " + _
                    CInt(asyncResult.AsyncResult.AsyncState) + _
                    " " + CStr(m.Body)))

                ' Restart the asynchronous peek operation, with the 
                ' same time-out.
                mq.BeginPeek(New TimeSpan(0, 1, 0), messageNumber)
                messageNumber += 1


            Catch e As MessageQueueException

                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine(e.ToString())

                    ' Handle other sources of MessageQueueException.

                End If

                ' Handle other exceptions.

            End Try

            Return

        End Sub 'MyPeekCompleted

    End Class 'MyNewQueue
End Namespace 'MyProject

[C#] 
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; 
        }
    }
}

[C++] 
#using <mscorlib.dll>
#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

__gc class MyNewQueue 
{
public:
    // Represents a state object associated with each message.
    static int messageNumber = 0;

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

    static void MyPeekCompleted(Object* source, 
        PeekCompletedEventArgs* asyncResult) 
    {
        try 
        {
            // Connect to the queue.
            MessageQueue* mq = dynamic_cast<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(S"Message: {0} {1}", asyncResult->AsyncResult->AsyncState , static_cast<String*>(m->Body));

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

        } 
        catch (MessageQueueException* e) 
        {
            if (e->MessageQueueErrorCode == 
                MessageQueueErrorCode::IOTimeout) 
            {
                Console::WriteLine(e);
            }

            // Handle other sources of MessageQueueException.
        }

        // Handle other exceptions.

        return; 
    }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous peek operation
// processing.
int main() 
{
    // Create an instance of MessageQueue. Set its formatter.
    MessageQueue* myQueue = new MessageQueue(S".\\myQueue");

    Type* p __gc[] = new Type* __gc[1];
    p[0] = __typeof(String);
    myQueue->Formatter = new XmlMessageFormatter( p );

    // Add an event handler for the PeekCompleted event.
    myQueue->PeekCompleted += new PeekCompletedEventHandler(0, MyNewQueue::MyPeekCompleted);

    // Begin the asynchronous peek operation with a timeout 
    // of one minute.
    myQueue->BeginPeek(TimeSpan(0, 1, 0), __box(MyNewQueue::messageNumber++));

    // Do other work on the current thread.

    return 0;
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

.NET Framework Security: 

See Also

MessageQueue Class | MessageQueue Members | System.Messaging Namespace | MessageQueue.BeginPeek Overload List | EndPeek | PeekCompleted | BeginReceive | Peek | Receive | TimeSpan

Show:
© 2015 Microsoft