MessageQueue.Receive 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.

Megkapja az üzenetsor első üzenetét, eltávolítva azt az üzenetsorból.

Túlterhelések

Name	Description
Receive()	Megkapja az első elérhető üzenetet az üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és letiltja az aktuális végrehajtási szálat, amíg egy üzenet el nem érhető.
Receive(MessageQueueTransaction)	Megkapja az első elérhető üzenetet a tranzakciós üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és letiltja az aktuális végrehajtási szálat, amíg egy üzenet el nem érhető.
Receive(MessageQueueTransactionType)	Megkapja az első elérhető üzenetet az üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és letiltja az aktuális végrehajtási szálat, amíg egy üzenet el nem érhető.
Receive(TimeSpan)	Megkapja az üzenetsor által hivatkozott MessageQueue első üzenetet, és megvárja, amíg egy üzenet el nem érhető az üzenetsorban, vagy lejár az időtúllépés.
Receive(TimeSpan, Cursor)	Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.
Receive(TimeSpan, MessageQueueTransaction)	Megkapja az első elérhető üzenetet a tranzakciós üzenetsorban, amelyre hivatkozik, MessageQueue és megvárja, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés lejár.
Receive(TimeSpan, MessageQueueTransactionType)	Megkapja az első elérhető üzenetet az üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és megvárja, amíg egy üzenet elérhetővé válik az üzenetsorban, vagy lejár az időkorlát.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.

Receive()

Megkapja az első elérhető üzenetet az üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és letiltja az aktuális végrehajtási szálat, amíg egy üzenet el nem érhető.

public:
 System::Messaging::Message ^ Receive();

public System.Messaging.Message Receive();

member this.Receive : unit -> System.Messaging.Message

Public Function Receive () As Message

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

MessageQueueException

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

Példák

Az alábbi példakód egy üzenetsorból fogad üzenetet, és az üzenetről a képernyőn jelenít meg információkat.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

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

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

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

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

    ' This class represents an object the following example 
    ' sends to a queue and receives from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Megjegyzések

Ezzel a túlterheléssel üzeneteket fogadhat egy üzenetsorból, vagy megvárhatja, amíg üzenetek vannak az üzenetsorban.

A Receive metódus lehetővé teszi egy üzenet szinkron olvasását, ezáltal eltávolítva azt az üzenetsorból. A következő hívások Receive az üzenetsorban megjelenő üzeneteket, illetve az új, magasabb prioritású üzeneteket fogják visszaadni.

Akkor használjon hívást Receive , ha elfogadható, hogy az aktuális szál le legyen tiltva, amíg egy üzenet megérkezik az üzenetsorba. Mivel a Receive metódus túlterhelése végtelen időtúllépést határoz meg, előfordulhat, hogy az alkalmazás határozatlan ideig várakozik. Ha az alkalmazás feldolgozása az üzenetre való várakozás nélkül folytatódik, fontolja meg az aszinkron metódus használatát. BeginReceive

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:

Receive(MessageQueueTransaction)

Megkapja az első elérhető üzenetet a tranzakciós üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és letiltja az aktuális végrehajtási szálat, amíg egy üzenet el nem érhető.

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive(System.Messaging.MessageQueueTransaction transaction);

member this.Receive : System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (transaction As MessageQueueTransaction) As Message

Paraméterek

transaction: MessageQueueTransaction

A MessageQueueTransaction objektum.

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

MessageQueueException

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

-vagy-

Az üzenetsor nem tranzakciós.

Példák

Az alábbi példakód egy tranzakciós üzenetsorhoz csatlakozik a helyi számítógépen, és üzenetet küld az üzenetsornak. Ezután megkapja a megrendelést tartalmazó üzenetet. Ha nem tranzakciós üzenetsorba ütközik, a rendszer kivételt küld, és visszaállítja a tranzakciót.

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

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of a MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   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 sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of a MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Megjegyzések

