MessageQueue Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Fornece acesso a uma fila de um servidor do Enfileiramento de Mensagens.
public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
public 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[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
type MessageQueue = class
inherit Component
interface IEnumerable[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
inherit Component
interface IEnumerablePublic Class MessageQueue
Inherits Component
Implements IEnumerable- Herança
- Atributos
- Implementações
Exemplos
O exemplo de código a seguir cria novos MessageQueue objetos usando vários tipos de sintaxe de nome de caminho. Em cada caso, ele envia uma mensagem para a fila cujo caminho é definido no construtor.
#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.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
' References public queues.
Public Sub SendPublic()
Dim myQueue As New MessageQueue(".\myQueue")
myQueue.Send("Public queue by path name.")
Return
End Sub
' References private queues.
Public Sub SendPrivate()
Dim myQueue As New MessageQueue(".\Private$\myQueue")
myQueue.Send("Private queue by path name.")
Return
End Sub
' References queues by label.
Public Sub SendByLabel()
Dim myQueue As New MessageQueue("Label:TheLabel")
myQueue.Send("Queue by label.")
Return
End Sub
' 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
' 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
' 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
' 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
' 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
End Class
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 chamada 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.Messaging
' This class represents an object the following example
' sends to a queue and receives from a queue.
Public Class Order
Public orderId As Integer
Public orderTime As DateTime
End Class
Public Class MyNewQueue
'
' Provides an entry point into the application.
'
' This example sends and receives a message from
' a qeue.
'
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue()
' Send a message to a queue.
myNewQueue.SendMessage()
' Receive a message from a queue.
myNewQueue.ReceiveMessage()
Return
End Sub
'
' Sends an Order to a queue.
'
Public Sub SendMessage()
' Create a new order and set values.
Dim sentOrder As New Order()
sentOrder.orderId = 3
sentOrder.orderTime = DateTime.Now
' Connect to a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Send the Order to the queue.
myQueue.Send(sentOrder)
Return
End Sub
'
' Receives a message containing an Order.
'
Public Sub ReceiveMessage()
' Connect to the a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Set the formatter to indicate the body contains an Order.
myQueue.Formatter = New XmlMessageFormatter(New Type() _
{GetType(Order)})
Try
' Receive and format the message.
Dim myMessage As Message = myQueue.Receive()
Dim myOrder As Order = CType(myMessage.Body, Order)
' Display message information.
Console.WriteLine(("Order ID: " + _
myOrder.orderId.ToString()))
Console.WriteLine(("Sent: " + _
myOrder.orderTime.ToString()))
Catch m As MessageQueueException
' Handle Message Queuing exceptions.
Catch e As InvalidOperationException
' Handle invalid serialization format.
Console.WriteLine(e.Message)
' Catch other exceptions as necessary.
End Try
Return
End Sub
End Class
Comentários
A tecnologia Enfileiramento de Mensagens permite que aplicativos em execução em momentos diferentes se comuniquem entre redes heterogêneas e sistemas que podem estar temporariamente offline. Os aplicativos enviam, recebem ou espiam (ler sem remover) mensagens das filas. O Enfileiramento de Mensagens é um componente opcional do Windows 2000 e Windows NT e deve ser instalado separadamente.
A MessageQueue classe é um wrapper em torno do Enfileiramento de Mensagens. Há várias versões do Enfileiramento de Mensagens e o uso da MessageQueue classe pode resultar em um comportamento ligeiramente diferente, dependendo do sistema operacional que você está usando.
A MessageQueue classe fornece uma referência a uma fila de Enfileiramento de Mensagens. Você pode especificar um caminho no MessageQueue construtor para se conectar a um recurso existente ou criar uma nova fila no servidor. Antes de chamar Send(Object), Peekou Receive, você deve associar a nova instância da classe a MessageQueue uma fila existente. Nesse ponto, você pode manipular as propriedades da fila, como Category e Label.
MessageQueue dá suporte a dois tipos de recuperação de mensagem: síncrono e assíncrono. Os métodos síncronos, Peek e Receive, fazem com que o thread de processo aguarde um intervalo de tempo especificado para que uma nova mensagem chegue na fila. Os métodos BeginPeek assíncronos e BeginReceive, permitem que as tarefas do aplicativo main continuem em um thread separado até que uma mensagem chegue à fila. Esses métodos funcionam usando objetos de retorno de chamada e objetos de estado para comunicar informações entre threads.
Ao criar uma nova instância da MessageQueue classe , você não está criando uma nova fila de Enfileiramento de Mensagens. Em vez disso, você pode usar os Create(String)métodos , Delete(String)e Purge para gerenciar filas no servidor.
Ao contrário Purgede , Create(String) e Delete(String) são static membros, portanto, você pode chamá-los sem criar uma nova instância da MessageQueue classe .
Você pode definir a MessageQueue propriedade do Path objeto com um dos três nomes: o nome amigável, o FormatNameou o Label. O nome amigável, que é definido pelas propriedades e da fila, é MachineNameQueueName\para uma fila pública ePrivate$\QueueNameMachineName\para uma fila privada.MachineNameQueueName A FormatName propriedade permite o acesso offline a filas de mensagens. Por fim, você pode usar a propriedade da Label fila para definir o da Pathfila.
Para obter uma lista de valores de propriedade iniciais para uma instância do MessageQueue, consulte o MessageQueue construtor .
Construtores
| MessageQueue() |
Inicializa uma nova instância da classe MessageQueue. 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. |
| MessageQueue(String) |
Inicializa uma nova instância da classe MessageQueue que referencia a fila de Enfileiramento de Mensagens no caminho especificado. |
| 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. |
| MessageQueue(String, Boolean, Boolean) |
Inicializa uma nova instância da classe MessageQueue. |
| MessageQueue(String, Boolean, Boolean, QueueAccessMode) |
Inicializa uma nova instância da classe MessageQueue. |
| MessageQueue(String, QueueAccessMode) |
Inicializa uma nova instância da classe MessageQueue. |
Campos
| InfiniteQueueSize |
Especifica que não existe nenhuma restrição de tamanho para uma fila. |
| InfiniteTimeout |
Especifica que não existe nenhum tempo limite para os métodos que espiam ou recebem mensagens. |
Propriedades
| AccessMode |
Obtém um valor que indica o modo de acesso da fila. |
| Authenticate |
Obtém ou define um valor que indica se a fila aceita apenas mensagens autenticadas. |
| BasePriority |
Obtém ou define a prioridade base que o Enfileiramento de Mensagens usa para rotear mensagens de uma fila pública pela rede. |
| CanRaiseEvents |
Obtém um valor que indica se o componente pode acionar um evento. (Herdado de Component) |
| CanRead |
Obtém um valor que indica se o MessageQueue pode ser lido. |
| CanWrite |
Obtém um valor que indica se é possível gravar no MessageQueue. |
| Category |
Obtém ou define a categoria da fila. |
| Container |
Obtém o IContainer que contém o Component. (Herdado de Component) |
| CreateTime |
Obtém a hora e a data em que a fila foi criada no Enfileiramento de Mensagens. |
| 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. |
| DenySharedReceive |
Obtém ou define um valor que indica se este MessageQueue tem acesso exclusivo para receber mensagens da fila do Enfileiramento de Mensagens. |
| DesignMode |
Obtém um valor que indica se o Component está no modo de design no momento. (Herdado de Component) |
| EnableConnectionCache |
Obtém ou define um valor que indica se um cache de conexões será mantido pelo aplicativo. |
| EncryptionRequired |
Obtém ou define um valor que indica se a fila aceita apenas mensagens não privadas (não criptografadas). |
| Events |
Obtém a lista de manipuladores de eventos que estão anexados a este Component. (Herdado de Component) |
| FormatName |
Obtém o nome de fila exclusivo que o Enfileiramento de Mensagens gerou no momento da criação da fila. |
| Formatter |
Obtém ou define o formatador usado para serializar ou desserializar um objeto do corpo de uma mensagem lida ou gravada na fila. |
| Id |
Obtém o identificador exclusivo de Enfileiramento de Mensagens da fila. |
| Label |
Obtém ou define a descrição da fila. |
| LastModifyTime |
Obtém a última vez que as propriedades de uma fila foram modificadas. |
| MachineName |
Obtém ou define o nome do computador em que a fila do serviço de enfileiramento de mensagens está localizada. |
| MaximumJournalSize |
Obtém ou define o tamanho máximo da fila de diário. |
| MaximumQueueSize |
Obtém ou define o tamanho máximo da fila. |
| MessageReadPropertyFilter |
Obtém ou define o filtro de propriedade para receber ou espiar mensagens. |
| MulticastAddress |
Introduzido no MSMQ 3.0. Obtém ou define o endereço multicast associado à fila. |
| Path |
Obtém ou define o caminho da fila. Definir o Path faz com que o MessageQueue aponte para uma nova fila. |
| QueueName |
Obtém ou define o nome amigável que identifica a fila. |
| ReadHandle |
Obtém o identificador nativo usado para ler as mensagens da fila de mensagens. |
| Site |
Obtém ou define o ISite do Component. (Herdado de Component) |
| SynchronizingObject |
Obtém ou define o objeto que realiza marshal da chamada do manipulador de eventos resultante de um evento ReceiveCompleted ou PeekCompleted. |
| Transactional |
Obtém um valor que indica se a fila aceita apenas as transações. |
| UseJournalQueue |
Obtém ou define um valor que indica se as mensagens recebidas são copiadas para a fila de diário. |
| WriteHandle |
Obtém identificador nativo utilizado para enviar mensagens para a fila de mensagens. |
Métodos
| BeginPeek() |
Inicia uma operação de espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila. |
| BeginPeek(TimeSpan) |
Inicia uma operação de espiada assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite. |
| 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. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| 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. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| 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. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| BeginReceive() |
Inicia uma operação de recebimento espiada assíncrona que não tem um tempo limite. A operação não será concluída até que uma mensagem fique disponível na fila. |
| BeginReceive(TimeSpan) |
Inicia uma operação de recebimento assíncrona que tem um tempo limite especificado. A operação não será concluída até que uma mensagem fique disponível na fila ou que ocorra o tempo limite. |
| 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. O objeto de estado fornece informações associadas em todo o tempo de vida da operação. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| 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. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| 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. Essa sobrecarga recebe uma notificação, por meio de um retorno de chamada, da identidade do manipulador de eventos da operação. A operação não é concluída até que uma mensagem se torna disponível na fila ou que ocorra o tempo limite. |
| ClearConnectionCache() |
Limpa o cache de conexão. |
| Close() |
Libera todos os recursos alocados pelo MessageQueue. |
| Create(String) |
Cria uma fila não transacional do serviço de enfileiramento de mensagens no caminho especificado. |
| Create(String, Boolean) |
Cria uma fila transacional ou não transacional do Enfileiramento de Mensagens no caminho especificado. |
| CreateCursor() |
Cria um novo Cursor para a fila de mensagens atual. |
| 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. (Herdado de MarshalByRefObject) |
| Delete(String) |
Exclui uma fila em um servidor de Enfileiramento de Mensagens. |
| Dispose() |
Libera todos os recursos usados pelo Component. (Herdado de Component) |
| Dispose(Boolean) |
Descarta os recursos (exceto a memória) usados pelo MessageQueue. |
| EndPeek(IAsyncResult) |
Conclui a operação de espiada assíncrona especificada. |
| EndReceive(IAsyncResult) |
Conclui a operação de recebimento assíncrono especificada. |
| Equals(Object) |
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object) |
| Exists(String) |
Determina se existe uma fila de Enfileiramento de Mensagens no caminho especificado. |
| GetAllMessages() |
Retorna todas as mensagens na fila. |
| GetEnumerator() |
Obsoleto.
Enumera as mensagens em uma fila. O GetEnumerator() foi preterido. Em vez disso, GetMessageEnumerator2() deve ser usado. |
| GetHashCode() |
Serve como a função de hash padrão. (Herdado de Object) |
| GetLifetimeService() |
Obsoleto.
Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject) |
| GetMachineId(String) |
Obtém o identificador do computador no qual a fila referenciada por este MessageQueue está localizada. |
| GetMessageEnumerator() |
Obsoleto.
Cria um objeto enumerador para todas as mensagens na fila. O GetMessageEnumerator() foi preterido. Em vez disso, GetMessageEnumerator2() deve ser usado. |
| GetMessageEnumerator2() |
Cria um objeto enumerador para todas as mensagens na fila. |
| GetMessageQueueEnumerator() |
Fornece a semântica de cursor somente de avanço para enumerar todas as filas públicas na rede. |
| 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. |
| GetPrivateQueuesByMachine(String) |
Recupera todas as filas privativas no computador especificado. |
| GetPublicQueues() |
Recupera todas as filas públicas na rede. |
| GetPublicQueues(MessageQueueCriteria) |
Recupera todas as filas públicas na rede que atendem aos critérios especificados. |
| GetPublicQueuesByCategory(Guid) |
Recupera todas as filas públicas na rede que pertencem à categoria especificada. |
| GetPublicQueuesByLabel(String) |
Recupera todas as filas públicas na rede que contêm o rótulo especificado. |
| GetPublicQueuesByMachine(String) |
Recupera todas as filas públicas que residem no computador especificado. |
| GetSecurityContext() |
Recupera o contexto de segurança que o MSMQ associa ao usuário atual (identidade de thread) no momento desta chamada. |
| GetService(Type) |
Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container. (Herdado de Component) |
| GetType() |
Obtém o Type da instância atual. (Herdado de Object) |
| InitializeLifetimeService() |
Obsoleto.
Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject) |
| MemberwiseClone() |
Cria uma cópia superficial do Object atual. (Herdado de Object) |
| MemberwiseClone(Boolean) |
Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject) |
| Peek() |
Retorna sem remover (espia) a primeira mensagem na fila referenciada por este MessageQueue. O método Peek() é síncrono. Portanto, ele bloqueia o thread atual até que uma mensagem se torne disponível. |
| Peek(TimeSpan) |
Retorna sem remover (espia) a primeira mensagem na fila referenciada por este 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. |
| Peek(TimeSpan, Cursor, PeekAction) |
Retorna sem remover (espia) a mensagem atual ou a próxima na fila usando o cursor especificado. 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. |
| 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. |
| 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. |
| PeekById(String) |
Espia a mensagem cujo identificador de mensagem corresponde ao parâmetro |
| PeekById(String, TimeSpan) |
Espia a mensagem cujo identificador de mensagem corresponde ao parâmetro |
| PeekByLookupId(Int64) |
Introduzido no MSMQ 3.0. Espiada na mensagem que corresponde ao identificador de pesquisa especificado de uma fila não transacional. |
| PeekByLookupId(MessageLookupAction, Int64) |
Introduzido no MSMQ 3.0. Espia uma mensagem específica da fila. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila. |
| Purge() |
Exclui todas as mensagens contidas na fila. |
| Receive() |
Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível. |
| Receive(MessageQueueTransaction) |
Recebe a primeira mensagem disponível na fila transacional referenciada pelo MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível. |
| Receive(MessageQueueTransactionType) |
Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Essa chamada é síncrona e bloqueia o thread atual de execução até que uma mensagem esteja disponível. |
| 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. |
| Receive(TimeSpan, Cursor) |
Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar. |
| Receive(TimeSpan, Cursor, MessageQueueTransaction) |
Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar. |
| Receive(TimeSpan, Cursor, MessageQueueTransactionType) |
Recebe a mensagem atual na fila usando um cursor especificado. Se nenhuma mensagem estiver disponível, esse método aguardará até uma mensagem ficar disponível ou o tempo limite expirar. |
| 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. |
| Receive(TimeSpan, MessageQueueTransactionType) |
Recebe a primeira mensagem disponível na fila referenciada pela MessageQueue. Esta chamada é síncrona e aguarda até que uma mensagem esteja disponível na fila ou que o tempo limite expire. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| ReceiveByLookupId(Int64) |
Introduzido no MSMQ 3.0. Recebe a mensagem que corresponde ao identificador de pesquisa especificado de uma fila não transacional. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) |
Introduzido no MSMQ 3.0. Recebe uma mensagem específica de uma fila transacional. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) |
Introduzido no MSMQ 3.0. Recebe uma mensagem específica da fila, usando o contexto de transação especificado. A mensagem pode ser especificada por um identificador de pesquisa ou pela sua posição no início ou no final da fila. |
| Refresh() |
Atualiza as propriedades apresentadas pelo MessageQueue para refletir o estado atual do recurso. |
| ResetPermissions() |
Redefine a lista de permissões para os valores padrão do sistema operacional. Remove quaisquer permissões de fila que você tenha anexado à lista padrão. |
| Send(Object) |
Envia um objeto a uma fila não transacional referenciada por essa MessageQueue. |
| Send(Object, MessageQueueTransaction) |
Envia um objeto para a fila transacional referenciada por este MessageQueue. |
| Send(Object, MessageQueueTransactionType) |
Envia um objeto para a fila referenciada por esse MessageQueue. |
| Send(Object, String) |
Envia um objeto para a fila não transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem. |
| Send(Object, String, MessageQueueTransaction) |
Envia um objeto para a fila transacional referenciada por este MessageQueue e especifica um rótulo para a mensagem. |
| Send(Object, String, MessageQueueTransactionType) |
Envia um objeto para a fila referenciada por esse MessageQueue e especifica um rótulo para a mensagem. |
| SetPermissions(AccessControlList) |
Atribui direitos de acesso à fila com base no conteúdo de uma lista de controle de acesso. |
| SetPermissions(MessageQueueAccessControlEntry) |
Atribui direitos de acesso para a fila com base no conteúdo de uma entrada de controle de acesso. |
| SetPermissions(String, MessageQueueAccessRights) |
Fornece os direitos de acesso especificados a um computador, grupo ou usuário. |
| 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). |
| ToString() |
Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído. (Herdado de Component) |
Eventos
| Disposed |
Ocorre quando o componente é disposto por uma chamada ao método Dispose(). (Herdado de Component) |
| PeekCompleted |
Ocorre quando uma mensagem é lida sem ser removida da fila. Este é o resultado da operação assíncrona, BeginPeek(). |
| ReceiveCompleted |
Ocorre quando uma mensagem foi removida da fila. Esse evento é gerado pela operação assíncrona, BeginReceive(). |
Métodos de Extensão
| Cast<TResult>(IEnumerable) |
Converte os elementos de um IEnumerable para o tipo especificado. |
| OfType<TResult>(IEnumerable) |
Filtra os elementos de um IEnumerable com base em um tipo especificado. |
| AsParallel(IEnumerable) |
Habilita a paralelização de uma consulta. |
| AsQueryable(IEnumerable) |
Converte um IEnumerable em um IQueryable. |
Aplica-se a
Acesso thread-safe
Somente o GetAllMessages() método é thread-safe.
