MessageQueue.Receive Metodo

Definizione

Riceve il primo messaggio della coda rimuovendolo da quest'ultima.Receives the first message in the queue, removing it from the queue.

Overload

Receive()

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction)

Riceve il primo messaggio disponibile nella coda transazionale a cui MessageQueue fa riferimento.Receives the first message available in the transactional queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType)

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan)

Riceve il primo messaggio disponibile nella coda cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction)

Riceve il primo messaggio disponibile nella coda transazionale cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType)

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e attende che un messaggio venga reso disponibile nella coda o il timeout scada.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive()

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

public:
 System::Messaging::Message ^ Receive();
public System.Messaging.Message Receive ();
member this.Receive : unit -> System.Messaging.Message
Public Function Receive () As Message

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice seguente viene ricevuto un messaggio da una coda e vengono restituite le informazioni relative a tale messaggio sullo schermo.The following code example receives a message from a queue and outputs information about that message to the screen.

#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

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda o attendere che siano presenti messaggi nella coda.Use this overload to receive a message from a queue, or wait until there are messages in the queue.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi che seguono nella coda o nuovi messaggi con priorità più alta.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Poiché questo overload del Receive metodo specifica un timeout infinito, l'applicazione potrebbe attendere per un periodo illimitato.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Se l'elaborazione dell'applicazione continua senza attendere il messaggio, provare a utilizzare il metodo asincrono, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Vedi anche

Receive(MessageQueueTransaction)

Riceve il primo messaggio disponibile nella coda transazionale a cui MessageQueue fa riferimento.Receives the first message available in the transactional queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Parametri

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

-oppure--or-

La coda non è transazionale.The queue is non-transactional.

Esempi

Nell'esempio di codice seguente viene eseguita la connessione a una coda transazionale nel computer locale e viene inviato un messaggio alla coda.The following code example connects to a transactional queue on the local computer and sends a message to the queue. Riceve quindi il messaggio che contiene un ordine.It then receives the message that contains an order. Se viene rilevata una coda non transazionale, viene generata un'eccezione ed è possibile eseguire il rollback della transazione.If it encounters a non-transactional queue, it will throw and exception and rollback the transaction.

#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

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda transazionale utilizzando il contesto di transazione interno definito dal transaction parametro oppure attendere che siano presenti messaggi nella coda.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, or wait until there are messages in the queue.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi seguiti nella coda.Subsequent calls to Receive will return the messages that follow in the queue.

Poiché questo metodo viene chiamato su una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non ci sono elementi di cui eseguire il rollback mediante una chiamata a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Poiché questo overload del Receive metodo specifica un timeout infinito, l'applicazione potrebbe attendere per un periodo illimitato.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Se l'elaborazione dell'applicazione continua senza attendere il messaggio, provare a utilizzare il metodo asincrono, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(MessageQueueTransactionType)

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Parametri

transactionType
MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

Esempi

L'esempio di codice seguente illustra l'uso di Receive(MessageQueueTransactionType).The following code example demonstrates the use of 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); 

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda utilizzando un contesto di transazione definito dal transactionType parametro oppure attendere che siano presenti messaggi nella coda.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, or wait until there are messages in the queue.

Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si desidera utilizzare per ricevere il messaggio.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Specificare Single se si desidera ricevere il messaggio come una singola transazione interna.Specify Single if you want to receive the message as a single internal transaction. È possibile specificare None se si desidera ricevere un messaggio da una coda transazionale all'esterno di un contesto di transazione.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi seguiti nella coda.Subsequent calls to Receive will return the messages that follow in the queue.

Se questo metodo viene chiamato per ricevere un messaggio da una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non ci sono elementi di cui eseguire il rollback mediante una chiamata a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Poiché questo overload del Receive metodo specifica un timeout infinito, l'applicazione potrebbe attendere per un periodo illimitato.Because this overload of the Receive method specifies an infinite time-out, the application might wait indefinitely. Se l'elaborazione dell'applicazione continua senza attendere il messaggio, provare a utilizzare il metodo asincrono, BeginReceive.If the application processing should continue without waiting for the message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(TimeSpan)

