MessageQueue MessageQueue MessageQueue MessageQueue Class

Definizione

Fornisce l'accesso a una coda su un server di Accodamento messaggi.Provides access to a queue on a Message Queuing server.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable
[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
Ereditarietà
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente vengono MessageQueue creati nuovi oggetti usando diversi tipi di sintassi dei nomi di percorso.The following code example creates new MessageQueue objects using various path name syntax types. In ogni caso, invia un messaggio alla coda il cui percorso è definito nel costruttore.In each case, it sends a message to the queue whose path is defined in the constructor.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   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 demonstrates several ways to set
		// a queue's path.
		//**************************************************

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

			myNewQueue.SendPublic();
			myNewQueue.SendPrivate();
			myNewQueue.SendByLabel();
			myNewQueue.SendByFormatName();
			myNewQueue.MonitorComputerJournal();
			myNewQueue.MonitorQueueJournal();
			myNewQueue.MonitorDeadLetter();
			myNewQueue.MonitorTransactionalDeadLetter();

			return;
		}
		
		// References public queues.
		public void SendPublic()
		{
			MessageQueue myQueue = new MessageQueue(".\\myQueue");
			myQueue.Send("Public queue by path name.");

			return;
		}

		// References private queues.
		public void SendPrivate()
		{
			MessageQueue myQueue = new 
				MessageQueue(".\\Private$\\myQueue");
			myQueue.Send("Private queue by path name.");

			return;
		}

		// References queues by label.
		public void SendByLabel()
		{
			MessageQueue myQueue = new MessageQueue("Label:TheLabel");
			myQueue.Send("Queue by label.");

			return;
		}

		// References queues by format name.
		public void SendByFormatName()
		{
			MessageQueue myQueue = new 
				MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" + 
				"-935C-845C2AFF7112");
			myQueue.Send("Queue by format name.");

			return;
		}

		// References computer journal queues.
		public void MonitorComputerJournal()
		{
			MessageQueue computerJournal = new 
				MessageQueue(".\\Journal$");
			while(true)
			{
				Message journalMessage = computerJournal.Receive();
				// Process the journal message.
			}
		}

		// References queue journal queues.
		public void MonitorQueueJournal()
		{
			MessageQueue queueJournal = new 
				MessageQueue(".\\myQueue\\Journal$");
			while(true)
			{
				Message journalMessage = queueJournal.Receive();
				// Process the journal message.
			}
		}
		
		// References dead-letter queues.
		public void MonitorDeadLetter()
		{
			MessageQueue deadLetter = new 
				MessageQueue(".\\DeadLetter$");
			while(true)
			{
				Message deadMessage = deadLetter.Receive();
				// Process the dead-letter message.
			}
		}

		// References transactional dead-letter queues.
		public void MonitorTransactionalDeadLetter()
		{
			MessageQueue TxDeadLetter = new 
				MessageQueue(".\\XactDeadLetter$");
			while(true)
			{
				Message txDeadLetter = TxDeadLetter.Receive();
				// Process the transactional dead-letter message.
			}
		}

	}
}
Imports System
Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example demonstrates several ways to set
        ' a queue's path.
        

        Public Shared Sub Main()

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

            myNewQueue.SendPublic()
            myNewQueue.SendPrivate()
            myNewQueue.SendByLabel()
            myNewQueue.SendByFormatName()
            myNewQueue.MonitorComputerJournal()
            myNewQueue.MonitorQueueJournal()
            myNewQueue.MonitorDeadLetter()
            myNewQueue.MonitorTransactionalDeadLetter()

            Return

        End Sub 'Main


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub 'SendPublic


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub 'SendPrivate


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub 'SendByLabel


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub 'SendByFormatName


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub 'MonitorComputerJournal


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub 'MonitorQueueJournal


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub 'MonitorDeadLetter


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub 'MonitorTransactionalDeadLetter

End Class 'MyNewQueue 

Nell'esempio di codice seguente viene inviato un messaggio a una coda e viene ricevuto un messaggio da una coda, utilizzando una classe specifica dell' Orderapplicazione denominata.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called Order.

#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
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 'Order


   
    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 'Main


        '
        ' 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 'SendMessage


        '
        ' 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 'ReceiveMessage

