MessageQueue MessageQueue MessageQueue MessageQueue Class

Definição

Fornece acesso a uma fila de um servidor do Enfileiramento de Mensagens.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
Herança
Atributos
Implementações

Exemplos

O exemplo de código a seguir MessageQueue cria novos objetos usando vários tipos de sintaxe de nome de caminho.The following code example creates new MessageQueue objects using various path name syntax types. Em cada caso, ele envia uma mensagem para a fila cujo caminho é definido no construtor.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 

O exemplo de código a seguir envia uma mensagem para uma fila e recebe uma mensagem de uma fila, usando uma classe específica do aplicativo Orderchamada.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

Comentários

A tecnologia de enfileiramento de mensagens permite que os aplicativos executados em momentos diferentes se comuniquem em redes e sistemas heterogêneos que podem estar temporariamente offline.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Aplicativos enviam, recebem ou inspecionam (leia sem remover) mensagens de filas.Applications send, receive, or peek (read without removing) messages from queues. O enfileiramento de mensagens é Windows 2000Windows 2000 um componente opcional do e do Windows NT e deve ser instalado separadamente.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

A MessageQueue classe é um wrapper em relação ao enfileiramento de mensagens.The MessageQueue class is a wrapper around Message Queuing. Há várias versões do enfileiramento de mensagens e o MessageQueue uso da classe pode resultar em um comportamento ligeiramente diferente, dependendo do sistema operacional que você está usando.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. Para obter informações sobre recursos específicos de cada versão do enfileiramento de mensagens, consulte o tópico "novidades no enfileiramento de mensagens" no SDK da plataforma no 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.

A MessageQueue classe fornece uma referência a uma fila do serviço de enfileiramento de mensagens.The MessageQueue class provides a reference to a Message Queuing queue. Você pode especificar um caminho no MessageQueue Construtor para se conectar a um recurso existente ou pode criar uma nova fila no servidor.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. Antes de poder chamar Send(Object), Peek, ou Receive, MessageQueue você deve associar a nova instância da classe a uma fila existente.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. Nesse ponto, você pode manipular as propriedades da fila, como Category e Label.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueuedá suporte a dois tipos de recuperação de mensagem: síncrona e assíncrona.MessageQueue supports two types of message retrieval: synchronous and asynchronous. Os métodos Peek síncronos e Receivefazem com que o thread do processo Aguarde um intervalo de tempo especificado para que uma nova mensagem chegue na fila.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. Os métodos BeginPeek assíncronos e BeginReceivepermitem que as tarefas do aplicativo principal continuem em um thread separado até que uma mensagem chegue na fila.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Esses métodos funcionam usando objetos de retorno de chamada e objetos de estado para comunicar informações entre threads.These methods work by using callback objects and state objects to communicate information between threads.

Ao criar uma nova instância da MessageQueue classe, você não está criando uma nova fila de enfileiramento de mensagens.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. Em vez disso, você pode Create(String)usar Delete(String)os métodos Purge , e para gerenciar filas no servidor.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

Ao Purgecontrário Create(String) de Delete(String) , e MessageQueue são static Membros, para que você possa chamá-los sem criar uma nova instância da 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.

Você pode definir a MessageQueue Propriedade do Path objeto com um dos três nomes: o nome amigável, o FormatNameou o Label.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. O nome MachineName amigável, que é definido pelas propriedades e Private$ \ \ MachineName QueueName da fila, é \ QueueName para uma fila pública e MachineName QueueName para uma fila particular.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. A FormatName propriedade permite o acesso offline a filas de mensagens.The FormatName property allows offline access to message queues. Por fim, você pode usar a propriedade da Label fila para definir a Pathfila.Lastly, you can use the queue's Label property to set the queue's Path.

Para obter uma lista de valores de propriedade inicial para uma MessageQueueinstância do, MessageQueue consulte o construtor.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Construtores

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

Inicializa uma nova instância da classe MessageQueue.Initializes a new instance of the MessageQueue class. Depois que o construtor sem parâmetros inicializar a nova instância, você precisará definir a propriedade Path da instância antes de usar a instância.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)

Inicializa uma nova instância da classe MessageQueue que referencia a fila de Enfileiramento de Mensagens no caminho especificado.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)

Inicializa uma nova instância da classe MessageQueue que referencia a fila do serviço de enfileiramento de mensagens no caminho especificado e com a restrição de acesso de leitura especificada.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)