Ezzel a túlterheléssel üzenetet fogadhat egy tranzakciós üzenetsorból a paraméter által transaction meghatározott belső tranzakciós környezettel, vagy várjon, amíg üzenetek vannak az üzenetsorban.

A Receive metódus lehetővé teszi egy üzenet szinkron olvasását, ezáltal eltávolítva azt az üzenetsorból. A következő hívások Receive az üzenetsorban megjelenő üzeneteket fogják visszaadni.

Mivel ez a metódus egy tranzakciós üzenetsoron van meghívva, a kapott üzenet visszakerül az üzenetsorba, ha a tranzakció megszakad. Az üzenet nem lesz véglegesen eltávolítva az üzenetsorból a tranzakció véglegesítése előtt.

Az üzenetsor első üzenetének olvasásához anélkül, hogy eltávolítaná az üzenetsorból, használja a metódust Peek . A Peek metódus mindig az üzenetsor első üzenetét adja vissza, így a metódus későbbi hívásai ugyanazt az üzenetet kapják, kivéve, ha egy magasabb prioritású üzenet érkezik az üzenetsorba. A hívás Peekáltal visszaadott üzenethez nincs tranzakciós környezet társítva. Mivel Peek nem távolít el egyetlen üzenetet sem az üzenetsorból, a hívás Abortnem indítható vissza.

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:

Receive(MessageQueueTransactionType)

public:
 System::Messaging::Message ^ Receive(System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive(System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (transactionType As MessageQueueTransactionType) As Message

Paraméterek

transactionType: MessageQueueTransactionType

Az egyik MessageQueueTransactionType érték, amely leírja az üzenethez társítandó tranzakciós környezet típusát.

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

MessageQueueException

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

InvalidEnumArgumentException

A transactionType paraméter nem tagja a MessageQueueTransactionType tagoknak.

Példák

Az alábbi példakód bemutatja a használatát Receive(MessageQueueTransactionType).


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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Simulate doing other work so the message has time to arrive.
System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue->Receive(MessageQueueTransactionType::Single);

queue->Close();


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Simulate doing other work so the message has time to arrive.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue.  Because the Id of the message
// , it might not be the message just sent.
msg = queue.Receive(MessageQueueTransactionType.Single);

Megjegyzések

Ezzel a túlterheléssel üzenetet fogadhat egy üzenetsorból a transactionType paraméter által meghatározott tranzakciós környezettel, vagy várjon, amíg üzenetek vannak az üzenetsorban.

Adja meg Automatic a transactionType paramétert, ha már van egy külső tranzakciós környezet ahhoz a szálhoz, amelyet az üzenet fogadásához használni szeretne. Adja meg Single , hogy egyetlen belső tranzakcióként szeretné-e megkapni az üzenetet. Megadhatja None , hogy egy tranzakciós üzenetsorból szeretne-e üzenetet fogadni egy tranzakciós környezeten kívül.

Ha ez a metódus egy tranzakciós üzenetsorból érkező üzenet fogadására van meghívva, a kapott üzenet visszakerül az üzenetsorba, ha a tranzakció megszakad. Az üzenet nem lesz véglegesen eltávolítva az üzenetsorból a tranzakció véglegesítése előtt.

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:

Receive(TimeSpan)

Megkapja az üzenetsor által hivatkozott MessageQueue első üzenetet, és megvárja, amíg egy üzenet el nem érhető az üzenetsorban, vagy lejár az időtúllépés.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout);

public System.Messaging.Message Receive(TimeSpan timeout);

member this.Receive : TimeSpan -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

ArgumentException

A paraméterhez timeout megadott érték érvénytelen, lehet timeout , hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout.

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

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

Példák

Az alábbi példakód egy üzenetsorból fogad üzenetet, és az üzenetről a képernyőn jelenít meg információkat. A példa legfeljebb öt másodpercig szünetelteti a végrehajtást, miközben arra vár, hogy egy üzenet megérkezik az üzenetsorba.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         // Wait 5 seconds for a message to arrive.
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5) );
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message arrived in queue." );
         }

         // Handle other sources of a MessageQueueException.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example receives a message from a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    // This class represents an object the following example
    // receives from a queue.

    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example receives a message from a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************

        public void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                // Wait 5 seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5));
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }

            catch (MessageQueueException e)
            {
                // Handle no message arriving in the queue.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message arrived in queue.");
                }			

                // Handle other sources of a MessageQueueException.
            }
            
            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

