Aracılığıyla paylaş

MessageQueue.BeginPeek Yöntem

  • Başvuru

Tanım

Ad Alanı:
System.Messaging
Bütünleştirilmiş Kod:
System.Messaging.dll

Message Queuing'e iletiye göz atmaya başlamasını ve bittiğinde olay işleyicisini bilgilendirmesini söyleyerek zaman uyumsuz bir göz atma işlemi başlatır.

Aşırı Yüklemeler

BeginPeek(TimeSpan, Object, AsyncCallback)

Belirtilen zaman aşımına ve belirtilen durum nesnesine sahip olan ve işlemin ömrü boyunca ilişkili bilgiler sağlayan zaman uyumsuz bir göz atma işlemi başlatır. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek(TimeSpan, Object)

Belirtilen zaman aşımına ve belirtilen durum nesnesine sahip olan ve işlemin ömrü boyunca ilişkili bilgiler sağlayan zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Belirtilen zaman aşımına sahip olan ve belirtilen bir imleç, belirtilen bir göz atma eylemi ve belirtilen bir durum nesnesi kullanan zaman uyumsuz bir göz atma işlemi başlatır. Durum nesnesi, işlemin ömrü boyunca ilişkili bilgiler sağlar. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek()

Zaman aşımı olmayan zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene kadar işlem tamamlanmaz.
BeginPeek(TimeSpan)

Belirtilen zaman aşımına sahip zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.

BeginPeek(TimeSpan, Object, AsyncCallback)

Belirtilen zaman aşımına ve belirtilen durum nesnesine sahip olan ve işlemin ömrü boyunca ilişkili bilgiler sağlayan zaman uyumsuz bir göz atma işlemi başlatır. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.

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

Parametreler

timeout
TimeSpan

bir TimeSpan iletinin kullanılabilir duruma gelmesini bekleme süresini gösteren bir.

stateObject
Object

Uygulama tarafından belirtilen ve zaman uyumsuz işlemle ilişkili bilgileri içeren bir durum nesnesi.

callback
AsyncCallback

Zaman AsyncCallback uyumsuz işlemin tamamlanması bildirimini alacak olan.

Döndürülenler

IAsyncResult

Gönderilen IAsyncResult zaman uyumsuz isteği tanımlayan.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği zaman uyumsuz bir göz atma işlemi oluşturur. Kod örneği yerel bir ileti kuyruğuna bir ileti gönderir ve ardından BeginPeek(TimeSpan, Object, AsyncCallback)çağrısı yaparak: on saniyelik bir zaman aşımı değeri; belirli bir iletiyi tanımlayan benzersiz bir tamsayı ve olay işleyicisini tanımlayan yeni bir örneğiAsyncCallback. MyPeekCompleted Bir PeekCompleted olay tetiklendiğinde, olay işleyicisi iletiye göz atarak ileti gövdesini ve tamsayı ileti tanımlayıcısını ekrana yazar.

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

Açıklamalar

Bu aşırı yüklemeyi kullandığınızda, geri çağırma parametresinde belirtilen geri çağırma, kuyrukta bir ileti kullanılabilir olduğunda veya belirtilen zaman aralığının süresi dolduğunda doğrudan çağrılır; olay PeekCompleted tetiklenmez. diğer aşırı yüklemeleri BeginPeek , olayı tetiklerken bu bileşene PeekCompleted güvenir.

PeekCompleted ayrıca kuyrukta zaten bir ileti varsa oluşturulur.

BeginPeek yöntemi hemen döndürür, ancak olay işleyici çağrılana kadar zaman uyumsuz işlem tamamlanmaz.

BeginPeek Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruğa göz atmak için çağırabilirsiniz. Zaman uyumlu bir şekilde kuyruğa göz atmak için yöntemini kullanın Peek .

Zaman uyumsuz bir işlem tamamlandıktan sonra, bildirimleri almaya devam etmek için olay işleyicisinde veya BeginReceive yeniden çağırabilirsinizBeginPeek.

