MessageQueue.Receive Yöntem

Başvuru

Tanım

Ad Alanı:: System.Messaging

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

Önemli

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

Kuyruktaki ilk iletiyi alır ve kuyruktan kaldırır.

Aşırı Yüklemeler

Receive()	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(MessageQueueTransaction)	tarafından MessageQueuebaşvuruda bulunulan işlem kuyruğunda bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(MessageQueueTransactionType)	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(TimeSpan)	tarafından MessageQueue başvurulan kuyrukta bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, MessageQueueTransaction)	tarafından MessageQueue başvurulan işlem kuyruğunda bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, MessageQueueTransactionType)	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve kuyrukta bir ileti bulunana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.

Receive()

tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.

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

public System.Messaging.Message Receive ();

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

Public Function Receive () As Message

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

MessageQueueException

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

Örnekler

Aşağıdaki kod örneği bir kuyruktan bir ileti alır ve bu ileti hakkındaki bilgileri ekrana aktarır.

#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

Açıklamalar

Kuyruktan ileti almak için bu aşırı yüklemeyi kullanın veya kuyrukta ileti olana kadar bekleyin.

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece bunu kuyruktan kaldırır. sonraki çağrıları Receive kuyrukta izleyen iletileri veya yeni, daha yüksek öncelikli iletileri döndürür.

Receive Bir iletinin kuyruğa gelmesini beklerken geçerli iş parçacığının engellenmesi kabul edilebilir olduğunda çağrısı kullanın. Yönteminin Receive bu aşırı yüklemesi sonsuz bir zaman aşımı belirttiğinden, uygulama süresiz olarak bekleyebilir. Uygulama işlemenin iletiyi beklemeden devam etmesi gerekiyorsa, zaman uyumsuz yöntemini BeginReceivekullanmayı göz önünde bulundurun.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(MessageQueueTransaction)

tarafından MessageQueuebaşvuruda bulunulan işlem kuyruğunda bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.

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

Parametreler

transaction: MessageQueueTransaction

MessageQueueTransaction nesnesi.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

MessageQueueException

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

-veya-

Kuyruk işlemsel değil.

Örnekler

Aşağıdaki kod örneği yerel bilgisayardaki bir işlem kuyruğuna bağlanır ve kuyruğa bir ileti gönderir. Ardından sipariş içeren iletiyi alır. İşlem dışı bir kuyrukla karşılaşırsa, ve özel durumu oluşturur ve işlemi geri alır.

