MessageQueue.Receive Metod

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

public System.Messaging.Message Receive();

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

Public Function Receive () As Message

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

Följande kodexempel tar emot ett meddelande från en kö och matar ut information om meddelandet till skärmen.

#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

Kommentarer

Använd den här överlagringen om du vill ta emot ett meddelande från en kö eller vänta tills det finns meddelanden i kön.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop till Receive returnerar meddelandena som följer i kön eller nya meddelanden med högre prioritet.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Eftersom den här överlagringen Receive av metoden anger en oändlig tidsgräns kan programmet vänta på obestämd tid. Om programbearbetningen ska fortsätta utan att vänta på meddelandet bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

Följande kodexempel ansluter till en transaktionskö på den lokala datorn och skickar ett meddelande till kön. Den tar sedan emot meddelandet som innehåller en beställning. Om den stöter på en icke-transaktionell kö utlöser den och undantager och återställer transaktionen.

#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

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en transaktionskö med hjälp av den interna transaktionskontexten som definieras av parametern transaction , eller vänta tills det finns meddelanden i kön.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop till Receive returnerar de meddelanden som följer i kön.

Eftersom den här metoden anropas i en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön. Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Eftersom den här överlagringen Receive av metoden anger en oändlig tidsgräns kan programmet vänta på obestämd tid. Om programbearbetningen ska fortsätta utan att vänta på meddelandet bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• MessageQueueTransaction
• Transactional
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

I följande kodexempel visas användningen av 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);

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en kö med hjälp av en transaktionskontext som definierats av parametern transactionType , eller vänta tills det finns meddelanden i kön.

Ange Automatic för parametern transactionType om det redan finns en extern transaktionskontext kopplad till tråden som du vill använda för att ta emot meddelandet. Ange Single om du vill ta emot meddelandet som en enda intern transaktion. Du kan ange None om du vill ta emot ett meddelande från en transaktionskö utanför en transaktionskontext.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop till Receive returnerar de meddelanden som följer i kön.

Om den här metoden anropas för att ta emot ett meddelande från en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön. Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Eftersom den här överlagringen Receive av metoden anger en oändlig tidsgräns kan programmet vänta på obestämd tid. Om programbearbetningen ska fortsätta utan att vänta på meddelandet bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• MessageQueueTransactionType
• Transactional
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

Följande kodexempel tar emot ett meddelande från en kö och matar ut information om meddelandet till skärmen. Exemplet pausar körningen i upp till fem sekunder i väntan på att ett meddelande ska tas emot i kön.

#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

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande och returnera under en angiven tidsperiod om det inte finns några meddelanden i kön.

Metoden Receive tillåter synkron läsning av ett meddelande och tar bort det från kön. Efterföljande anrop till Receive returnerar meddelandena som följer i kön eller nya meddelanden med högre prioritet.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Tråden blockeras under den angivna tidsperioden eller på obestämd tid om du har angett värdet InfiniteTimeout för parametern timeout . Om programbearbetningen ska fortsätta utan att vänta på ett meddelande bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• InfiniteTimeout
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

I följande kodexempel visas användningen av den här metoden.

#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

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en transaktionskö med hjälp av den interna transaktionskontexten som definieras av parametern transaction och returnera inom en angiven tidsperiod om det inte finns några meddelanden i kön.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop till Receive returnerar de meddelanden som följer i kön.

Eftersom den här metoden anropas i en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön. Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Tråden blockeras under den angivna tidsperioden eller på obestämd tid om du har angett värdet InfiniteTimeout för parametern timeout . Om programbearbetningen ska fortsätta utan att vänta på ett meddelande bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• MessageQueueTransaction
• Transactional
• InfiniteTimeout
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till det första meddelandet som är tillgängligt i kön.

Undantag

Exempel

I följande kodexempel visas användningen av den här metoden.

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

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en kö med hjälp av en transaktionskontext som definierats av parametern transactionType och returnera under en angiven tidsperiod om det inte finns några meddelanden i kön.

Ange Automatic för parametern transactionType om det redan finns en extern transaktionskontext kopplad till tråden som du vill använda för att ta emot meddelandet. Ange Single om du vill ta emot meddelandet som en enda intern transaktion. Du kan ange None om du vill ta emot ett meddelande från en transaktionskö utanför en transaktionskontext.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop till Receive returnerar de meddelanden som följer i kön.

Om den här metoden anropas för att ta emot ett meddelande från en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa det första meddelandet i en kö utan att ta bort det från kön använder du Peek metoden . Metoden Peek returnerar alltid det första meddelandet i kön, så efterföljande anrop till metoden returnerar samma meddelande om inte ett meddelande med högre prioritet kommer in i kön. Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Tråden blockeras under den angivna tidsperioden eller på obestämd tid om du har angett värdet InfiniteTimeout för parametern timeout . Om programbearbetningen ska fortsätta utan att vänta på ett meddelande bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• MessageQueueTransactionType
• Transactional
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till ett meddelande i kön.

Undantag

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en transaktionskö med hjälp av den interna transaktionskontexten som definieras av parametern transaction och returnera inom en angiven tidsperiod om det inte finns några meddelanden i kön.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop för att Receive returnera meddelandena som följer i kön.

Eftersom den här metoden anropas i en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa ett meddelande i en kö utan att ta bort det från kön använder du Peek metoden . Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Tråden blockeras under den angivna tidsperioden eller på obestämd tid om du har angett värdet InfiniteTimeout för parametern timeout . Om programbearbetningen ska fortsätta utan att vänta på ett meddelande bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• Cursor
• MessageQueueTransaction
• Transactional
• InfiniteTimeout
• Peek()
• BeginReceive()

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

Parametrar

Returer

En Message som refererar till ett meddelande i kön.

Undantag

Kommentarer

Använd den här överlagringen för att ta emot ett meddelande från en kö med hjälp av en transaktionskontext som definierats av parametern transactionType och returnera under en angiven tidsperiod om det inte finns några meddelanden i kön.

Ange Automatic för parametern transactionType om det redan finns en extern transaktionskontext kopplad till tråden som du vill använda för att ta emot meddelandet. Ange Single om du vill ta emot meddelandet som en enda intern transaktion. Du kan ange None om du vill ta emot ett meddelande från en transaktionskö utanför en transaktionskontext.

Metoden Receive möjliggör synkron läsning av ett meddelande och tar därmed bort det från kön. Efterföljande anrop för att Receive returnera meddelandena som följer i kön.

Om den här metoden anropas för att ta emot ett meddelande från en transaktionskö returneras meddelandet som tas emot till kön om transaktionen avbryts. Meddelandet tas inte bort permanent från kön förrän transaktionen har checkats in.

Om du vill läsa ett meddelande i en kö utan att ta bort det från kön använder du Peek metoden . Det finns ingen transaktionskontext som är associerad med ett meddelande som returneras av ett anrop till Peek. Eftersom Peek inte tar bort några meddelanden i kön finns det inget att återställa med ett anrop till Abort.

Använd ett anrop till Receive när det är acceptabelt att den aktuella tråden blockeras medan den väntar på att ett meddelande ska tas emot i kön. Tråden blockeras under den angivna tidsperioden eller på obestämd tid om du har angett värdet InfiniteTimeout för parametern timeout . Om programbearbetningen ska fortsätta utan att vänta på ett meddelande bör du överväga att använda den asynkrona metoden . BeginReceive

I följande tabell visas om den här metoden är tillgänglig i olika arbetsgruppslägen.

Se även

• Cursor
• MessageQueueTransactionType
• Transactional
• Peek()
• BeginReceive()