MessageQueue.BeginPeek Metode

Referensi

Definisi

Ruang nama:: System.Messaging

Rakitan:: System.Messaging.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Memulai operasi intip asinkron dengan memberi tahu Antrean Pesan untuk mulai mengintip pesan dan memberi tahu penanganan aktivitas setelah selesai.

Overload

BeginPeek(TimeSpan, Object, AsyncCallback)	Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginPeek(TimeSpan, Object)	Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan yang menggunakan kursor tertentu, tindakan cuplikan tertentu, dan objek status tertentu. Objek status menyediakan informasi terkait sepanjang masa operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginPeek()	Memulai operasi intip asinkron yang tidak memiliki waktu habis. Operasi tidak selesai sampai pesan tersedia dalam antrean.
BeginPeek(TimeSpan)	Memulai operasi intip asinkron yang memiliki waktu habis yang ditentukan. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

BeginPeek(TimeSpan, Object, AsyncCallback)

Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

public IAsyncResult BeginPeek (TimeSpan timeout, object stateObject, AsyncCallback callback);

member this.BeginPeek : TimeSpan * obj * AsyncCallback -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

stateObject: Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

callback: AsyncCallback

AsyncCallback yang akan menerima pemberitahuan penyelesaian operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi intip asinkron. Contoh kode mengirim pesan ke antrean pesan lokal, lalu memanggil BeginPeek(TimeSpan, Object, AsyncCallback), meneruskan: nilai waktu habis sepuluh detik; bilangan bulat unik yang mengidentifikasi pesan tertentu; dan instans AsyncCallback baru yang mengidentifikasi penanganan aktivitas, MyPeekCompleted. PeekCompleted Saat peristiwa dimunculkan, penanganan aktivitas mengintip pesan dan menulis isi pesan dan pengidentifikasi pesan bilangan bulat ke layar.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();      
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the PeekCompleted event.
void MyPeekCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous peek operation.
    Message^ msg = queue->EndPeek(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    // Receive the message. This will remove the message from the queue.
    msg = queue->Receive(TimeSpan::FromSeconds(10.0));

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    CreateQueue(".\\exampleQueue", false);

    // Connect to a queue on the local computer.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // Send a message to the queue.
    queue->Send("Example Message");

    // Begin the asynchronous peek operation.
    queue->BeginPeek(TimeSpan::FromSeconds(10.0), messageNumber++,
        gcnew AsyncCallback(MyPeekCompleted));

    // Simulate doing other work on the current thread.
    System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

    queue->Close();
}

using System;
using System.Messaging;

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

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous peek operation.
        queue.BeginPeek(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyPeekCompleted));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the PeekCompleted event.
    private static void MyPeekCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous peek operation.
        Message msg = queue.EndPeek(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);

        // Receive the message. This will remove the message from the queue.
        msg = queue.Receive(TimeSpan.FromSeconds(10.0));
    }
}

Keterangan

Ketika Anda menggunakan kelebihan beban ini, panggilan balik yang ditentukan dalam parameter panggilan balik dipanggil secara langsung ketika pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa; PeekCompleted peristiwa tidak dinaikkan. Kelebihan beban lain mengandalkan BeginPeek komponen ini untuk meningkatkan PeekCompleted peristiwa.

PeekCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Metode BeginPeek ini segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginPeek asinkron, Anda dapat memanggilnya untuk mengintip antrean tanpa memblokir utas eksekusi saat ini. Untuk mengintip antrean secara sinkron, gunakan Peek metode .

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

BeginPeek mengembalikan yang IAsyncResult mengidentifikasi operasi asinkron yang dimulai oleh metode . Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndPeek(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti dari IAsyncResult untuk mengidentifikasi operasi yang telah selesai.

Objek status mengaitkan informasi status dengan operasi. Misalnya, jika Anda memanggil BeginPeek beberapa kali untuk memulai beberapa operasi, Anda dapat mengidentifikasi setiap operasi melalui objek status terpisah yang Anda tentukan.

Tabel berikut ini memperlihatkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja	Tersedia
Komputer lokal	Ya
Komputer lokal dan nama format langsung	Ya
Komputer jarak jauh	Tidak
Komputer jarak jauh dan nama format langsung	Ya

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan, Object)

Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Object ^ stateObject);