#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 == true )
      {
         // 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 == true)
            {
                // 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

Açıklamalar

parametresi tarafından transaction tanımlanan iç işlem bağlamını kullanarak bir işlem kuyruğundan ileti almak için bu aşırı yüklemeyi kullanın veya kuyrukta iletiler olana kadar bekleyin.

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece bunu kuyruktan kaldırır. sonraki çağrıları Receive kuyrukta izleyen iletileri döndürür.

Bu yöntem işlem kuyruğunda çağrıldığından, işlem durdurulduysa alınan ileti kuyruğa döndürülür. İşlem işlenene kadar ileti kuyruktan kalıcı olarak kaldırılmaz.

Kuyruktaki ilk iletiyi kuyruktan kaldırmadan okumak için yöntemini kullanın Peek . Peek yöntemi her zaman kuyruktaki ilk iletiyi döndürür, bu nedenle daha yüksek öncelikli bir ileti kuyruğa ulaşmadığı sürece yöntemine yapılan sonraki çağrılar aynı iletiyi döndürür. çağrısı Peektarafından döndürülen bir iletiyle ilişkilendirilmiş bir işlem bağlamı yoktur. Peek Kuyruktaki hiçbir iletiyi kaldırmadığı için çağrısıyla geri alınabilecek bir Abortşey olmaz.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(MessageQueueTransactionType)

tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.

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

Parametreler

transactionType: MessageQueueTransactionType

MessageQueueTransactionType İletiyle ilişkilendirilecek işlem bağlamının türünü açıklayan değerlerden biri.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

MessageQueueException

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

InvalidEnumArgumentException

transactionType parametresi üyelerden MessageQueueTransactionType biri değildir.

Örnekler

Aşağıdaki kod örneğinde kullanımı gösterilmektedir 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);

Açıklamalar

Parametresi tarafından transactionType tanımlanan bir işlem bağlamını kullanarak kuyruktan ileti almak için bu aşırı yüklemeyi kullanın veya kuyrukta iletiler olana kadar bekleyin.

İletiyi transactionType almak için kullanmak istediğiniz iş parçacığına eklenmiş bir dış işlem bağlamı zaten varsa parametresini belirtinAutomatic. İletiyi tek bir iç işlem olarak almak isteyip istemediğinizi belirtin Single . İşlem bağlamı dışında bir işlem kuyruğundan ileti almak isteyip istemediğinizi belirtebilirsiniz None .

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece ileti kuyruktan kaldırılır. sonraki çağrıları Receive , kuyrukta izleyen iletileri döndürür.

İşlem kuyruğundan ileti almak için bu yöntem çağrılırsa, işlem durdurulduysa alınan ileti kuyruğa döndürülür. İleti, işlem yürütülene kadar kuyruktan kalıcı olarak kaldırılmaz.

Kuyruktaki ilk iletiyi kuyruktan kaldırmadan okumak için yöntemini kullanın Peek . Peek yöntemi her zaman kuyruktaki ilk iletiyi döndürür, bu nedenle yönteme yapılan sonraki çağrılar kuyruğa daha yüksek öncelikli bir ileti ulaşmadığı sürece aynı iletiyi döndürür. çağrısı Peektarafından döndürülen bir iletiyle ilişkilendirilmiş işlem bağlamı yoktur. Peek Kuyruktaki hiçbir iletiyi kaldırmadığından, çağrısı Aborttarafından geri alınabilecek hiçbir şey olmaz.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan)

tarafından MessageQueue başvurulan kuyrukta bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil, büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

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

Örnekler

Aşağıdaki kod örneği, kuyruktan bir ileti alır ve bu ileti hakkındaki bilgileri ekrana gönderir. Örnek, bir iletinin kuyruğa gelmesini beklerken yürütmeyi beş saniyeye kadar duraklatır.

#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

Açıklamalar

Bir ileti almak ve kuyrukta ileti yoksa belirli bir süre içinde dönmek için bu aşırı yüklemeyi kullanın.

yöntemi, Receive bir iletinin kuyruktan kaldırılarak zaman uyumlu bir şekilde okunmasına olanak tanır. sonraki çağrıları Receive , kuyrukta izleyen iletileri veya yeni, daha yüksek öncelikli iletileri döndürür.

Receive Bir iletinin kuyruğa gelmesini beklerken geçerli iş parçacığının engellenmesi kabul edilebilir olduğunda çağrısı kullanın. İş parçacığı belirli bir süre boyunca engellenir veya parametrenin timeout değerini InfiniteTimeout belirttiyseniz süresiz olarak. Uygulama işlemenin ileti beklenmeden devam etmesi gerekiyorsa, zaman uyumsuz yöntemini BeginReceivekullanmayı göz önünde bulundurun.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor)

Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

cursor: Cursor

Cursor İleti kuyruğunda belirli bir konumu koruyan bir.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil, büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

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

Bir ileti almak ve kuyrukta ileti yoksa belirli bir süre içinde dönmek için bu aşırı yüklemeyi kullanın.

Şunlara uygulanır

Receive(TimeSpan, MessageQueueTransaction)

tarafından MessageQueue başvurulan işlem kuyruğunda bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

transaction: MessageQueueTransaction

MessageQueueTransaction nesnesi.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil, büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

Kuyruk işlemsel değil.

-veya-

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

Örnekler

Aşağıdaki kod örneği bu yöntemin kullanımını gösterir.