BeginPeek yönteminin başlattığı zaman uyumsuz işlemi tanımlayan bir IAsyncResult döndürür. Genellikle çağrılana kadar EndPeek(IAsyncResult) kullanmasanız da, bunu IAsyncResult işlemin ömrü boyunca kullanabilirsiniz. Ancak, birkaç zaman uyumsuz işlem başlatırsanız, değerlerini IAsyncResult bir diziye yerleştirebilir ve tüm işlemlerin mi yoksa herhangi bir işlemin mi tamamlanmasının bekleneceğini belirtebilirsiniz. Bu durumda, tamamlanmış işlemi tanımlamak için özelliğini IAsyncResult kullanırsınızAsyncWaitHandle.

Durum nesnesi, durum bilgilerini işlemle ilişkilendirir. Örneğin, birden çok işlemi başlatmak için birden çok kez çağırırsanız BeginPeek , her işlemi tanımladığınız ayrı bir durum nesnesi aracılığıyla tanımlayabilirsiniz.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

BeginPeek(TimeSpan, Object)

İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir özet işlemi başlatır. Kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı gerçekleşene kadar işlem tamamlanmaz.

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

Parametreler

timeout
TimeSpan

bir TimeSpan iletinin kullanılabilir duruma gelmesini bekleme süresini gösteren bir.

stateObject
Object

Uygulama tarafından belirtilen ve zaman uyumsuz işlemle ilişkili bilgileri içeren bir durum nesnesi.

Döndürülenler

IAsyncResult

Gönderilen IAsyncResult zaman uyumsuz isteği tanımlayan.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği, ".\myQueue" kuyruk yolunu kullanarak zaman uyumsuz bir göz atma işlemi oluşturur. Bir olay işleyicisi MyPeekCompletedoluşturur ve bunu olay işleyici temsilcisine PeekCompleted ekler. BeginPeek bir dakikalık zaman aşımı ile çağrılır. her çağrısı BeginPeek , belirli bir işlemi tanımlayan benzersiz bir ilişkili tamsayıya sahiptir. Bir PeekCompleted olay tetiklendiğinde veya zaman aşımı süresi dolduğunda, varsa ileti alınır ve gövdesi ve işleme özgü tamsayı tanımlayıcısı ekrana yazılır. Ardından BeginPeek , aynı zaman aşımına ve yeni tamamlanan işlemin ilişkili tamsayısına sahip yeni bir zaman uyumsuz göz atma işlemi başlatmak için yeniden çağrılır.

#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

Açıklamalar

Zaman uyumsuz işlemede, kuyrukta bir ileti kullanılabilir olduğunda veya belirtilen zaman aralığının süresi dolduğunda olayı tetikleme PeekCompleted işlemini kullanırsınızBeginPeek.

PeekCompleted ayrıca kuyrukta zaten bir ileti varsa oluşturulur.

Bilgileri işlemin ömrü boyunca korunacak işlemle ilişkilendirmek için bu aşırı yüklemeyi kullanın. Olay işleyicisi, işlemiyle ilişkili özelliğini IAsyncResult inceleyerek AsyncState bu bilgilere erişebilir.

kullanmak BeginPeekiçin, zaman uyumsuz işlemin sonuçlarını işleyen bir olay işleyicisi oluşturun ve bunu olay temsilcinizle ilişkilendirin. BeginPeek zaman uyumsuz bir göz atma işlemi başlatır; MessageQueue , kuyruğa bir ileti geldiğinde olayın yükseltilmesiyle PeekCompleted bildirilir. daha MessageQueue sonra çağrısı EndPeek(IAsyncResult) yaparak veya kullanarak sonucu alarak iletiye PeekCompletedEventArgserişebilir.

BeginPeek yöntemi hemen döndürür, ancak olay işleyici çağrılana kadar zaman uyumsuz işlem tamamlanmaz.

BeginPeek Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruğa göz atmak için çağırabilirsiniz. Zaman uyumlu bir şekilde kuyruğa göz atmak için yöntemini kullanın Peek .

Zaman uyumsuz bir işlem tamamlandıktan sonra, bildirimleri almaya devam etmek için olay işleyicisinde veya BeginReceive yeniden çağırabilirsinizBeginPeek.

BeginPeek yönteminin başlattığı zaman uyumsuz işlemi tanımlayan bir IAsyncResult döndürür. Genellikle çağrılana kadar EndPeek(IAsyncResult) kullanmasanız da, bunu IAsyncResult işlemin ömrü boyunca kullanabilirsiniz. Ancak, birkaç zaman uyumsuz işlem başlatırsanız, değerlerini IAsyncResult bir diziye yerleştirebilir ve tüm işlemlerin mi yoksa herhangi bir işlemin mi tamamlanmasının bekleneceğini belirtebilirsiniz. Bu durumda, tamamlanmış işlemi tanımlamak için özelliğini IAsyncResult kullanırsınızAsyncWaitHandle.

