Compartilhar via


MessageQueue Classe

Definição

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 IEnumerable
Public 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 id.

PeekById(String, TimeSpan)

Espia a mensagem cujo identificador de mensagem corresponde ao parâmetro id. Aguarda até que a mensagem seja exibida na fila ou um tempo limite ocorra.

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.

Confira também