Inicializa uma nova instância da 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)

Inicializa uma nova instância da classe MessageQueue.Initializes a new instance of the MessageQueue class.

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

Inicializa uma nova instância da classe MessageQueue.Initializes a new instance of the MessageQueue class.

Campos

InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize

Especifica que não existe nenhuma restrição de tamanho para uma fila.Specifies that no size restriction exists for a queue.

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Especifica que não existe nenhum tempo limite para os métodos que espiam ou recebem mensagens.Specifies that no time-out exists for methods that peek or receive messages.

Propriedades

AccessMode AccessMode AccessMode AccessMode

Obtém um valor que indica o modo de acesso da fila.Gets a value that indicates the access mode for the queue.

Authenticate Authenticate Authenticate Authenticate

Obtém ou define um valor que indica se a fila aceita apenas mensagens autenticadas.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority BasePriority BasePriority BasePriority

Obtém ou define a prioridade base que o Enfileiramento de Mensagens usa para rotear mensagens de uma fila pública pela rede.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
CanRead CanRead CanRead CanRead

Obtém um valor que indica se o MessageQueue pode ser lido.Gets a value that indicates whether the MessageQueue can be read.

CanWrite CanWrite CanWrite CanWrite

Obtém um valor que indica se é possível gravar no MessageQueue.Gets a value that indicates whether the MessageQueue can be written to.

Category Category Category Category

Obtém ou define a categoria da fila.Gets or sets the queue category.

Container Container Container Container

Obtém o IContainer que contém o Component.Gets the IContainer that contains the Component.

(Inherited from Component)
CreateTime CreateTime CreateTime CreateTime

Obtém a hora e a data em que a fila foi criada no Enfileiramento de Mensagens.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend

Obtém ou define os valores da propriedade da mensagem a serem usados por padrão quando o aplicativo envia mensagens para a fila.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive DenySharedReceive DenySharedReceive DenySharedReceive

Obtém ou define um valor que indica se este MessageQueue tem acesso exclusivo para receber mensagens da fila do Enfileiramento de Mensagens.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

Obtém um valor que indica se o Component está no modo de design no momento.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableConnectionCache EnableConnectionCache EnableConnectionCache EnableConnectionCache

Obtém ou define um valor que indica se um cache de conexões será mantido pelo aplicativo.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired EncryptionRequired EncryptionRequired EncryptionRequired

Obtém ou define um valor que indica se a fila aceita apenas mensagens não privadas (não criptografadas).Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events Events Events Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
FormatName FormatName FormatName FormatName

Obtém o nome de fila exclusivo que o Enfileiramento de Mensagens gerou no momento da criação da fila.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter Formatter Formatter Formatter

Obtém ou define o formatador usado para serializar ou desserializar um objeto do corpo de uma mensagem lida ou gravada na fila.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

Obtém o identificador exclusivo de Enfileiramento de Mensagens da fila.Gets the unique Message Queuing identifier of the queue.

Label Label Label Label

Obtém ou define a descrição da fila.Gets or sets the queue description.

LastModifyTime LastModifyTime LastModifyTime LastModifyTime

Obtém a última vez que as propriedades de uma fila foram modificadas.Gets the last time the properties of a queue were modified.

MachineName MachineName MachineName MachineName

Obtém ou define o nome do computador em que a fila do serviço de enfileiramento de mensagens está localizada.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize MaximumJournalSize MaximumJournalSize MaximumJournalSize

Obtém ou define o tamanho máximo da fila de diário.Gets or sets the maximum size of the journal queue.

MaximumQueueSize MaximumQueueSize MaximumQueueSize MaximumQueueSize

Obtém ou define o tamanho máximo da fila.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter

Obtém ou define o filtro de propriedade para receber ou espiar mensagens.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress MulticastAddress MulticastAddress MulticastAddress

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Obtém ou define o endereço multicast associado à fila.Gets or sets the multicast address associated with the queue.

Path Path Path Path

Obtém ou define o caminho da fila.Gets or sets the queue's path. Definir o Path faz com que o MessageQueue aponte para uma nova fila.Setting the Path causes the MessageQueue to point to a new queue.

QueueName QueueName QueueName QueueName

Obtém ou define o nome amigável que identifica a fila.Gets or sets the friendly name that identifies the queue.

ReadHandle ReadHandle ReadHandle ReadHandle