Bu aşırı yükleme bir zaman aşımı ve durum nesnesi belirtir. parametresi tarafından belirtilen aralığın timeout süresi dolarsa, bu bileşen olayı tetikler PeekCompleted . İleti olmadığından, sonraki çağrısı EndPeek(IAsyncResult) bir özel durum oluşturur.

Durum nesnesi, durum bilgilerini işlemle ilişkilendirir. Örneğin, birden çok işlemi başlatmak için birden çok kez çağırırsanız BeginPeek , her işlemi tanımladığınız ayrı bir durum nesnesi aracılığıyla tanımlayabilirsiniz. Bu senaryonun çizimi için Örnek bölümüne bakın.

Durum nesnesini, işlem iş parçacıkları arasında bilgi geçirmek için de kullanabilirsiniz. Bir iş parçacığı başlatılırsa ancak zaman uyumsuz bir senaryoda geri çağırma farklı bir iş parçacığındaysa, durum nesnesi sıralanır ve olaydaki bilgilerle birlikte geri geçirilir.

ise CanReadfalse, tamamlanma olayı tetiklenir, ancak çağrılırken EndPeek(IAsyncResult)bir özel durum oluşturulur.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

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

Belirtilen zaman aşımına sahip olan ve belirtilen bir imleç, belirtilen bir özet eylemi ve belirtilen durum nesnesi kullanan zaman uyumsuz bir özet işlemi başlatır. Durum nesnesi, işlemin ömrü boyunca ilişkili bilgiler sağlar. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. Kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı gerçekleşene kadar işlem tamamlanmaz.

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

Parametreler

timeout
TimeSpan

bir TimeSpan iletinin kullanılabilir duruma gelmesini bekleme süresini gösteren bir.

cursor
Cursor

Cursor İleti kuyruğunda belirli bir konumu koruyan.

action
PeekAction

Değerlerden PeekAction biri. Kuyruktaki geçerli iletiye mi yoksa sonraki iletiye mi göz atılmayacağını gösterir.

state
Object

Uygulama tarafından belirtilen ve zaman uyumsuz işlemle ilişkili bilgileri içeren bir durum nesnesi.

callback
AsyncCallback

Zaman AsyncCallback uyumsuz işlem tamamlama bildirimini alan.

Döndürülenler

IAsyncResult

Gönderilen IAsyncResult zaman uyumsuz isteği tanımlayan.

Özel durumlar

ArgumentOutOfRangeException

parametresi için action veya PeekAction.Next dışında PeekAction.Current bir değer belirtildi.

ArgumentNullException

cursor parametresidirnull.

ArgumentException

parametresi için timeout belirtilen değer geçerli değil.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Açıklamalar

Bu aşırı yüklemeyi kullandığınızda, geri çağırma parametresinde belirtilen geri çağırma, kuyrukta bir ileti kullanılabilir olduğunda veya belirtilen sürenin süresi dolduğunda doğrudan çağrılır. Olay PeekCompleted tetiklenmez. diğer aşırı yüklemeleri BeginPeek bu bileşeni kullanarak olayı tetikler PeekCompleted .

PeekCompleted , kuyrukta zaten bir ileti varsa da tetiklenmiş olur.

BeginPeek yöntemi hemen döndürür, ancak olay işleyicisi çağrılana kadar zaman uyumsuz işlem tamamlanmaz.

BeginPeek Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruğa göz atmak için çağırabilirsiniz. Sıraya zaman uyumlu bir şekilde göz atmak için yöntemini kullanın Peek .

Zaman uyumsuz bir işlem tamamlandıktan sonra, bildirimleri almaya devam etmek için olay işleyicisinde veya BeginReceive yeniden çağırabilirsinizBeginPeek.