' This class represents an object the following example 
' receives from a queue.
Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
End Class


   
Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example receives a message from a queue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                ' Wait 5 seconds for a message to arrive.
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5))
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch e As MessageQueueException
                ' Handle no message arriving in the queue.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.IOTimeout Then

                    Console.WriteLine("No message arrived in queue.")

                End If

                ' Handle other sources of a MessageQueueException.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)

                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Megjegyzések

Ezzel a túlterheléssel fogadhatja az üzeneteket, és adott időtartamon belül visszatérhet, ha nincsenek üzenetek az üzenetsorban.

A Receive metódus lehetővé teszi egy üzenet szinkron olvasását, és eltávolítja azt az üzenetsorból. A következő hívások Receive az üzenetsorban megjelenő üzeneteket, illetve az új, magasabb prioritású üzeneteket fogják visszaadni.

Akkor használjon hívást Receive , ha elfogadható, hogy az aktuális szál le legyen tiltva, amíg egy üzenet megérkezik az üzenetsorba. A szál le lesz tiltva az adott időtartamra, vagy határozatlan időre, ha megadta a InfiniteTimeout paraméter értékéttimeout. Ha az alkalmazás feldolgozása üzenet várakozása nélkül folytatódik, fontolja meg az aszinkron metódus használatát. BeginReceive

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:

Receive(TimeSpan, Cursor)

Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor);

public System.Messaging.Message Receive(TimeSpan timeout, System.Messaging.Cursor cursor);

member this.Receive : TimeSpan * System.Messaging.Cursor -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

cursor: Cursor

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

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

ArgumentException

A paraméterhez timeout megadott érték érvénytelen, lehet timeout , hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout.

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

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

Ezzel a túlterheléssel fogadhatja az üzeneteket, és adott időtartamon belül visszatérhet, ha nincsenek üzenetek az üzenetsorban.

A következőre érvényes:

Receive(TimeSpan, MessageQueueTransaction)

Megkapja az első elérhető üzenetet a tranzakciós üzenetsorban, amelyre hivatkozik, MessageQueue és megvárja, amíg egy üzenet el nem érhető az üzenetsorban, vagy az időtúllépés lejár.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive(TimeSpan timeout, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transaction As MessageQueueTransaction) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

transaction: MessageQueueTransaction

A MessageQueueTransaction objektum.

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

ArgumentException

A paraméterhez timeout megadott érték érvénytelen, lehet timeout , hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout.

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

Az üzenetsor nem tranzakciós.

-vagy-

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

Példák

Az alábbi példakód bemutatja ennek a módszernek a használatát.

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