Obtém o identificador nativo usado para ler as mensagens da fila de mensagens.Gets the native handle used to read messages from the message queue.

Site Site Site Site

Obtém ou define o ISite do Component.Gets or sets the ISite of the Component.

(Inherited from Component)
SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Obtém ou define o objeto que realiza marshal da chamada do manipulador de eventos resultante de um evento ReceiveCompleted ou PeekCompleted.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional Transactional Transactional Transactional

Obtém um valor que indica se a fila aceita apenas as transações.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

Obtém ou define um valor que indica se as mensagens recebidas são copiadas para a fila de diário.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle WriteHandle WriteHandle WriteHandle

Obtém identificador nativo utilizado para enviar mensagens para a fila de mensagens.Gets the native handle used to send messages to the message queue.

Métodos

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

Inicia uma operação de espiada assíncrona que não tem um tempo limite. A operação não é concluída até que uma mensagem se torna disponível na fila.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)

Inicia uma operação de espiada assíncrona que tem um tempo limite especificado. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação de espiada assíncrona que tem um tempo limite especificado e usa um cursor específico, uma ação de espiada especificada e um objeto de estado especificado.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. O objeto de estado fornece informações associadas em todo o tempo de vida da operação.The state object provides associated information throughout the lifetime of the operation. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação.This overload receives notification, through a callback, of the identity of the event handler for the operation. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação.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. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação assíncrona de espiada que tem um tempo limite especificado e um objeto de estado especificado, que fornece informações associadas durante todo o tempo de vida da operação.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. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação.This overload receives notification, through a callback, of the identity of the event handler for the operation. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Inicia uma operação de recebimento assíncrona que não tem um tempo limite. A operação não é concluída até que uma mensagem se torna disponível na fila.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)

Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado e usa um cursor especificado e um objeto de estado especificado.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. O objeto de estado fornece informações associadas em todo o tempo de vida da operação.The state object provides associated information throughout the lifetime of the operation. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação.This overload receives notification, through a callback, of the identity of the event handler for the operation. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação de recebimento assíncrona que tem um tempo limite e um objeto de estado especificados, que fornece informações associadas durante o tempo de vida da operação.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. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.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)

Inicia uma operação de recebimento assíncrona que tem um tempo limite e um objeto de estado especificados, que fornece informações associadas durante o tempo de vida da operação.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. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação.This overload receives notification, through a callback, of the identity of the event handler for the operation. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Limpa o cache de conexão.Clears the connection cache.

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

Libera todos os recursos alocados pelo MessageQueue.Frees all resources allocated by the MessageQueue.

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

Cria uma fila não transacional do serviço de enfileiramento de mensagens no caminho especificado.Creates a non-transactional Message Queuing queue at the specified path.

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

Cria uma fila transacional ou não transacional do Enfileiramento de Mensagens no caminho especificado.Creates a transactional or non-transactional Message Queuing queue at the specified path.

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

Cria um novo Cursor para a fila de mensagens atual.Creates a new Cursor for the current message queue.

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

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto 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)

Exclui uma fila em um servidor de Enfileiramento de Mensagens.Deletes a queue on a Message Queuing server.

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

Libera todos os recursos usados pelo Component.Releases all resources used by the Component.

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

Descarta os recursos (exceto a memória) usados pelo MessageQueue.Disposes of the resources (other than memory) used by the MessageQueue.

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

Conclui a operação de espiada assíncrona especificada.Completes the specified asynchronous peek operation.

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

Conclui a operação de recebimento assíncrono especificada.Completes the specified asynchronous receive operation.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Determina se existe uma fila de Enfileiramento de Mensagens no caminho especificado.Determines whether a Message Queuing queue exists at the specified path.

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

Retorna todas as mensagens na fila.Returns all the messages that are in the queue.

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

Enumera as mensagens em uma fila.Enumerates the messages in a queue. O GetEnumerator() foi preterido.GetEnumerator() is deprecated. Em vez disso, GetMessageEnumerator2() deve ser usado.GetMessageEnumerator2() should be used instead.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.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)

Obtém o identificador do computador no qual a fila referenciada por este MessageQueue está localizada.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

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

Cria um objeto enumerador para todas as mensagens na fila.Creates an enumerator object for all the messages in the queue. O GetMessageEnumerator() foi preterido.GetMessageEnumerator() is deprecated. Em vez disso, GetMessageEnumerator2() deve ser usado.GetMessageEnumerator2() should be used instead.

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