BeginPeek yöntemi tarafından başlatılan zaman uyumsuz işlemi tanımlayan bir IAsyncResult döndürür. Genellikle IAsyncResult çağrılana kadar EndPeek(IAsyncResult) kullanmasanız da, bunu işlemin ömrü boyunca kullanabilirsiniz. Ancak, birkaç zaman uyumsuz işlem başlatırsanız, değerlerini IAsyncResult bir diziye yerleştirebilir ve tüm işlemlerin veya herhangi bir işlemin tamamlanmasının beklenip beklenmeyeceğini belirtebilirsiniz. Bu durumda, tamamlanan işlemi tanımlamak için özelliğini IAsyncResult kullanınAsyncWaitHandle.

Durum nesnesi, durum bilgilerini işlemle ilişkilendirir. Örneğin, birden çok işlem başlatmak için birden çok kez çağırırsanız BeginPeek , her işlemi tanımladığınız ayrı bir durum nesnesi aracılığıyla tanımlayabilirsiniz.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

BeginPeek()

Zaman aşımı olmayan zaman uyumsuz bir özet işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene kadar işlem tamamlanmaz.

public:
 IAsyncResult ^ BeginPeek();
public IAsyncResult BeginPeek ();
member this.BeginPeek : unit -> IAsyncResult
Public Function BeginPeek () As IAsyncResult

Döndürülenler

IAsyncResult

Gönderilen IAsyncResult zaman uyumsuz isteği tanımlayan.

Özel durumlar

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği adlı MyPeekCompletedbir olay işleyicisi oluşturur, bunu olay işleyici temsilcisine PeekCompleted ekler ve ".\myQueue" yolunda bulunan kuyrukta zaman uyumsuz bir özet işlemi başlatmak için çağrı BeginPeek yapar. Bir PeekCompleted olay tetiklendiğinde, örnek iletiye göz atar ve gövdesini ekrana yazar. Örnek daha sonra yeni bir zaman uyumsuz özet işlemi başlatmak için yeniden çağırır BeginPeek .

#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

Açıklamalar

Zaman uyumsuz işlemede, kuyrukta bir ileti kullanılabilir olduğunda olayı tetikleme PeekCompleted amacıyla kullanırsınızBeginPeek.

PeekCompleted , kuyrukta zaten bir ileti varsa da tetiklenmiş olur.

kullanmak BeginPeekiçin, zaman uyumsuz işlemin sonuçlarını işleyen ve olay temsilcinizle ilişkilendiren bir olay işleyicisi oluşturun. BeginPeek zaman uyumsuz bir özet işlemi başlatır; MessageQueue , kuyruğa bir ileti geldiğinde olayın yükseltilmesiyle PeekCompleted bildirilir. daha MessageQueue sonra çağrısı yaparak EndPeek(IAsyncResult) veya kullanarak sonucu alarak iletiye PeekCompletedEventArgserişebilir.

BeginPeek yöntemi hemen döndürür, ancak olay işleyicisi çağrılana kadar zaman uyumsuz işlem tamamlanmaz.

BeginPeek Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruğa göz atmak için çağırabilirsiniz. Sıraya zaman uyumlu bir şekilde göz atmak için yöntemini kullanın Peek .

Zaman uyumsuz bir işlem tamamlandıktan sonra, bildirimleri almaya devam etmek için olay işleyicisinde veya BeginReceive yeniden çağırabilirsinizBeginPeek.

IAsyncResult döndürenBeginPeek, yöntemin başlattığı zaman uyumsuz işlemi tanımlar. Genellikle IAsyncResult çağrılana kadar EndPeek(IAsyncResult) kullanmasanız da, bunu işlemin ömrü boyunca kullanabilirsiniz. Ancak, birkaç zaman uyumsuz işlem başlatırsanız, değerlerini IAsyncResult bir diziye yerleştirebilir ve tüm işlemlerin veya herhangi bir işlemin tamamlanmasının beklenip beklenmeyeceğini belirtebilirsiniz. Bu durumda, tamamlanmış işlemi tanımlamak için özelliğini IAsyncResult kullanırsınızAsyncWaitHandle.

ise CanReadfalsetamamlama olayı oluşturulur, ancak çağrılırken EndPeek(IAsyncResult)bir özel durum oluşturulur.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

BeginPeek(TimeSpan)

Belirtilen zaman aşımına sahip zaman uyumsuz bir özet işlemi başlatır. Kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı gerçekleşene kadar işlem tamamlanmaz.

