MessageQueue.BeginReceive Yöntem

Başvuru

Tanım

Ad Alanı:: System.Messaging

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

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Message Queuing'e ileti almaya başlamasını ve bittiğinde olay işleyicisini bilgilendirmesini bildirerek zaman uyumsuz bir alma işlemi başlatır.

Aşırı Yüklemeler

BeginReceive()	Zaman aşımı olmayan zaman uyumsuz bir alma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene kadar işlem tamamlanmaz.
BeginReceive(TimeSpan)	Belirtilen zaman aşımına sahip zaman uyumsuz alma işlemini başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive(TimeSpan, Object)	İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir alma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive(TimeSpan, Object, AsyncCallback)	İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir alma 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.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Belirtilen zaman aşımına sahip olan ve belirtilen bir imleç ile belirtilen durum nesnesini kullanan zaman uyumsuz bir alma 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.

BeginReceive()

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

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive ();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () 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 zaman uyumsuz istekleri zincirler. Yerel bilgisayarda "myQueue" adlı bir kuyruk olduğunu varsayar. işlevi, Main yordam tarafından MyReceiveCompleted işlenen zaman uyumsuz işlemi başlatır. MyReceiveCompleted geçerli iletiyi işler ve yeni bir zaman uyumsuz alma işlemi başlatır.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// 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 ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

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

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // 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 ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' 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 ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

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

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

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Aşağıdaki kod örneği zaman uyumsuz istekleri kuyruğa alır. çağrısı BeginReceive , dönüş değerinde öğesini AsyncWaitHandle kullanır. Yordam, Main çıkmadan önce tüm zaman uyumsuz işlemlerin tamamlanmasını bekler.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// 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 ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

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 receive
        // 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 ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' 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 ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

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

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

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Açıklamalar

Zaman uyumsuz işlemede, kuyruktan bir ileti kaldırıldığında olayı tetikleme ReceiveCompleted işlemini kullanırsınızBeginReceive.

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

kullanmak BeginReceiveiçin, zaman uyumsuz işlemin sonuçlarını işleyen ve olay temsilcinizle ilişkilendiren bir olay işleyicisi oluşturun. BeginReceive zaman uyumsuz bir alma işlemi başlatır; MessageQueue , kuyruğa bir ileti geldiğinde olayın yükseltilmesiyle ReceiveCompleted bildirilir. daha MessageQueue sonra çağrısı EndReceive(IAsyncResult)yaparak iletiye erişebilir.

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

