Export (0) Print
Expand All
This topic has not yet been rated - Rate this topic

PeekCompletedEventArgs Class

Provides data for the PeekCompleted event. When your asynchronous peek operation calls an event handler, an instance of this class is passed to the handler.

For a list of all members of this type, see PeekCompletedEventArgs Members.

System.Object
   System.EventArgs
      System.Messaging.PeekCompletedEventArgs

[Visual Basic]
Public Class PeekCompletedEventArgs
   Inherits EventArgs
[C#]
public class PeekCompletedEventArgs : EventArgs
[C++]
public __gc class PeekCompletedEventArgs : public EventArgs
[JScript]
public class PeekCompletedEventArgs extends EventArgs

Thread Safety

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Remarks

When you use event notification to peek (read without removing) messages asynchronously from the queue, you must create a method that handles your message processing. Your code must call BeginPeek to begin the asynchronous processing. When a message is peeked, your application is notified through the PeekCompleted event. An instance of PeekCompletedEventArgs is passed into the event delegate that calls your event handler. The data associated with the PeekCompleted event is contained in the delegate's AsyncResult parameter.

Note   There are two ways to provide notification of event completion: event notification and callbacks. PeekCompletedEventArgs is used only with event notification. For information comparing callbacks and event notification, see "Events vs. Callbacks" on MSDN.

PeekCompletedEventArgs provides access to the message that initiated the end of the asynchronous peek operation, through the Message member. This is an alternate access to the message, and behaves much the same as a call to MessageQueue.EndPeek.

Example

[Visual Basic, C#, C++] The following example creates an event handler for the PeekCompleted event and associates it with the event delegate by using the PeekCompletedEventHandler. The event handler, MyPeekCompleted, peeks a message and writes its label to the screen.

[Visual Basic] 
Imports System
Imports 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 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.
            myQueue.BeginPeek()

            ' 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)

            ' 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.
            Console.WriteLine(("Message: " + CStr(m.Body)))

            ' Restart the asynchronous peek operation.
            mq.BeginPeek()

            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
    {

        //**************************************************
        // 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; 
        }
    }
}

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

using namespace System;
using namespace System::Messaging;

// This example performs asynchronous peek operation
// processing.
//*************************************************

__gc class MyNewQueue 
{
// Provides an event handler for the PeekCompleted
// event.
public:
    static void MyPeekCompleted(Object* source, PeekCompletedEventArgs* asyncResult) 
    {
        // 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.
        Console::WriteLine(S"Message: {0}", static_cast<String*>(m->Body));

        // Restart the asynchronous peek operation.
        mq->BeginPeek();

        return; 
    }
};

// Provides an entry point into the application.
//         

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.
    myQueue->BeginPeek();

    // 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

Namespace: System.Messaging

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

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

See Also

PeekCompletedEventArgs Members | System.Messaging Namespace | MessageQueue | PeekCompletedEventHandler | PeekCompleted | BeginPeek | EndPeek | Message

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.