Riceve il primo messaggio disponibile nella coda cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché timeout è minore di Zero o maggiore di InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

-oppure--or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method

Esempi

Nell'esempio di codice seguente viene ricevuto un messaggio da una coda e vengono restituite le informazioni relative a tale messaggio sullo schermo.The following code example receives a message from a queue and outputs information about that message to the screen. Nell'esempio viene sospesa l'esecuzione per un massimo di cinque secondi durante l'attesa dell'arrivo di un messaggio nella coda.The example pauses execution for up to five seconds while waiting for a message to arrive in the queue.

#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

Commenti

Utilizzare questo overload per ricevere e restituire un messaggio in un periodo di tempo specificato se nella coda non sono disponibili messaggi.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

Il Receive metodo consente la lettura sincrona di un messaggio, con la relativa rimozione dalla coda.The Receive method allows for the synchronous reading of a message, removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi che seguono nella coda o nuovi messaggi con priorità più alta.Subsequent calls to Receive will return the messages that follow in the queue, or new, higher priority messages.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Il thread verrà bloccato per il periodo di tempo specificato o per un periodo illimitato se è stato specificato il InfiniteTimeout valore per timeout il parametro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Se l'elaborazione dell'applicazione deve continuare senza attendere un messaggio, provare a usare il metodo asincrono BeginReceive,.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(TimeSpan, Cursor)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor

Oggetto Cursor che occupa una posizione specifica nella coda messaggi.A Cursor that maintains a specific position in the message queue.

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché timeout è minore di Zero o maggiore di InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

In alternativa-or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method

Utilizzare questo overload per ricevere e restituire un messaggio in un periodo di tempo specificato se nella coda non sono disponibili messaggi.Use this overload to receive a message and return in a specified period of time if there are no messages in the queue.

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Receive(TimeSpan, MessageQueueTransaction)

Riceve il primo messaggio disponibile nella coda transazionale cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché timeout è minore di Zero o maggiore di InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

In alternativa-or-

La coda non è transazionale.The queue is non-transactional.

In alternativa-or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice riportato di seguito viene illustrato l'utilizzo di questo metodo.The following code example demonstrates the use of this method.

#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

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda transazionale utilizzando il contesto di transazione interno definito dal transaction parametro e restituire entro un periodo di tempo specificato se non sono presenti messaggi nella coda.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi seguiti nella coda.Subsequent calls to Receive will return the messages that follow in the queue.

Poiché questo metodo viene chiamato su una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.Because this method is called on a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non ci sono elementi di cui eseguire il rollback mediante una chiamata a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Il thread verrà bloccato per il periodo di tempo specificato o per un periodo illimitato se è stato specificato il InfiniteTimeout valore per timeout il parametro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Se l'elaborazione dell'applicazione deve continuare senza attendere un messaggio, provare a usare il metodo asincrono BeginReceive,.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(TimeSpan, MessageQueueTransactionType)

Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento.Receives the first message available in the queue referenced by the MessageQueue. Questa chiamata è sincrona e attende che un messaggio venga reso disponibile nella coda o il timeout scada.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

transactionType
MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.One of the MessageQueueTransactionType values, describing the type of transaction context to associate with the message.

Restituisce

Oggetto Message che fa riferimento al primo messaggio disponibile nella coda.A Message that references the first message available in the queue.

Eccezioni

Il valore specificato per il parametro timeout non è valido, probabilmente perché timeout è minore di Zero o maggiore di InfiniteTimeout.The value specified for the timeout parameter is not valid, possibly timeout is less than Zero or greater than InfiniteTimeout.

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

In alternativa-or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Esempi