BeginReceive Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruktan bir ileti almak için çağırabilirsiniz. Bir iletiyi zaman uyumlu bir şekilde almak için yöntemini kullanın Receive .

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ürenBeginReceive, yönteminin başlattığı zaman uyumsuz işlemi tanımlar. Genellikle çağrılana kadar EndReceive(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.

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

İşlemlerle zaman uyumsuz çağrıyı BeginReceive kullanmayın. İşlemsel zaman uyumsuz bir işlem gerçekleştirmek istiyorsanız çağrısı BeginPeekyapın ve işlemi ve (zaman uyumlu) Receive yöntemini göz atma işlemi için oluşturduğunuz olay işleyicisine yerleştirin. Olay işleyiciniz aşağıdaki C# kodunda gösterildiği gibi işlevler içerebilir.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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

BeginReceive(TimeSpan)

Belirtilen zaman aşımına sahip zaman uyumsuz alma işlemini başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive (TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (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

Parametre için belirtilen değer, büyük olasılıkla negatif bir sayıyı temsil ettiği için timeout 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 alma işlemi oluşturur. Kod örneği bir MyReceiveCompletedolay işleyicisi oluşturur ve bunu olay işleyici temsilcisine ReceiveCompleted ekler. Kod örneği yerel ileti kuyruğuna bir ileti gönderir ve ardından BeginReceive(TimeSpan)çağrısı yaparak on saniyelik bir zaman aşımı değeri iletir. Bir ReceiveCompleted olay tetiklendiğinde, olay işleyicisi iletiyi alır ve ileti gövdesini 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 ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

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

int 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.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

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

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

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

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}


using System;
using System.Messaging;

public class QueueExample
{
    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");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

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

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // 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 ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

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

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 ReceiveCompleted işlemini kullanırsınızBeginReceive.

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

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

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

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

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

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 ReceiveCompleted . İleti olmadığından, sonraki çağrısı EndReceive(IAsyncResult) bir özel durum oluşturur.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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

BeginReceive(TimeSpan, Object)

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

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

public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject);

member this.BeginReceive : TimeSpan * obj -> IAsyncResult

Public Function BeginReceive (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 zaman uyumsuz bir alma işlemi oluşturur. Kod örneği bir MyReceiveCompletedolay işleyicisi oluşturur ve bunu olay işleyici temsilcisine ReceiveCompleted ekler. Kod örneği yerel ileti kuyruğuna bir ileti gönderir, ardından BeginReceive(TimeSpan, Object)çağrısı yaparak on saniyelik bir zaman aşımı değeri ve belirli bir iletiyi tanımlayan benzersiz bir tamsayı iletir. Bir ReceiveCompleted olay tetiklendiğinde, olay işleyicisi iletiyi alır ve 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 ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

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

    queue->Close();
}

int 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.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

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

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

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

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        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");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

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

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // 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 ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

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

Açıklamalar

ReceiveCompleted 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 bilgileri algılayabilir.

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

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

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

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 ReceiveCompleted . İleti olmadığından, sonraki çağrısı EndReceive(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 BeginReceive , her işlemi tanımladığınız ayrı bir durum nesnesi aracılığıyla tanımlayabilirsiniz.

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.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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

BeginReceive(TimeSpan, Object, AsyncCallback)

İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir alma 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 ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);

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

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

Public Function BeginReceive (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 alma işlemi oluşturur. Kod örneği yerel bir ileti kuyruğuna bir ileti gönderir ve ardından BeginReceive(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. MyReceiveCompleted Bir ReceiveCompleted olay tetiklendiğinde, olay işleyicisi iletiyi alır ve 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 ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

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

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

    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.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

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

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

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        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 receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // 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 ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

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

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 ReceiveCompleted tetiklenmez. diğer aşırı yüklemeleri BeginReceive , olayı tetiklerken bu bileşene ReceiveCompleted güvenir.

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

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

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

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

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Belirtilen zaman aşımına sahip ve belirtilen bir imleç ile belirtilen durum nesnesini kullanan zaman uyumsuz bir alma 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 ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);

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

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

Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, 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 bir.

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şlemin tamamlanması bildirimini alan.

Döndürülenler

IAsyncResult

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

Özel durumlar

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; ReceiveCompleted olay tetiklenmez. diğer aşırı yüklemeleri BeginReceive bu bileşeni kullanarak olayı tetikler ReceiveCompleted .

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

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

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

BeginReceive Zaman uyumsuz olduğundan, geçerli yürütme iş parçacığını engellemeden kuyruktan bir ileti almak için çağırabilirsiniz. Zaman uyumlu bir şekilde ileti almak için yöntemini kullanın Receive .

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ürenBeginReceive, yöntemin başlattığı zaman uyumsuz işlemi tanımlar. Genellikle IAsyncResult çağrılana kadar EndReceive(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 BeginReceive , her işlemi tanımladığınız ayrı bir durum nesnesi aracılığıyla tanımlayabilirsiniz.

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

Zaman uyumsuz çağrıyı BeginReceive işlemlerle kullanmayın. İşlemsel zaman uyumsuz bir işlem gerçekleştirmek istiyorsanız çağrısı BeginPeekyapın ve işlemi ve (zaman uyumlu) Receive yöntemini özet işlemi için oluşturduğunuz olay işleyicisine yerleştirin. Olay işleyiciniz aşağıdaki C# kodunda gösterildiği gibi işlevsellik içerebilir.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

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.

Aracılığıyla paylaş

MessageQueue.BeginReceive Yöntem

Tanım

Aşırı Yüklemeler

BeginReceive()

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

BeginReceive(TimeSpan)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

BeginReceive(TimeSpan, Object)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

BeginReceive(TimeSpan, Object, AsyncCallback)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Ek kaynaklar