using namespace System;
using namespace System::Messaging;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends a message to a transactional queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional)
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }

   //*************************************************
   // Receives a message from the transactional queue.
   //*************************************************
   void ReceiveMessageTransactional()
   {
      // Connect to a transactional queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         // Wait five seconds for a message to arrive. 
         Message^ myMessage = myQueue->Receive( TimeSpan(0,0,5), myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }
         // Handle no message arriving in the queue.
         else

         // Handle no message arriving in the queue.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::IOTimeout )
         {
            Console::WriteLine( "No message in queue." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
// 
// This example sends and receives a message from
// a transactional queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessageTransactional();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   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 sends and receives a message from
        // a transactional queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessageTransactional();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();

            return;
        }

        //**************************************************
        // Sends a message to a transactional queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

        //**************************************************
        // Receives a message from the transactional queue.
        //**************************************************
        
        public  void ReceiveMessageTransactional()
        {
            // Connect to a transactional queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                // Wait five seconds for a message to arrive.
                Message myMessage =	myQueue.Receive(new
                    TimeSpan(0,0,5), myTransaction);
                
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }

                    // Handle no message arriving in the queue.
                else if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.IOTimeout)
                {
                    Console.WriteLine("No message in queue.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

Namespace MyProj


   
    Public Class MyNewQueue


        '**************************************************
        ' Provides an entry point into the application.
        ' 
        ' This example sends and receives a message from
        ' a transactional queue.
        '**************************************************

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue

            ' Send a message to a queue.
            myNewQueue.SendMessageTransactional()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional()

            Return

        End Sub


        '**************************************************
        ' Sends a message to a transactional queue.
        '**************************************************

        Public Sub SendMessageTransactional()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            End If

            Return

        End Sub


        '**************************************************
        ' Receives a message from the transactional queue.
        '**************************************************

        Public Sub ReceiveMessageTransactional()

            ' Connect to a transactional queue on the local computer.
            Dim myQueue As New MessageQueue(".\myTransactionalQueue")

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                ' Wait five seconds for a message to arrive. 
                Dim myMessage As Message = myQueue.Receive(New _
                    TimeSpan(0, 0, 5), myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                Else
                    ' Handle no message arriving in the queue.
                    If e.MessageQueueErrorCode = _
                        MessageQueueErrorCode.IOTimeout Then

                        Console.WriteLine("No message in queue.")

                    End If
                End If

                ' Else catch other sources of a MessageQueueException.

                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as InvalidOperationException,
                ' thrown when the formatter cannot deserialize the message.

            End Try

            Return

        End Sub

    End Class
End Namespace 'MyProj

Megjegyzések

Ezzel a túlterheléssel üzenetet fogadhat egy tranzakciós üzenetsorból a paraméter által transaction definiált belső tranzakciós környezet használatával, és adott időn belül visszatérhet, ha nincsenek üzenetek az üzenetsorban.

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:

Receive(TimeSpan, MessageQueueTransactionType)

Megkapja az első elérhető üzenetet az üzenetsorban, amelyre a MessageQueuerendszer hivatkozik. Ez a hívás szinkron, és megvárja, amíg egy üzenet elérhetővé válik az üzenetsorban, vagy lejár az időkorlát.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive(TimeSpan timeout, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, transactionType As MessageQueueTransactionType) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

transactionType: MessageQueueTransactionType

Az egyik MessageQueueTransactionType érték, amely leírja az üzenethez társítandó tranzakciós környezet típusát.

Válaszok

Message

Az Message üzenetsorban elérhető első üzenetre hivatkozik.

Kivételek

ArgumentException

A paraméterhez timeout megadott érték érvénytelen, lehet timeout , hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout.

InvalidEnumArgumentException

A transactionType paraméter nem tagja a MessageQueueTransactionType tagoknak.

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

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

Példák

Az alábbi példakód bemutatja ennek a módszernek a használatát.


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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

// Set the formatter to indicate the message body contains a String.
queue->Formatter = gcnew XmlMessageFormatter(
    gcnew array<Type^>{String::typeid});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue->Receive(TimeSpan::FromSeconds(10.0),
    MessageQueueTransactionType::Single);

queue->Close();


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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

// Set the formatter to indicate the message body contains a String.
queue.Formatter = new XmlMessageFormatter(new Type[]
    {typeof(String)});

// Receive the message from the queue. Because the Id of the message
// is not specified, it might not be the message just sent.
msg = queue.Receive(TimeSpan.FromSeconds(10.0),
    MessageQueueTransactionType.Single);

Megjegyzések

Ezzel a túlterheléssel üzenetet fogadhat egy üzenetsorból a transactionType paraméter által meghatározott tranzakciós környezettel, és adott időtartamon belül visszatérhet, ha nincsenek üzenetek az üzenetsorban.

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:

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransaction ^ transaction);

public System.Messaging.Message Receive(TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransaction transaction);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransaction -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transaction As MessageQueueTransaction) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

cursor: Cursor

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

transaction: MessageQueueTransaction

A MessageQueueTransaction objektum.

Válaszok

Message

Az Message üzenetsor egy üzenetére hivatkozik.

Kivételek

ArgumentNullException

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

-vagy-

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

ArgumentException

A timeout paraméterhez megadott érték érvénytelen. Lehet, timeout hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout .

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

Az üzenetsor nem tranzakciós.

-vagy-

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

Megjegyzések

A Receive metódus lehetővé teszi egy üzenet szinkron olvasását, ezáltal eltávolítva azt az üzenetsorból. A következő hívások az Receive üzenetsorban megjelenő üzenetek visszaadására.

Mivel ez a metódus egy tranzakciós üzenetsoron van meghívva, a fogadott üzenet visszakerül az üzenetsorba, ha a tranzakció megszakadt. Az üzenet nem lesz véglegesen eltávolítva az üzenetsorból a tranzakció véglegesítése előtt.

Ha az üzenetsorban lévő üzeneteket anélkül szeretné elolvasni, hogy eltávolítaná azt az üzenetsorból, használja a metódust Peek . A hívás Peekáltal visszaadott üzenethez nincs tranzakciós környezet társítva. Mivel Peek nem távolít el üzeneteket az üzenetsorból, nincs mit visszahozni egy hívással Abort.

Akkor használjon hívást Receive , ha elfogadható, hogy az aktuális szál le legyen tiltva, amíg egy üzenet megérkezik az üzenetsorba. A szál le van tiltva az adott időtartamra, vagy határozatlan időre, ha megadta a InfiniteTimeout paraméter értékéttimeout. Ha az alkalmazás feldolgozása üzenet várakozása nélkül folytatódik, fontolja meg az aszinkron metódus használatát. BeginReceive

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:

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Az aktuális üzenet fogadása az üzenetsorban egy megadott kurzor használatával. Ha nem érhető el üzenet, ez a metódus megvárja, amíg egy üzenet elérhető, vagy az időtúllépés lejár.

public:
 System::Messaging::Message ^ Receive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Messaging::MessageQueueTransactionType transactionType);

public System.Messaging.Message Receive(TimeSpan timeout, System.Messaging.Cursor cursor, System.Messaging.MessageQueueTransactionType transactionType);

member this.Receive : TimeSpan * System.Messaging.Cursor * System.Messaging.MessageQueueTransactionType -> System.Messaging.Message

Public Function Receive (timeout As TimeSpan, cursor As Cursor, transactionType As MessageQueueTransactionType) As Message

Paraméterek

timeout: TimeSpan

Ez TimeSpan azt jelzi, hogy mennyi időt kell várni, amíg egy új üzenet elérhetővé válik az ellenőrzéshez.

cursor: Cursor

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

transactionType: MessageQueueTransactionType

MessageQueueTransactionType Az üzenethez társítandó tranzakciós környezet típusát leíró értékek egyike.

Válaszok

Message

Az Message üzenetsor egy üzenetére hivatkozik.

Kivételek

ArgumentNullException

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

ArgumentException

A timeout paraméterhez megadott érték érvénytelen. Lehet, timeout hogy kisebb vagy nagyobb, mint Zero InfiniteTimeout .

InvalidEnumArgumentException

A transactionType paraméter nem tagja a MessageQueueTransactionType tagoknak.

MessageQueueException

Az időkorlát lejárta előtt nem érkezett üzenet az üzenetsorba.

-vagy-

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

Megjegyzések

Ha ezt a metódust arra kérik, hogy egy tranzakciós üzenetsorból fogadjon üzenetet, a kapott üzenet visszakerül az üzenetsorba, ha a tranzakció megszakadt. Az üzenet nem lesz véglegesen eltávolítva az üzenetsorból a tranzakció véglegesítése előtt.

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?