Nell'esempio di codice riportato di seguito viene illustrato l'utilizzo di questo metodo.The following code example demonstrates the use of this method.


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

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda utilizzando un contesto di transazione definito dal transactionType parametro e restituire in un periodo di tempo specificato se non sono presenti messaggi nella coda.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si desidera utilizzare per ricevere il messaggio.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Specificare Single se si desidera ricevere il messaggio come una singola transazione interna.Specify Single if you want to receive the message as a single internal transaction. È possibile specificare None se si desidera ricevere un messaggio da una coda transazionale all'esterno di un contesto di transazione.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Le chiamate successive Receive a restituiranno i messaggi seguiti nella coda.Subsequent calls to Receive will return the messages that follow in the queue.

Se questo metodo viene chiamato per ricevere un messaggio da una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.If this method is called to receive a message from a transactional queue, the message that is received would be returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere il primo messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read the first message in a queue without removing it from the queue, use the Peek method. Il Peek metodo restituisce sempre il primo messaggio nella coda, quindi le chiamate successive al metodo restituiscono lo stesso messaggio a meno che un messaggio con priorità più alta non arrivi nella coda.The Peek method always returns the first message in the queue, so subsequent calls to the method return the same message unless a higher priority message arrives in the queue. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non ci sono elementi di cui eseguire il rollback mediante una chiamata a Abort.Because Peek does not remove any messages in the queue, there would be nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Il thread verrà bloccato per il periodo di tempo specificato o per un periodo illimitato se è stato specificato il InfiniteTimeout valore per timeout il parametro.The thread will be blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Se l'elaborazione dell'applicazione deve continuare senza attendere un messaggio, provare a usare il metodo asincrono BeginReceive,.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(TimeSpan, Cursor, MessageQueueTransaction)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor

Oggetto Cursor che occupa una posizione specifica nella coda messaggi.A Cursor that maintains a specific position in the message queue.

Restituisce

Oggetto Message che fa riferimento a un messaggio della coda.A Message that references a message in the queue.

Eccezioni

Il valore del parametro cursor è null.The cursor parameter is null.

In alternativa-or- Il valore del parametro transaction è null.The transaction parameter is null.

Il valore specificato per il parametro timeout non è valido.The value specified for the timeout parameter is not valid. Probabilmente timeout è minore di Zero o maggiore di InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

-oppure--or-

La coda non è transazionale.The queue is non-transactional.

In alternativa-or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda transazionale utilizzando il contesto di transazione interno definito dal transaction parametro e restituire entro un periodo di tempo specificato se non sono presenti messaggi nella coda.Use this overload to receive a message from a transactional queue using the internal transaction context defined by the transaction parameter, and return within a specified period of time if there are no messages in the queue.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Chiamate successive per Receive restituire i messaggi seguiti nella coda.Subsequent calls to Receive return the messages that follow in the queue.

Poiché questo metodo viene chiamato su una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.Because this method is called on a transactional queue, the message that is received is returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere un messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read a message in a queue without removing it from the queue, use the Peek method. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non è necessario eseguire il rollback tramite una chiamata a Abort.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Il thread è bloccato per il periodo di tempo specificato o per un periodo illimitato se è stato specificato InfiniteTimeout il valore timeout per il parametro.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Se l'elaborazione dell'applicazione deve continuare senza attendere un messaggio, provare a usare il metodo asincrono BeginReceive,.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Riceve il messaggio corrente nella coda, utilizzando il cursore specificato.Receives the current message in the queue, using a specified cursor. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout.If no message is available, this method waits until either a message is available, or the time-out expires.

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

Parametri

timeout
TimeSpan

Oggetto TimeSpan che indica l'intervallo di attesa prima che un nuovo messaggio venga reso disponibile per il controllo.A TimeSpan that indicates the time to wait until a new message is available for inspection.

cursor
Cursor

Oggetto Cursor che occupa una posizione specifica nella coda messaggi.A Cursor that maintains a specific position in the message queue.

transactionType
MessageQueueTransactionType

Uno dei valori di MessageQueueTransactionType che descrive il tipo di contesto di transazione da associare al messaggio.One of the MessageQueueTransactionType values that describes the type of transaction context to associate with the message.

Restituisce

Oggetto Message che fa riferimento a un messaggio della coda.A Message that references a message in the queue.

Eccezioni

Il valore del parametro cursor è null.The cursor parameter is null.