public IAsyncResult BeginPeek (TimeSpan timeout, object stateObject);

member this.BeginPeek : TimeSpan * obj -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

stateObject: Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi intip asinkron, menggunakan jalur antrean ".\myQueue". Ini membuat penanganan aktivitas, MyPeekCompleted, dan melampirkannya ke PeekCompleted delegasi penanganan aktivitas. BeginPeek dipanggil, dengan waktu habis satu menit. Setiap panggilan ke BeginPeek memiliki bilangan bulat terkait unik yang mengidentifikasi operasi tertentu. PeekCompleted Saat peristiwa dinaikkan atau waktu habis kedaluwarsa, pesan, jika ada, diambil dan isinya serta pengidentifikasi bilangan bulat khusus operasi ditulis ke layar. Kemudian BeginPeek dipanggil lagi untuk memulai operasi intip asinkron baru dengan waktu habis yang sama dan bilangan bulat terkait dari operasi yang baru saja selesai.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref 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( "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), 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 = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

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

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

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue3
    {
        // 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;
        }
    }
}

Imports System.Messaging


   
' Provides a container class for the example.

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



        ' 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

End Class

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginPeek untuk menaikkan PeekCompleted peristiwa saat pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa.

PeekCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Gunakan kelebihan beban ini untuk mengaitkan informasi dengan operasi yang akan dipertahankan sepanjang masa operasi. Penanganan aktivitas dapat mengakses informasi ini dengan melihat AsyncState properti dari IAsyncResult yang terkait dengan operasi.

Untuk menggunakan BeginPeek, buat penanganan aktivitas yang memproses hasil operasi asinkron, dan kaitkan dengan delegasi peristiwa Anda. BeginPeek memulai operasi intip asinkron; MessageQueue diberi tahu, melalui penggalangan PeekCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndPeek(IAsyncResult) atau dengan mengambil hasilnya menggunakan PeekCompletedEventArgs.

Metode BeginPeek ini segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginPeek asinkron, Anda dapat memanggilnya untuk mengintip antrean tanpa memblokir utas eksekusi saat ini. Untuk mengintip antrean secara sinkron, gunakan Peek metode .

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

Kelebihan beban ini menentukan waktu habis dan objek status. Jika interval yang ditentukan oleh parameter kedaluwarsa timeout , komponen ini akan menaikkan PeekCompleted peristiwa. Karena tidak ada pesan, panggilan berikutnya ke EndPeek(IAsyncResult) akan melemparkan pengecualian.

Anda juga dapat menggunakan objek status untuk meneruskan informasi di seluruh utas proses. Jika utas dimulai tetapi panggilan balik berada di utas yang berbeda dalam skenario asinkron, objek status dinamai dan diteruskan kembali bersama dengan informasi dari peristiwa tersebut.

Jika CanRead adalah false, peristiwa penyelesaian dinaikkan, tetapi pengecualian akan dilemparkan saat memanggil EndPeek(IAsyncResult).

Tabel berikut ini memperlihatkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja	Tersedia
Komputer lokal	Ya
Komputer lokal dan nama format langsung	Ya
Komputer jarak jauh	Tidak
Komputer jarak jauh dan nama format langsung	Ya

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Memulai operasi intip asinkron yang memiliki batas waktu tertentu dan yang menggunakan kursor tertentu, tindakan intip tertentu, dan objek status tertentu. Objek status menyediakan informasi terkait sepanjang masa operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::PeekAction action, System::Object ^ state, AsyncCallback ^ callback);

public IAsyncResult BeginPeek (TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.PeekAction action, object state, AsyncCallback callback);