#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 == true )
      {
         // 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 == true)
            {
                // 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

Açıklamalar

parametresi tarafından transaction tanımlanan iç işlem bağlamını kullanarak bir işlem kuyruğundan ileti almak ve kuyrukta ileti yoksa belirli bir süre içinde dönmek için bu aşırı yüklemeyi kullanın.

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece ileti kuyruktan kaldırılır. sonraki çağrıları Receive , kuyrukta izleyen iletileri döndürür.

Bu yöntem işlem kuyruğunda çağrıldığından, işlem durdurulduysa alınan ileti kuyruğa döndürülür. İleti, işlem yürütülene kadar kuyruktan kalıcı olarak kaldırılmaz.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, MessageQueueTransactionType)

tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType İletiyle ilişkilendirilecek işlem bağlamının türünü açıklayan değerlerden biri.

Döndürülenler

Message

Message Kuyrukta bulunan ilk iletiye başvuran bir.

Özel durumlar

ArgumentException

parametresi için timeout belirtilen değer geçerli değil, büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

InvalidEnumArgumentException

transactionType parametresi üyelerden MessageQueueTransactionType biri değildir.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

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

Örnekler

Aşağıdaki kod örneği bu yöntemin kullanımını gösterir.


// 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);

Açıklamalar

Parametresi tarafından transactionType tanımlanan bir işlem bağlamını kullanarak kuyruktan ileti almak ve kuyrukta ileti yoksa belirli bir süre içinde döndürmek için bu aşırı yüklemeyi kullanın.

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece ileti kuyruktan kaldırılır. sonraki çağrıları Receive , kuyrukta izleyen iletileri döndürür.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

cursor: Cursor

Cursor İleti kuyruğunda belirli bir konumu koruyan bir.

transaction: MessageQueueTransaction

MessageQueueTransaction nesnesi.

Döndürülenler

Message

Message Kuyruktaki bir iletiye başvuran bir.

Özel durumlar

ArgumentNullException

cursor parametresidirnull.

-veya-

transaction parametresidirnull.

ArgumentException

parametresi için timeout belirtilen değer geçerli değil. Büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

Kuyruk işlemsel değil.

-veya-

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

Açıklamalar

yöntemi, Receive bir iletinin zaman uyumlu bir şekilde okunmasına olanak tanır ve böylece ileti kuyruktan kaldırılır. Kuyrukta takip eden iletileri döndürmek için Receive sonraki çağrılar.

Bu yöntem işlem kuyruğunda çağrıldığından, işlem durdurulduysa alınan ileti kuyruğa döndürülür. İleti, işlem yürütülene kadar kuyruktan kalıcı olarak kaldırılmaz.

Kuyruktaki bir iletiyi kuyruktan kaldırmadan okumak için yöntemini kullanın Peek . çağrısı Peektarafından döndürülen bir iletiyle ilişkilendirilmiş işlem bağlamı yoktur. Peek Kuyruktaki hiçbir iletiyi kaldırmadığından, çağrısı Aborttarafından geri alınabilecek hiçbir şey yoktur.

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

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

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.

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

Parametreler

timeout: TimeSpan

TimeSpan Yeni bir iletinin denetlenmeye hazır olmasını bekleme süresini gösteren bir.

cursor: Cursor

Cursor İleti kuyruğunda belirli bir konumu koruyan bir.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType İletiyle ilişkilendirilecek işlem bağlamının türünü açıklayan değerlerden biri.

Döndürülenler

Message

Message Kuyruktaki bir iletiye başvuran bir.

Özel durumlar

ArgumentNullException

cursor parametresidirnull.

ArgumentException

parametresi için timeout belirtilen değer geçerli değil. Büyük olasılıkla timeout değerinden Zero küçük veya büyüktür InfiniteTimeout.

InvalidEnumArgumentException

transactionType parametresi üyelerden MessageQueueTransactionType biri değildir.

MessageQueueException

Zaman aşımı süresi dolmadan önce kuyruğa bir ileti gelmedi.

-veya-

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

Açıklamalar

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

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

Ayrıca bkz.

Şunlara uygulanır

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

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

Aracılığıyla paylaş

MessageQueue.Receive Yöntem

Tanım

Aşırı Yüklemeler

Receive()

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(MessageQueueTransaction)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(MessageQueueTransactionType)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor)

Parametreler

Döndürülenler

Özel durumlar

Şunlara uygulanır

Receive(TimeSpan, MessageQueueTransaction)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, MessageQueueTransactionType)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Ek kaynaklar