Il valore specificato per il parametro timeout non è valido.The value specified for the timeout parameter is not valid. Probabilmente timeout è minore di Zero o maggiore di InfiniteTimeout.Possibly timeout is less than Zero or greater than InfiniteTimeout.

Il parametro transactionType non è uno dei membri di MessageQueueTransactionType.The transactionType parameter is not one of the MessageQueueTransactionType members.

Un messaggio non è arrivato nella coda prima della scadenza del timeout.A message did not arrive in the queue before the time-out expired.

-oppure--or-

Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.An error occurred when accessing a Message Queuing method.

Commenti

Utilizzare questo overload per ricevere un messaggio da una coda utilizzando un contesto di transazione definito dal transactionType parametro e restituire in un periodo di tempo specificato se non sono presenti messaggi nella coda.Use this overload to receive a message from a queue using a transaction context defined by the transactionType parameter, and return in a specified period of time if there are no messages in the queue.

Specificare Automatic per il transactionType parametro se è già presente un contesto di transazione esterno collegato al thread che si desidera utilizzare per ricevere il messaggio.Specify Automatic for the transactionType parameter if there is already an external transaction context attached to the thread that you want to use to receive the message. Specificare Single se si desidera ricevere il messaggio come una singola transazione interna.Specify Single if you want to receive the message as a single internal transaction. È possibile specificare None se si desidera ricevere un messaggio da una coda transazionale all'esterno di un contesto di transazione.You can specify None if you want to receive a message from a transactional queue outside of a transaction context.

Il Receive metodo consente la lettura sincrona di un messaggio, in modo da rimuoverlo dalla coda.The Receive method allows for the synchronous reading of a message, thereby removing it from the queue. Chiamate successive per Receive restituire i messaggi seguiti nella coda.Subsequent calls to Receive return the messages that follow in the queue.

Se questo metodo viene chiamato per ricevere un messaggio da una coda transazionale, il messaggio ricevuto viene restituito alla coda se la transazione è stata interrotta.If this method is called to receive a message from a transactional queue, the message that is received is returned to the queue if the transaction is aborted. Il messaggio non viene rimosso definitivamente dalla coda fino a quando non viene eseguito il commit della transazione.The message is not permanently removed from the queue until the transaction is committed.

Per leggere un messaggio in una coda senza rimuoverlo dalla coda, usare il Peek metodo.To read a message in a queue without removing it from the queue, use the Peek method. Nessun contesto di transazione associato a un messaggio restituito da una chiamata a Peek.There is no transaction context associated with a message returned by a call to Peek. Poiché Peek non rimuove alcun messaggio nella coda, non è necessario eseguire il rollback tramite una chiamata a Abort.Because Peek does not remove any messages in the queue, there is nothing to roll back by a call to Abort.

Utilizzare una chiamata a Receive quando è accettabile il blocco del thread corrente durante l'attesa dell'arrivo di un messaggio nella coda.Use a call to Receive when it is acceptable for the current thread to be blocked while it waits for a message to arrive in the queue. Il thread è bloccato per il periodo di tempo specificato o per un periodo illimitato se è stato specificato InfiniteTimeout il valore timeout per il parametro.The thread is blocked for the given period of time, or indefinitely if you specified the value InfiniteTimeout for the timeout parameter. Se l'elaborazione dell'applicazione deve continuare senza attendere un messaggio, provare a usare il metodo asincrono BeginReceive,.If the application processing should continue without waiting for a message, consider using the asynchronous method, BeginReceive.

Nella tabella seguente viene indicato se questo metodo è disponibile in diverse modalità del gruppo di lavoro.The following table shows whether this method is available in various Workgroup modes.

Modalità gruppo di lavoroWorkgroup mode DisponibileAvailable
Computer localeLocal computer Yes
Nome del computer locale e del formato direttoLocal computer and direct format name Yes
Computer remotoRemote computer NoNo
Nome del computer remoto e del formato direttoRemote computer and direct format name Yes

Thread safety

Il metodo non è thread-safe.The method is not thread safe.

Vedi anche

Si applica a