member this.BeginPeek : TimeSpan * System.Messaging.Cursor * System.Messaging.PeekAction * obj * AsyncCallback -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan, cursor As Cursor, action As PeekAction, state As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

cursor: Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

action: PeekAction

Salah PeekAction satu nilai. Menunjukkan apakah akan mengintip pesan saat ini dalam antrean, atau pesan berikutnya.

state: Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

callback: AsyncCallback

AsyncCallback yang menerima pemberitahuan penyelesaian operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentOutOfRangeException

Nilai selain PeekAction.Current atau PeekAction.Next ditentukan untuk action parameter .

ArgumentNullException

Parameternya cursor adalah null.

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Keterangan

Ketika Anda menggunakan kelebihan beban ini, panggilan balik yang ditentukan dalam parameter panggilan balik dipanggil secara langsung ketika pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa. Peristiwa PeekCompleted tidak dinaikkan. Kelebihan beban lainnya mengandalkan BeginPeek komponen ini untuk menaikkan PeekCompleted peristiwa.

PeekCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Metode BeginPeek segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginPeek asinkron, Anda dapat memanggilnya untuk mengintip antrean tanpa memblokir utas eksekusi saat ini. Untuk mengintip antrean secara sinkron, gunakan Peek metode .

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

BeginPeek IAsyncResult mengembalikan yang mengidentifikasi operasi asinkron yang dimulai oleh metode . Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndPeek(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, gunakan AsyncWaitHandle properti dari IAsyncResult untuk mengidentifikasi operasi yang telah selesai.

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja	Tersedia
Komputer lokal	Ya
Komputer lokal dan nama format langsung	Ya
Komputer jarak jauh	Tidak
Komputer jarak jauh dan nama format langsung	Ya

Lihat juga

Berlaku untuk

BeginPeek()

Memulai operasi intip asinkron yang tidak memiliki waktu habis. Operasi tidak selesai sampai pesan tersedia dalam antrean.

public:
 IAsyncResult ^ BeginPeek();

public IAsyncResult BeginPeek ();

member this.BeginPeek : unit -> IAsyncResult

Public Function BeginPeek () As IAsyncResult

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat penanganan aktivitas bernama MyPeekCompleted, melampirkannya ke PeekCompleted delegasi penanganan aktivitas, dan memanggil BeginPeek untuk memulai operasi intip asinkron pada antrean yang terletak di jalur ".\myQueue". PeekCompleted Saat peristiwa dinaikkan, contoh mengintip pesan dan menulis isinya ke layar. Contoh kemudian memanggil BeginPeek lagi untuk memulai operasi intip asinkron baru.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This example performs asynchronous peek operation
// processing.
//*************************************************
ref class MyNewQueue
{
public:

   // Provides an event handler for the PeekCompleted
   // event.
   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( "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 = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

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

   // Begin the asynchronous peek operation.
   myQueue->BeginPeek();

   // Do other work on the current thread.
   return 0;
}

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

Imports System.Messaging





' Provides a container class for the example.
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


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

End Class

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginPeek untuk menaikkan PeekCompleted peristiwa saat pesan tersedia dalam antrean.

PeekCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginPeek, buat penanganan aktivitas yang memproses hasil operasi asinkron, dan kaitkan dengan delegasi peristiwa Anda. BeginPeek memulai operasi intip asinkron; MessageQueue diberi tahu, melalui peningkatan PeekCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndPeek(IAsyncResult) atau dengan mengambil hasilnya menggunakan PeekCompletedEventArgs.

Metode BeginPeek segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginPeek asinkron, Anda dapat memanggilnya untuk mengintip antrean tanpa memblokir utas eksekusi saat ini. Untuk mengintip antrean secara sinkron, gunakan Peek metode .

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginPeek mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndPeek(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti untuk IAsyncResult mengidentifikasi operasi yang telah selesai.

Jika CanRead adalah false, peristiwa penyelesaian dinaikkan, tetapi pengecualian akan dilemparkan saat memanggil EndPeek(IAsyncResult).

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja	Tersedia
Komputer lokal	Ya
Komputer lokal dan nama format langsung	Ya
Komputer jarak jauh	Tidak
Komputer jarak jauh dan nama format langsung	Ya

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan)

Memulai operasi intip asinkron yang memiliki waktu habis yang ditentukan. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);

public IAsyncResult BeginPeek (TimeSpan timeout);

member this.BeginPeek : TimeSpan -> IAsyncResult

Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parameter

timeout: TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi intip asinkron, menggunakan jalur antrean ".\myQueue". Ini membuat penanganan aktivitas, MyPeekCompleted, dan melampirkannya ke PeekCompleted delegasi penanganan aktivitas. BeginPeek dipanggil dengan waktu habis satu menit, untuk memulai operasi intip asinkron. PeekCompleted Saat peristiwa dinaikkan atau waktu habis berakhir, pesan diambil jika ada, dan isinya ditulis ke layar. Kemudian BeginPeek dipanggil lagi untuk memulai operasi intip asinkron baru dengan waktu habis yang sama.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   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.
         Console::WriteLine( "Message: {0}", static_cast<String^>(m->Body) );

         // Restart the asynchronous peek operation, with the 
         // same time-out.
         mq->BeginPeek( TimeSpan(0,1,0) );
      }
      catch ( MessageQueueException^ e ) 
      {
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( e );
         }

         // Handle other sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

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

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

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue2
    {
        //**************************************************
        // 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));

            // 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.
                Console.WriteLine("Message: " + (string)m.Body);

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

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

                // Handle other sources of MessageQueueException.
            }

            // Handle other exceptions.

            return;
        }
    }
}

