MessageQueue.BeginReceive Metódus

Definíció

Névtér:: System.Messaging

Szerelvény:: System.Messaging.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Aszinkron fogadási műveletet kezdeményez úgy, hogy közli a Message Queuing szolgáltatással, hogy kezdje meg az üzenet fogadását, és ha elkészült, értesítse az eseménykezelőt.

Túlterhelések

Name	Description
BeginReceive()	Olyan aszinkron fogadási műveletet kezdeményez, amelynek nincs időtúllépése. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban.
BeginReceive(TimeSpan)	Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépéssel rendelkezik. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginReceive(TimeSpan, Object)	Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során biztosít kapcsolódó információkat. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginReceive(TimeSpan, Object, AsyncCallback)	Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Aszinkron fogadási műveletet kezdeményez, amely egy megadott időtúllépéssel rendelkezik, és egy adott kurzort és egy megadott állapotobjektumot használ. Az állapotobjektum a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

BeginReceive()

Olyan aszinkron fogadási műveletet kezdeményez, amelynek nincs időtúllépése. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban.

public:
 IAsyncResult ^ BeginReceive();

public IAsyncResult BeginReceive();

member this.BeginReceive : unit -> IAsyncResult

Public Function BeginReceive () As IAsyncResult

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Példák

Az alábbi példakód az aszinkron kéréseket láncra fonja. Feltételezi, hogy a helyi számítógépen van egy "myQueue" nevű üzenetsor. A Main függvény elindítja a rutin által MyReceiveCompleted kezelt aszinkron műveletet. MyReceiveCompleted feldolgozza az aktuális üzenetet, és elindít egy új aszinkron fogadási műveletet.

#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

Az alábbi példakód aszinkron kéréseket vár. Az a hívás, amely BeginReceive a AsyncWaitHandle visszaadott értéket használja. A Main rutin megvárja, amíg az összes aszinkron művelet befejeződik a kilépés előtt.

#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

Megjegyzések

Az aszinkron feldolgozás során az eseményt az üzenetsorból való eltávolításakor kell BeginReceive elindítani ReceiveCompleted .

ReceiveCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használatához BeginReceivehozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginReceive aszinkron fogadási műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével ReceiveCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue hívással EndReceive(IAsyncResult)elérheti az üzenetet.

A BeginReceive metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Mivel BeginReceive aszinkron, úgy hívhatja meg, hogy az üzenetsorból fogadjon egy üzenetet anélkül, hogy blokkolta volna az aktuális végrehajtási szálat. Az üzenet szinkron fogadásához használja a metódust Receive .

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

A IAsyncResult visszaadott BeginReceive érték azonosítja a metódus által elindított aszinkron műveletet. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndReceive(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben a befejezett művelet azonosításához használja AsyncWaitHandle a IAsyncResult tulajdonságot.

Ha CanRead igen false, a befejezési esemény létrejön, de a hívás EndReceive(IAsyncResult)során kivétel lép fel.

Ne használja az aszinkron hívást BeginReceive tranzakciókkal. Ha tranzakciós aszinkron műveletet szeretne végrehajtani, hívja meg BeginPeekés helyezze el a tranzakciót és a (szinkron) Receive metódust a betekintő művelethez létrehozott eseménykezelőben. Az eseménykezelő a következő C#-kódban látható módon tartalmazhat funkciókat.

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

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

A következőre érvényes:

BeginReceive(TimeSpan)

Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépéssel rendelkezik. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);

public IAsyncResult BeginReceive(TimeSpan timeout);

member this.BeginReceive : TimeSpan -> IAsyncResult

Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A paraméterhez timeout megadott érték érvénytelen, valószínűleg azért, mert negatív számot jelöl.

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Példák

Az alábbi példakód egy aszinkron fogadási műveletet hoz létre. A példakód létrehoz egy eseménykezelőt, MyReceiveCompletedés csatolja az ReceiveCompleted eseménykezelő delegálthoz. A példakód egy üzenetet küld egy helyi üzenetsornak, majd meghívja BeginReceive(TimeSpan)a 10 másodperces időtúllépési értéket. Amikor eseményt ReceiveCompleted hoz létre, az eseménykezelő megkapja az üzenetet, és a képernyőre írja az üzenet törzsét.

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