Cria um objeto enumerador para todas as mensagens na fila.Creates an enumerator object for all the messages in the queue.

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

Fornece a semântica de cursor somente de avanço para enumerar todas as filas públicas na rede.Provides forward-only cursor semantics to enumerate through all public queues on the network.

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

Fornece a semântica de cursor somente de avanço para enumerar todas as filas públicas na rede que atendem aos critérios especificados.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 todas as filas privativas no computador especificado.Retrieves all the private queues on the specified computer.

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

Recupera todas as filas públicas na rede.Retrieves all the public queues on the network.

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

Recupera todas as filas públicas na rede que atendem aos critérios especificados.Retrieves all the public queues on the network that meet the specified criteria.

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

Recupera todas as filas públicas na rede que pertencem à categoria especificada.Retrieves all the public queues on the network that belong to the specified category.

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

Recupera todas as filas públicas na rede que contêm o rótulo especificado.Retrieves all the public queues on the network that carry the specified label.

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

Recupera todas as filas públicas que residem no computador especificado.Retrieves all the public queues that reside on the specified computer.

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

Recupera o contexto de segurança que o MSMQ associa ao usuário atual (identidade de thread) no momento desta chamada.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)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.Returns an object that represents a service provided by the Component or by its Container.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

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

Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. O método Peek() é síncrono. Portanto, ele bloqueia o thread atual até que uma mensagem se torne disponível.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

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

Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.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)

Retorna sem remover (espia) a mensagem atual ou a próxima na fila usando o cursor especificado.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. O método Peek() é síncrono e, portanto, bloqueia o thread atual até que uma mensagem fique disponível ou o tempo limite especificado seja atingido.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)

Exibe a mensagem que corresponde ao identificador de correlação especificado e gerará imediatamente uma exceção se nenhuma mensagem com o identificador de correlação especificado existir atualmente na fila.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)

Espia a mensagem que corresponde ao identificador de correlação fornecido e aguarda até uma mensagem com o identificador de correlação especificado estar disponível na fila ou até o tempo limite expirar.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)

Espia a mensagem cujo identificador de mensagem corresponde ao parâmetro id.Peeks the message whose message identifier matches the id parameter.

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

Espia a mensagem cujo identificador de mensagem corresponde ao parâmetro id.Peeks the message whose message identifier matches the id parameter. Aguarda até que a mensagem seja exibida na fila ou um tempo limite ocorra.Waits until the message appears in the queue or a time-out occurs.

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

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Espiada na mensagem que corresponde ao identificador de pesquisa especificado de uma fila não transacional.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)

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Espia uma mensagem específica da fila.Peeks at a specific message from the queue. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila.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()

Exclui todas as mensagens contidas na fila.Deletes all the messages contained in the queue.

Receive() Receive() Receive() Receive()

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Essa chamada é síncrona e bloqueia a execução do thread atual até que uma mensagem esteja disponível.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction) Receive(MessageQueueTransaction)

Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. Essa chamada é síncrona e bloqueia a execução do thread atual até que uma mensagem esteja disponível.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType) Receive(MessageQueueTransactionType)

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Essa chamada é síncrona e bloqueia a execução do thread atual até que uma mensagem esteja disponível.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan)

Recebe a primeira mensagem disponível na fila referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.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)

Recebe a mensagem atual na fila usando um cursor especificado.Receives the current message in the queue, using a specified cursor. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.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)

Recebe a mensagem atual na fila usando um cursor especificado.Receives the current message in the queue, using a specified cursor. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.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)

Recebe a mensagem atual na fila usando um cursor especificado.Receives the current message in the queue, using a specified cursor. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar.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)

Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue e aguarda até que uma mensagem esteja disponível na fila ou o tempo limite expire.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)

Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta chamada é síncrona e aguarda até que uma mensagem esteja disponível na fila ou que o tempo limite expire.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)

Recebe a mensagem que corresponde ao identificador de correlação fornecido (de uma fila não transacional) e gera uma exceção imediatamente se nenhuma mensagem com o identificador de correlação existir atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador de correlação fornecido (de uma fila transacional) e gera uma exceção imediatamente se nenhuma mensagem com o identificador de correlação existir atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador de correlação especificado e gerará imediatamente uma exceção se nenhuma mensagem com o identificador de correlação especificado existir atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador de correlação fornecido (de uma fila não transacional) e aguarda até uma mensagem com o identificador de correlação especificado estar disponível na fila ou até o tempo limite expirar.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)