public:
 IAsyncResult ^ BeginPeek(TimeSpan timeout);
public IAsyncResult BeginPeek (TimeSpan timeout);
member this.BeginPeek : TimeSpan -> IAsyncResult
Public Function BeginPeek (timeout As TimeSpan) As IAsyncResult

Parametreler

timeout
TimeSpan

bir TimeSpan iletinin kullanılabilir duruma gelmesini bekleme süresini gösteren bir.

Döndürülenler

IAsyncResult

Gönderilen IAsyncResult zaman uyumsuz isteği tanımlayan.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil.

MessageQueueException

Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği, ".\myQueue" kuyruk yolunu kullanarak zaman uyumsuz bir göz atma işlemi oluşturur. Bir olay işleyicisi MyPeekCompletedoluşturur ve bunu olay işleyicisi temsilcisine PeekCompleted ekler. BeginPeek , zaman uyumsuz göz atma işlemini başlatmak için bir dakikalık zaman aşımı ile çağrılır. Bir PeekCompleted olay tetiklendiğinde veya zaman aşımı süresi dolduğunda, varsa ileti alınır ve gövdesi ekrana yazılır. Ardından BeginPeek , aynı zaman aşımı ile yeni bir zaman uyumsuz özet işlemi başlatmak için yeniden çağrılır.

#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

Açıklamalar

Zaman uyumsuz işlemede, kuyrukta bir ileti kullanılabilir olduğunda veya belirtilen zaman aralığının süresi dolduğunda olayı tetikleme PeekCompleted amacıyla kullanırsınızBeginPeek.

PeekCompleted , kuyrukta zaten bir ileti varsa da tetiklenmiş olur.

kullanmak BeginPeekiçin, zaman uyumsuz işlemin sonuçlarını işleyen ve olay temsilcinizle ilişkilendiren bir olay işleyicisi oluşturun. BeginPeek zaman uyumsuz bir özet işlemi başlatır; MessageQueue , kuyruğa bir ileti geldiğinde olayın yükseltilmesiyle PeekCompleted bildirilir. daha MessageQueue sonra çağrısı yaparak EndPeek(IAsyncResult) veya kullanarak sonucu alarak iletiye PeekCompletedEventArgserişebilir.

BeginPeek yöntemi hemen döndürür, ancak olay işleyicisi çağrılana kadar zaman uyumsuz işlem tamamlanmaz.

BeginPeek Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruğa göz atmak için çağırabilirsiniz. Sıraya zaman uyumlu bir şekilde göz atmak için yöntemini kullanın Peek .

Zaman uyumsuz bir işlem tamamlandıktan sonra, bildirimleri almaya devam etmek için olay işleyicisinde veya BeginReceive yeniden çağırabilirsinizBeginPeek.

IAsyncResult döndürenBeginPeek, yöntemin başlattığı zaman uyumsuz işlemi tanımlar. Genellikle IAsyncResult çağrılana kadar EndPeek(IAsyncResult) kullanmasanız da, bunu işlemin ömrü boyunca kullanabilirsiniz. Ancak, birkaç zaman uyumsuz işlem başlatırsanız, değerlerini IAsyncResult bir diziye yerleştirebilir ve tüm işlemlerin veya herhangi bir işlemin tamamlanmasının beklenip beklenmeyeceğini belirtebilirsiniz. Bu durumda, tamamlanmış işlemi tanımlamak için özelliğini IAsyncResult kullanırsınızAsyncWaitHandle.

Bu aşırı yükleme bir zaman aşımı belirtir. parametresi tarafından belirtilen aralığın timeout süresi dolarsa, bu bileşen olayı tetikler PeekCompleted . İleti olmadığından, sonraki bir çağrısı EndPeek(IAsyncResult) özel durum oluşturur.

ise CanReadfalsetamamlama olayı oluşturulur, ancak çağrılırken EndPeek(IAsyncResult)bir özel durum oluşturulur.

Aşağıdaki tabloda bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu Kullanılabilir
Yerel bilgisayar Yes
Yerel bilgisayar ve doğrudan biçim adı Yes
Uzak bilgisayar No
Uzak bilgisayar ve doğrudan biçim adı Yes

Ayrıca bkz.

Şunlara uygulanır

İş Parçacığı Güvenliği

yöntemi iş parçacığı güvenli değil.