Megjegyzések

Az aszinkron feldolgozás során az eseményt akkor emeli BeginReceive ki ReceiveCompleted , ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időintervallum lejárt.

ReceiveCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használatához BeginReceivehozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginReceive aszinkron fogadási műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével ReceiveCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez úgy férhet hozzá, hogy meghívja EndReceive(IAsyncResult) vagy lekérte az eredményt a ReceiveCompletedEventArgs.

A BeginReceive metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

Ha CanRead igen false, a befejezési esemény létrejön, de a hívás EndReceive(IAsyncResult)során kivétel lép fel.

Ez a túlterhelés időtúllépést határoz meg. Ha a timeout paraméter által megadott időköz lejár, ez az összetevő aktiválja az eseményt ReceiveCompleted . Mivel nincs üzenet, egy későbbi hívás kivételt fog eredményezni EndReceive(IAsyncResult) .

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

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

A következőre érvényes:

BeginReceive(TimeSpan, Object)

Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során biztosít kapcsolódó információkat. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

stateObject: Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Példák

Az alábbi példakód egy aszinkron fogadási műveletet hoz létre. A példakód létrehoz egy eseménykezelőt, MyReceiveCompletedés csatolja az ReceiveCompleted eseménykezelő delegálthoz. A példakód egy üzenetet küld egy helyi üzenetsornak, majd meghívja BeginReceive(TimeSpan, Object)a 10 másodperces időtúllépési értéket és egy egyedi egész számot, amely azonosítja az adott üzenetet. ReceiveCompleted Esemény létrehozásakor az eseménykezelő megkapja az üzenetet, és a képernyőre írja az üzenet törzsét és az egész szám üzenetazonosítóját.

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

Megjegyzések

Az aszinkron feldolgozás során az eseményt akkor emeli BeginReceive ki ReceiveCompleted , ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időintervallum lejárt.

ReceiveCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

Ezzel a túlterheléssel olyan információkat társíthat a művelethez, amelyek a művelet teljes élettartama alatt megmaradnak. Az eseménykezelő ezt az információt AsyncState a művelethez társított tulajdonsággal IAsyncResult tudja észlelni.

A használatához BeginReceivehozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginReceive aszinkron fogadási műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével ReceiveCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez úgy férhet hozzá, hogy meghívja EndReceive(IAsyncResult) vagy lekérte az eredményt a ReceiveCompletedEventArgs.

A BeginReceive metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

Ez a túlterhelés időtúllépést és állapotobjektumot határoz meg. Ha a timeout paraméter által megadott időköz lejár, ez az összetevő aktiválja az eseményt ReceiveCompleted . Mivel nincs üzenet, egy későbbi hívás kivételt fog eredményezni EndReceive(IAsyncResult) .

Az állapotobjektum az állapotinformációkat társítja a művelethez. Ha például többször is meghív BeginReceive több műveletet, az egyes műveleteket egy ön által meghatározott külön állapotobjektumon keresztül azonosíthatja.

Az állapotobjektummal adatokat is továbbíthat a folyamatszálak között. Ha egy szál el van indítva, de a visszahívás egy másik szálon van aszinkron forgatókönyvben, az állapotobjektumot a rendszer marsallja, és visszaadja az esemény információival együtt.

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

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

A következőre érvényes:

BeginReceive(TimeSpan, Object, AsyncCallback)

Elindít egy aszinkron fogadási műveletet, amely egy megadott időtúllépési és egy megadott állapotobjektummal rendelkezik, amely a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

stateObject: Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

callback: AsyncCallback

A AsyncCallback rendszer értesítést kap az aszinkron művelet befejezéséről.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Példák

Az alábbi példakód egy aszinkron fogadási műveletet hoz létre. A példakód egy üzenetet küld egy helyi üzenetsorba, majd meghívja a következőtBeginReceive(TimeSpan, Object, AsyncCallback): egy tíz másodperces időtúllépési érték, egy egyedi egész szám, amely azonosítja az adott üzenetet, és egy új példányAsyncCallback, amely azonosítja az eseménykezelőt. MyReceiveCompleted ReceiveCompleted Esemény létrehozásakor az eseménykezelő megkapja az üzenetet, és a képernyőre írja az üzenet törzsét és az egész szám üzenetazonosítóját.

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