Recebe a mensagem que corresponde ao identificador de correlação fornecido (de uma fila transacional) e aguarda até uma mensagem com o identificador de correlação especificado estar disponível na fila ou até o tempo limite expirar.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)

Recebe a mensagem que corresponde ao identificador de correlação fornecido e aguarda até uma mensagem com o identificador de correlação especificado estar disponível na fila ou até o tempo limite expirar.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)

Recebe a mensagem que corresponde ao identificador fornecido (de uma fila não transacional) e gera uma exceção imediatamente se nenhuma mensagem com o identificador existe atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador fornecido (de uma fila transacional) e gera uma exceção imediatamente se nenhuma mensagem com o identificador existe atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador especificado e gerará imediatamente uma exceção se nenhuma mensagem com o identificador especificado existir atualmente na fila.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)

Recebe a mensagem que corresponde ao identificador fornecido (de uma fila não transacional) e aguarda até uma mensagem com o identificador estar disponível na fila ou tempo limite expirar.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)

Recebe a mensagem que corresponde ao identificador fornecido (de uma fila transacional) e aguarda até uma mensagem com o identificador estar disponível na fila ou tempo limite expirar.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)

Recebe a mensagem que corresponde ao identificador fornecido e aguarda até uma mensagem com o identificador estar disponível na fila ou tempo limite expirar.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)

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Recebe a mensagem que corresponde ao identificador de pesquisa especificado de uma fila não transacional.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)

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Recebe uma mensagem específica de uma fila transacional.Receives a specific message from a transactional queue. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila.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)

Introduzido no MSMQ 3.0.Introduced in MSMQ 3.0. Recebe uma mensagem específica da fila, usando o contexto de transação especificado.Receives a specific message from the queue, using the specified transaction context. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila.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()

Atualiza as propriedades apresentadas pelo MessageQueue para refletir o estado atual do recurso.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

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

Redefine a lista de permissões para os valores padrão do sistema operacional.Resets the permission list to the operating system's default values. Remove quaisquer permissões de fila que você tenha anexado à lista padrão.Removes any queue permissions you have appended to the default list.

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

Envia um objeto a uma fila não transacional referenciada por essa MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

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

Envia um objeto para a fila transacional referenciada por este MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

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

Envia um objeto para a fila referenciada por esse MessageQueue.Sends an object to the queue referenced by this MessageQueue.

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

Envia um objeto para a fila não transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.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)

Envia um objeto para a fila transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem.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)

Envia um objeto para a fila referenciada por esse MessageQueue e especifica um rótulo para a mensagem.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)

Atribui direitos de acesso à fila com base no conteúdo de uma lista de controle de acesso.Assigns access rights to the queue based on the contents of an access control list.

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

Atribui direitos de acesso para a fila com base no conteúdo de uma entrada de controle de acesso.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)

Fornece os direitos de acesso especificados a um computador, grupo ou usuário.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)

Fornece a um computador, grupo ou usuário os direitos de acesso especificados, com o tipo de controle de acesso especificado (permitir, negar, revogar ou definir).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()

Retorna um String que contém o nome do Component, se houver.Returns a String containing the name of the Component, if any. Esse método não deve ser substituído.This method should not be overridden.

(Inherited from Component)

Eventos

Disposed Disposed Disposed Disposed

Ocorre quando o componente é disposto por uma chamada para o método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
PeekCompleted PeekCompleted PeekCompleted PeekCompleted

Ocorre quando uma mensagem é lida sem ser removida da fila.Occurs when a message is read without being removed from the queue. Este é o resultado da operação assíncrona, BeginPeek().This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted ReceiveCompleted ReceiveCompleted ReceiveCompleted

Ocorre quando uma mensagem foi removida da fila.Occurs when a message has been removed from the queue. Esse evento é gerado pela operação assíncrona, BeginReceive().This event is raised by the asynchronous operation, BeginReceive().

Métodos de Extensão

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

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

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

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita a paralelização de uma consulta.Enables parallelization of a query.

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

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Aplica-se a

Acesso thread-safe

Somente o GetAllMessages() método é thread-safe.Only the GetAllMessages() method is thread safe.

Veja também