End Class 'MyNewQueue

Commenti

La tecnologia di Accodamento messaggi consente alle applicazioni in esecuzione in momenti diversi di comunicare su reti e sistemi eterogenei che potrebbero essere temporaneamente offline.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Le applicazioni inviano, ricevono o visualizzano (lettura senza rimuovere) messaggi dalle code.Applications send, receive, or peek (read without removing) messages from queues. Accodamento messaggi è un componente facoltativo di Windows 2000Windows 2000 e Windows NT e deve essere installato separatamente.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

La MessageQueue classe è un wrapper per l'accodamento dei messaggi.The MessageQueue class is a wrapper around Message Queuing. Sono disponibili più versioni di Accodamento messaggi e l'utilizzo della MessageQueue classe può determinare un comportamento leggermente diverso, a seconda del sistema operativo in uso.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. Per informazioni sulle funzionalità specifiche di ogni versione di Accodamento messaggi, vedere l'argomento relativo alle novità di Accodamento messaggi in Platform SDK in MSDN.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

La MessageQueue classe fornisce un riferimento a una coda di Accodamento messaggi.The MessageQueue class provides a reference to a Message Queuing queue. È possibile specificare un percorso nel MessageQueue costruttore per connettersi a una risorsa esistente oppure è possibile creare una nuova coda nel server.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. Prima di poter chiamare Send(Object), Peeko Receive, MessageQueue è necessario associare la nuova istanza della classe a una coda esistente.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. A questo punto, è possibile modificare le proprietà della coda, Category ad Labelesempio e.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueuesupporta due tipi di recupero dei messaggi: sincrono e asincrono.MessageQueue supports two types of message retrieval: synchronous and asynchronous. I metodi sincroni, Peek e Receive, determinano l'attesa da parte del thread di processo di un intervallo di tempo specificato per l'arrivo di un nuovo messaggio nella coda.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. I metodi asincroni, BeginPeek e BeginReceive, consentono alle attività principali dell'applicazione di continuare in un thread separato fino a quando non arriva un messaggio nella coda.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Questi metodi funzionano usando oggetti di callback e oggetti di stato per comunicare le informazioni tra i thread.These methods work by using callback objects and state objects to communicate information between threads.

Quando si crea una nuova istanza della MessageQueue classe, non viene creata una nuova coda di Accodamento messaggi.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. In alternativa, è possibile utilizzare Create(String)i Delete(String)metodi, Purge e per gestire le code nel server.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

Diversamente da Purge, Create(String) e Delete(String) sono membristatic , quindi MessageQueue è possibile chiamarli senza creare una nuova istanza della classe.Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

È possibile impostare la MessageQueue Path proprietà dell'oggetto con uno dei tre nomi seguenti: FormatNameil nome descrittivo Label, o.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. Il nome descrittivo, definito dalle proprietà MachineName e Private$ \ \ MachineName QueueName della coda, è \ QueueName per una coda pubblica e MachineName QueueName per una coda privata.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. La FormatName proprietà consente l'accesso offline alle code di messaggi.The FormatName property allows offline access to message queues. Infine, è possibile usare la Label proprietà della coda per impostare la Pathcoda.Lastly, you can use the queue's Label property to set the queue's Path.

Per un elenco dei valori iniziali delle proprietà di un'istanza MessageQueuedi, vedere MessageQueue il costruttore.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Costruttori

MessageQueue() MessageQueue() MessageQueue() MessageQueue()

Inizializza una nuova istanza della classe MessageQueue.Initializes a new instance of the MessageQueue class. Dopo che il costruttore senza parametri ha inizializzato la nuova istanza, è necessario impostare la proprietà Path dell'istanza prima di poterla usare.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

MessageQueue(String) MessageQueue(String) MessageQueue(String) MessageQueue(String)

Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda di Accodamento messaggi nel percorso specificato.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

MessageQueue(String, Boolean) MessageQueue(String, Boolean) MessageQueue(String, Boolean) MessageQueue(String, Boolean)

Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda di Accodamento messaggi nel percorso specificato e con la restrizione specificata per l'accesso in lettura.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean)

Inizializza una nuova istanza della classe MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode) MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inizializza una nuova istanza della classe MessageQueue.Initializes a new instance of the MessageQueue class.

MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode) MessageQueue(String, QueueAccessMode)

Inizializza una nuova istanza della classe MessageQueue.Initializes a new instance of the MessageQueue class.

Campi

InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize

Specifica che non sono previste restrizioni relative alle dimensioni di una coda.Specifies that no size restriction exists for a queue.

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Specifica che non è previsto un timeout per i metodi che leggono o ricevono messaggi.Specifies that no time-out exists for methods that peek or receive messages.

Proprietà

AccessMode AccessMode AccessMode AccessMode

Ottiene un valore che indica la modalità di accesso per la coda.Gets a value that indicates the access mode for the queue.

Authenticate Authenticate Authenticate Authenticate

Ottiene o imposta un valore che indica se la coda accetta solo messaggi autenticati.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority BasePriority BasePriority BasePriority

Ottiene o imposta la priorità di base utilizzata da Accodamento messaggi per effettuare il routing dei messaggi di una coda pubblica sulla rete.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
CanRead CanRead CanRead CanRead

Ottiene un valore che indica se è possibile leggere l'oggetto MessageQueue.Gets a value that indicates whether the MessageQueue can be read.

CanWrite CanWrite CanWrite CanWrite

Ottiene un valore che indica se è possibile scrivere nell'oggetto MessageQueue.Gets a value that indicates whether the MessageQueue can be written to.

Category Category Category Category

Ottiene o imposta la categoria della coda.Gets or sets the queue category.

Container Container Container Container

Ottiene il IContainer che contiene il Component.Gets the IContainer that contains the Component.

(Inherited from Component)
CreateTime CreateTime CreateTime CreateTime

Ottiene la data e l'ora di creazione della coda in Accodamento messaggi.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend

Ottiene o imposta i valori di proprietà dei messaggi da utilizzare per impostazione predefinita quando vengono inviati messaggi alla coda dall'applicazione.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive DenySharedReceive DenySharedReceive DenySharedReceive

Ottiene o imposta un valore che indica se l'oggetto MessageQueue dispone dell'accesso esclusivo per la ricezione dei messaggi dalla coda di Accodamento messaggi.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode DesignMode DesignMode DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableConnectionCache EnableConnectionCache EnableConnectionCache EnableConnectionCache

Ottiene o imposta un valore che indica se l'applicazione gestirà una cache di connessioni.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired EncryptionRequired EncryptionRequired EncryptionRequired

Ottiene o imposta un valore che indica se la coda accetta solo messaggi non privati (non crittografati).Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events Events Events Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
FormatName FormatName FormatName FormatName

Ottiene il nome univoco generato per la coda da Accodamento messaggi al momento della creazione della coda.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter Formatter Formatter Formatter

Ottiene o imposta il formattatore utilizzato per serializzare o deserializzare un oggetto dal corpo di un messaggio letto o scritto in una coda.Gets or sets the formatter used to serialize an object into or deserialize an object from the body of a message read from or written to the queue.

Id Id Id Id

Ottiene l'identificatore univoco di Accodamento messaggi per la coda.Gets the unique Message Queuing identifier of the queue.

Label Label Label Label

Ottiene o imposta la descrizione della coda.Gets or sets the queue description.

LastModifyTime LastModifyTime LastModifyTime LastModifyTime

Ottiene la data e l'ora dell'ultima modifica delle proprietà di una coda.Gets the last time the properties of a queue were modified.

MachineName MachineName MachineName MachineName

Ottiene o imposta il nome del computer in cui si trova la coda di Accodamento messaggi.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize MaximumJournalSize MaximumJournalSize MaximumJournalSize

Ottiene o imposta la dimensione massima della coda del giornale di registrazione.Gets or sets the maximum size of the journal queue.

MaximumQueueSize MaximumQueueSize MaximumQueueSize MaximumQueueSize

Ottiene o imposta la dimensione massima della coda.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter

Ottiene o imposta il filtro di proprietà per la ricezione o la visualizzazione dei messaggi.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress MulticastAddress MulticastAddress MulticastAddress

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Ottiene o imposta l'indirizzo multicast associato alla coda.Gets or sets the multicast address associated with the queue.

Path Path Path Path

Ottiene o imposta il percorso della coda.Gets or sets the queue's path. Impostando la proprietà Path, MessageQueue punta a una nuova coda.Setting the Path causes the MessageQueue to point to a new queue.

QueueName QueueName QueueName QueueName

Ottiene o imposta il nome descrittivo che identifica la coda.Gets or sets the friendly name that identifies the queue.

ReadHandle ReadHandle ReadHandle ReadHandle

Ottiene l'handle nativo utilizzato per leggere i messaggi dalla coda di messaggi.Gets the native handle used to read messages from the message queue.

Site Site Site Site

Ottiene o imposta l'oggetto ISite di Component.Gets or sets the ISite of the Component.

(Inherited from Component)
SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Ottiene o imposta l'oggetto utilizzato per effettuare il marshalling della chiamata al gestore eventi risultante da un evento ReceiveCompleted o PeekCompleted.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional Transactional Transactional Transactional

Ottiene un valore che indica se la coda accetta solo transazioni.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

Ottiene o imposta un valore che indica se i messaggi ricevuti vengono copiati nella coda del giornale di registrazione.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle WriteHandle WriteHandle WriteHandle

Ottiene l'handle nativo utilizzato per inviare messaggi alla coda di messaggi.Gets the native handle used to send messages to the message queue.

Metodi

BeginPeek() BeginPeek() BeginPeek() BeginPeek()

Avvia un'operazione di lettura asincrona per la quale non è stato specificato un intervallo di timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan)

Avvia un'operazione di lettura asincrona per la quale è stato specificato un periodo di timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Avvia un'operazione di lettura asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione.The state object provides associated information throughout the lifetime of the operation. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object)

Avvia un'operazione di lettura asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback)

Avvia un'operazione di lettura asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive() BeginReceive() BeginReceive() BeginReceive()

Avvia un'operazione di ricezione asincrona per la quale non è stato specificato alcun timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan)

Avvia un'operazione di ricezione asincrona per la quale è stato specificato un periodo di timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione.The state object provides associated information throughout the lifetime of the operation. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback)

Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione.This overload receives notification, through a callback, of the identity of the event handler for the operation. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

ClearConnectionCache() ClearConnectionCache() ClearConnectionCache() ClearConnectionCache()

Svuota la cache delle connessioni.Clears the connection cache.

Close() Close() Close() Close()

Libera tutte le risorse allocate da MessageQueue.Frees all resources allocated by the MessageQueue.

Create(String) Create(String) Create(String) Create(String)

Crea una coda non transazionale di Accodamento messaggi nel percorso specificato.Creates a non-transactional Message Queuing queue at the specified path.

Create(String, Boolean) Create(String, Boolean) Create(String, Boolean) Create(String, Boolean)

Crea una coda transazionale o non transazionale di Accodamento messaggi nel percorso specificato.Creates a transactional or non-transactional Message Queuing queue at the specified path.

CreateCursor() CreateCursor() CreateCursor() CreateCursor()

Crea un nuovo oggetto Cursor per la coda messaggi corrente.Creates a new Cursor for the current message queue.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Delete(String) Delete(String) Delete(String) Delete(String)

Elimina una coda su un server di Accodamento messaggi.Deletes a queue on a Message Queuing server.

Dispose() Dispose() Dispose() Dispose()

Rilascia tutte le risorse usate da Component.Releases all resources used by the Component.

(Inherited from Component)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Elimina le risorse, diverse dalla memoria, usate dall'oggetto MessageQueue.Disposes of the resources (other than memory) used by the MessageQueue.

EndPeek(IAsyncResult) EndPeek(IAsyncResult) EndPeek(IAsyncResult) EndPeek(IAsyncResult)

Completa l'operazione di visualizzazione asincrona specificata.Completes the specified asynchronous peek operation.

EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult) EndReceive(IAsyncResult)

Completa l'operazione di ricezione asincrona specificata.Completes the specified asynchronous receive operation.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists(String) Exists(String) Exists(String) Exists(String)

Determina se una coda di Accodamento messaggi è presente nel percorso specificato.Determines whether a Message Queuing queue exists at the specified path.

GetAllMessages() GetAllMessages() GetAllMessages() GetAllMessages()

Restituisce tutti i messaggi presenti nella coda.Returns all the messages that are in the queue.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Enumera i messaggi in una coda.Enumerates the messages in a queue. L'oggetto GetEnumerator() è deprecato.GetEnumerator() is deprecated. È consigliabile utilizzare invece GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetMachineId(String) GetMachineId(String) GetMachineId(String) GetMachineId(String)

Ottiene l'identificatore del computer in cui viene posizionata la coda cui MessageQueue fa riferimento.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

GetMessageEnumerator() GetMessageEnumerator() GetMessageEnumerator() GetMessageEnumerator()

Crea un oggetto enumeratore per tutti i messaggi contenuti nella coda.Creates an enumerator object for all the messages in the queue. L'oggetto GetMessageEnumerator() è deprecato.GetMessageEnumerator() is deprecated. È consigliabile utilizzare invece GetMessageEnumerator2().GetMessageEnumerator2() should be used instead.

GetMessageEnumerator2() GetMessageEnumerator2() GetMessageEnumerator2() GetMessageEnumerator2()

Crea un oggetto enumeratore per tutti i messaggi contenuti nella coda.Creates an enumerator object for all the messages in the queue.

GetMessageQueueEnumerator() GetMessageQueueEnumerator() GetMessageQueueEnumerator() GetMessageQueueEnumerator()

Fornisce la semantica del cursore forward-only per enumerare tutte le code pubbliche sulla rete.Provides forward-only cursor semantics to enumerate through all public queues on the network.

GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria)

Fornisce la semantica del cursore forward-only per enumerare tutte le code pubbliche sulla rete che soddisfano i criteri specificati.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String)

Recupera tutte le code private sul computer specificato.Retrieves all the private queues on the specified computer.

GetPublicQueues() GetPublicQueues() GetPublicQueues() GetPublicQueues()

Recupera tutte le code pubbliche sulla rete.Retrieves all the public queues on the network.

GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria) GetPublicQueues(MessageQueueCriteria)

Recupera tutte le code pubbliche sulla rete che soddisfano i criteri specificati.Retrieves all the public queues on the network that meet the specified criteria.

GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid) GetPublicQueuesByCategory(Guid)

Recupera tutte le code pubbliche sulla rete appartenenti alla categoria specificata.Retrieves all the public queues on the network that belong to the specified category.

GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String) GetPublicQueuesByLabel(String)

Recupera tutte le code pubbliche sulla rete contenenti l'etichetta specificata.Retrieves all the public queues on the network that carry the specified label.

GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String) GetPublicQueuesByMachine(String)

Recupera tutte le code pubbliche che risiedono sul computer specificato.Retrieves all the public queues that reside on the specified computer.

GetSecurityContext() GetSecurityContext() GetSecurityContext() GetSecurityContext()

Recupera il contesto di sicurezza che MSMQ associa all'utente corrente (identità del thread) nel momento in cui viene eseguita questa chiamata.Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
Peek() Peek() Peek() Peek()

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

Peek(TimeSpan) Peek(TimeSpan) Peek(TimeSpan) Peek(TimeSpan)

Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction)

Termina senza rimuovere (legge) il messaggio corrente o successivo della coda, utilizzando il cursore specificato.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

PeekByCorrelationId(String) PeekByCorrelationId(String) PeekByCorrelationId(String) PeekByCorrelationId(String)

Legge il messaggio che corrisponde all'identificatore di correlazione specificato e, se nella coda non è disponibile correntemente alcun messaggio con l'identificatore di correlazione specificato, genererà immediatamente un'eccezione.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan)

Legge il messaggio che corrisponde all'identificatore di correlazione specificato e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda o che il timeout scada.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String) PeekById(String) PeekById(String) PeekById(String)

Legge il messaggio il cui identificatore corrisponde al parametro id.Peeks the message whose message identifier matches the id parameter.

PeekById(String, TimeSpan) PeekById(String, TimeSpan) PeekById(String, TimeSpan) PeekById(String, TimeSpan)

Legge il messaggio il cui identificatore corrisponde al parametro id.Peeks the message whose message identifier matches the id parameter. Attende che il messaggio venga visualizzato nella coda o che si verifichi il timeout.Waits until the message appears in the queue or a time-out occurs.

PeekByLookupId(Int64) PeekByLookupId(Int64) PeekByLookupId(Int64) PeekByLookupId(Int64)

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Legge il messaggio che corrisponde all'identificatore di ricerca specificato da una coda non transazionale.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64)

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Legge un messaggio specifico nella coda.Peeks at a specific message from the queue. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge() Purge() Purge() Purge()

Elimina tutti i messaggi contenuti nella coda.Deletes all the messages contained in the queue.

Receive() Receive() Receive() 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) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) 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) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) 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) Receive(TimeSpan) Receive(TimeSpan) 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) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) 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, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) 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) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) 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(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) 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) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) 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.

ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) ReceiveByCorrelationId(String)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda non transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda non transazionale) e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda oppure che il timeout scada.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda transazionale) e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda oppure che il timeout scada.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

Riceve il messaggio che corrisponde all'identificatore di correlazione specificato e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda o che il timeout scada.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveById(String) ReceiveById(String) ReceiveById(String) ReceiveById(String)

Riceve il messaggio che corrisponde all'identificatore specificato da una coda non transazionale e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction)

Riceve il messaggio che corrisponde all'identificatore specificato (da una coda transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType)

Riceve il messaggio corrispondente all'identificatore specificato e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan)

Riceve il messaggio corrispondente all'identificatore specificato (da una coda non transazionale) e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction)

Riceve il messaggio corrispondente all'identificatore specificato (da una coda transazionale) e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType)

Riceve il messaggio che corrisponde all'identificatore specificato e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64)

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Riceve il messaggio che corrisponde all'identificatore di ricerca specificato da una coda non transazionale.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Riceve un messaggio specifico da una coda transazionale.Receives a specific message from a transactional queue. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Riceve un messaggio specifico della coda, utilizzando il contesto di transazione specificato.Receives a specific message from the queue, using the specified transaction context. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh() Refresh() Refresh() Refresh()

Aggiorna le proprietà presentate da MessageQueue per riflettere lo stato corrente della risorsa.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

ResetPermissions() ResetPermissions() ResetPermissions() ResetPermissions()

Reimposta l'elenco delle autorizzazioni sui valori predefiniti del sistema operativo.Resets the permission list to the operating system's default values. Rimuove tutte le autorizzazioni relative alla coda aggiunte all'elenco predefinito.Removes any queue permissions you have appended to the default list.

Send(Object) Send(Object) Send(Object) Send(Object)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction) Send(Object, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType) Send(Object, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String) Send(Object, String) Send(Object, String) Send(Object, String)

Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction) Send(Object, String, MessageQueueTransaction) Send(Object, String, MessageQueueTransaction) Send(Object, String, MessageQueueTransaction)

Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType) Send(Object, String, MessageQueueTransactionType)

Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList)

Assegna i diritti di accesso alla coda in base al contenuto di un elenco di controllo di accesso.Assigns access rights to the queue based on the contents of an access control list.

SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry) SetPermissions(MessageQueueAccessControlEntry)

Assegna i diritti di accesso alla coda in base al contenuto di una voce di controllo di accesso.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights)

Fornisce a un computer, a un gruppo o a un utente i diritti di accesso specificati.Gives a computer, group, or user the specified access rights.

SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)

Concede a un computer, a un utente o a un gruppo di utenti i diritti di accesso specificati con il tipo di controllo di accesso specificato (concessione, rifiuto, revoca o impostazione).Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString() ToString() ToString() ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component.Returns a String containing the name of the Component, if any. Questo metodo non deve essere sottoposto a override.This method should not be overridden.

(Inherited from Component)

Eventi

Disposed Disposed Disposed Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
PeekCompleted PeekCompleted PeekCompleted PeekCompleted

Viene generato quando un messaggio viene letto senza essere rimosso dalla coda.Occurs when a message is read without being removed from the queue. Si tratta del risultato dell'operazione asincrona BeginPeek().This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted ReceiveCompleted ReceiveCompleted ReceiveCompleted

Viene generato quando un messaggio è stato rimosso dalla coda.Occurs when a message has been removed from the queue. Questo evento viene generato dall'operazione asincrona BeginReceive().This event is raised by the asynchronous operation, BeginReceive().

Metodi di estensione

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a

Thread safety

Solo il GetAllMessages() metodo è thread-safe.Only the GetAllMessages() method is thread safe.

Vedi anche