Megjegyzések

Ha ezt a túlterhelést használja, a visszahívási paraméterben megadott visszahívás közvetlenül akkor lesz meghívva, ha egy üzenet elérhetővé válik az üzenetsorban, vagy ha a megadott időtartam lejárt; az ReceiveCompleted esemény nincs előállítva. A többi túlterhelés az BeginReceive összetevőre támaszkodva növeli az eseményt ReceiveCompleted .

ReceiveCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használatához BeginReceivehozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginReceive aszinkron fogadási műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével ReceiveCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez úgy férhet hozzá, hogy meghívja EndReceive(IAsyncResult) vagy lekérte az eredményt a ReceiveCompletedEventArgs.

A BeginReceive metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

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

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

A következőre érvényes:

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Aszinkron fogadási műveletet kezdeményez, amely egy megadott időtúllépéssel rendelkezik, és egy adott kurzort és egy megadott állapotobjektumot használ. Az állapotobjektum a művelet teljes élettartama során biztosít kapcsolódó információkat. Ez a túlterhelés egy visszahíváson keresztül értesítést kap a művelet eseménykezelőjének identitásáról. A művelet nem fejeződik be, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés következik be.

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

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt az időtartamot jelzi, amíg egy üzenet elérhetővé válik.

cursor: Cursor

Egy Cursor adott pozíciót tart fenn az üzenetsorban.

state: Object

Az alkalmazás által megadott állapotobjektum, amely az aszinkron művelethez társított információkat tartalmazza.

callback: AsyncCallback

Az AsyncCallback aszinkron művelet befejezéséről szóló értesítést kapó.

Válaszok

IAsyncResult

A IAsyncResult közzétett aszinkron kérést azonosító.

Kivételek

ArgumentNullException

A cursor paraméter a következő null: .

ArgumentException

A timeout paraméterhez megadott érték érvénytelen.

MessageQueueException

Hiba történt a Message Queuing metódus elérésekor.

Megjegyzések

ReceiveCompleted akkor is létrejön, ha egy üzenet már létezik az üzenetsorban.

A használatához BeginReceivehozzon létre egy eseménykezelőt, amely feldolgozza az aszinkron művelet eredményeit, és társítja azt az eseménymegbízotthoz. BeginReceive aszinkron fogadási műveletet kezdeményez; a MessageQueue rendszer az esemény felemelésével ReceiveCompleted értesítést kap, amikor egy üzenet érkezik az üzenetsorba. Ezután MessageQueue az üzenethez úgy férhet hozzá, hogy meghívja EndReceive(IAsyncResult) vagy lekérte az eredményt a ReceiveCompletedEventArgs.

A BeginReceive metódus azonnal visszatér, de az aszinkron művelet nem fejeződik be az eseménykezelő meghívásáig.

Ha egy aszinkron művelet befejeződik, meghívhatja BeginPeek vagy BeginReceive újra az eseménykezelőben, hogy továbbra is megkapja az értesítéseket.

A IAsyncResult visszaadott BeginReceive érték azonosítja a metódus által elindított aszinkron műveletet. Ezt IAsyncResult a művelet teljes élettartama alatt használhatja, bár általában csak akkor használja, ha EndReceive(IAsyncResult) meghívják. Ha azonban több aszinkron műveletet indít el, az értékeket IAsyncResult elhelyezheti egy tömbben, és megadhatja, hogy várnia kell-e az összes művelet vagy bármely művelet befejezésére. Ebben az esetben használja a AsyncWaitHandle tulajdonságot a IAsyncResult befejezett művelet azonosításához.

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

Az alábbi táblázat azt mutatja be, hogy ez a módszer elérhető-e különböző munkacsoport-módban.

Munkacsoport mód	Elérhető
Helyi számítógép	Igen
Helyi számítógép és közvetlen formátum neve	Igen
Távoli számítógép	No
Távoli számítógép és közvetlen formátum neve	Igen

Lásd még

A következőre érvényes:

Szálbiztonság

A metódus nem szálbiztos.

Visszajelzés

Hasznosnak találta ezt az oldalt?