Export (0) Print
Expand All
0 out of 2 rated this helpful - Rate this topic

MessageQueue.BeginPeek Method

Initiates an asynchronous peek operation by telling Message Queuing to begin peeking a message and notify the event handler when finished.

Overload List

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

[Visual Basic] Overloads Public Function BeginPeek() As IAsyncResult
[C#] public IAsyncResult BeginPeek();
[C++] public: IAsyncResult* BeginPeek();
[JScript] public function BeginPeek() : IAsyncResult;

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.

[Visual Basic] Overloads Public Function BeginPeek(TimeSpan) As IAsyncResult
[C#] public IAsyncResult BeginPeek(TimeSpan);
[C++] public: IAsyncResult* BeginPeek(TimeSpan);
[JScript] public function BeginPeek(TimeSpan) : IAsyncResult;

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(TimeSpan, Object) As IAsyncResult
[C#] public IAsyncResult BeginPeek(TimeSpan, object);
[C++] public: IAsyncResult* BeginPeek(TimeSpan, Object*);
[JScript] public function BeginPeek(TimeSpan, Object) : IAsyncResult;

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. This overload receives notification, through a callback, of the identity of the event handler for the operation. 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(TimeSpan, Object, AsyncCallback) As IAsyncResult
[C#] public IAsyncResult BeginPeek(TimeSpan, object, AsyncCallback);
[C++] public: IAsyncResult* BeginPeek(TimeSpan, Object*, AsyncCallback*);
[JScript] public function BeginPeek(TimeSpan, Object, AsyncCallback) : IAsyncResult;

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, C#, C++] Note   This example shows how to use one of the overloaded versions of BeginPeek. For other examples that might be available, see the individual overload topics.
[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.

See Also

MessageQueue Class | MessageQueue Members | System.Messaging Namespace

Show:
© 2014 Microsoft. All rights reserved.