Imports System.Messaging


' Provides a container class for the example.
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 with a time-out 
            ' of one minute.
            myQueue.BeginPeek(New TimeSpan(0, 1, 0))

            ' Do other work on the current thread.
            Return

        End Sub



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

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

            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

End Class

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginPeek untuk menaikkan PeekCompleted peristiwa saat pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa.

PeekCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginPeek, buat penanganan aktivitas yang memproses hasil operasi asinkron, dan kaitkan dengan delegasi peristiwa Anda. BeginPeek memulai operasi intip asinkron; MessageQueue diberi tahu, melalui peningkatan PeekCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndPeek(IAsyncResult) atau dengan mengambil hasilnya menggunakan PeekCompletedEventArgs.

Metode BeginPeek segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginPeek asinkron, Anda dapat memanggilnya untuk mengintip antrean tanpa memblokir utas eksekusi saat ini. Untuk mengintip antrean secara sinkron, gunakan Peek metode .

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginPeek mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndPeek(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti dari IAsyncResult untuk mengidentifikasi operasi yang telah selesai.

Kelebihan beban ini menentukan waktu habis. Jika interval yang ditentukan oleh parameter kedaluwarsa timeout , komponen ini akan menaikkan PeekCompleted peristiwa. Karena tidak ada pesan, panggilan berikutnya ke EndPeek(IAsyncResult) akan melemparkan pengecualian.

Jika CanRead adalah false, peristiwa penyelesaian dinaikkan, tetapi pengecualian akan dilemparkan saat memanggil EndPeek(IAsyncResult).

Tabel berikut ini memperlihatkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja	Tersedia
Komputer lokal	Ya
Komputer lokal dan nama format langsung	Ya
Komputer jarak jauh	Tidak
Komputer jarak jauh dan nama format langsung	Ya

Lihat juga

Berlaku untuk

Keamanan Thread

Metode ini tidak aman untuk utas.

Bagikan melalui

MessageQueue.BeginPeek Metode

Definisi

Overload

BeginPeek(TimeSpan, Object, AsyncCallback)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan, Object)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

BeginPeek()

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

BeginPeek(TimeSpan)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Keamanan Thread

Sumber Daya Tambahan: