MessageQueue Clase

Definición

Espacio de nombres:: System.Messaging

Ensamblado:: System.Messaging.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Proporciona acceso a una cola en un servidor Message Queuing.

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

Herencia: Object

MarshalByRefObject

Component
MessageQueue

Atributos: TypeConverterAttribute MessagingDescriptionAttribute

Implementaciones: IEnumerable

Ejemplos

En el ejemplo de código siguiente se crean nuevos MessageQueue objetos mediante varios tipos de sintaxis de nombre de ruta de acceso. En cada caso, envía un mensaje a la cola cuya ruta de acceso se define en el 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.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

En el ejemplo de código siguiente se envía un mensaje a una cola y se recibe un mensaje de una cola mediante una clase específica de la aplicación denominada 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

Comentarios

La tecnología Message Queuing permite a las aplicaciones que se ejecutan en diferentes momentos comunicarse entre redes y sistemas heterogéneos que podrían estar temporalmente sin conexión. Las aplicaciones envían, reciben o parecen (leer sin quitar) mensajes de las colas. Message Queuing es un componente opcional de Windows 2000 y Windows NT, y debe instalarse por separado.

La MessageQueue clase es un contenedor alrededor de Message Queuing. Hay varias versiones de Message Queuing y el uso de la MessageQueue clase puede dar lugar a un comportamiento ligeramente diferente, en función del sistema operativo que use.

La MessageQueue clase proporciona una referencia a una cola de Message Queuing. Puede especificar una ruta de acceso en el MessageQueue constructor para conectarse a un recurso existente o puede crear una nueva cola en el servidor. Para poder llamar a Send(Object), Peeko Receive, debe asociar la nueva instancia de la MessageQueue clase a una cola existente. En ese momento, puede manipular las propiedades de cola como Category y Label.

MessageQueue admite dos tipos de recuperación de mensajes: sincrónico y asincrónico. Los métodos sincrónicos Peek y Receive, hacen que el subproceso de proceso espere un intervalo de tiempo especificado para que un mensaje nuevo llegue a la cola. Los métodos asincrónicos BeginPeek y BeginReceive, permiten que las tareas principales de la aplicación continúen en un subproceso independiente hasta que llegue un mensaje a la cola. Estos métodos funcionan mediante objetos de devolución de llamada y objetos de estado para comunicar información entre subprocesos.

Al crear una nueva instancia de la MessageQueue clase , no va a crear una nueva cola de Message Queuing. En su lugar, puede usar los Create(String)métodos , Delete(String)y Purge para administrar colas en el servidor.

A diferencia Purgede , Create(String) y Delete(String) son static miembros, por lo que puede llamarlos sin crear una nueva instancia de la MessageQueue clase .

Puede establecer la MessageQueue propiedad del Path objeto con uno de los tres nombres: el nombre descriptivo, , FormatNameo Label. El nombre descriptivo, definido por las propiedades y de MachineName la cola, esQueueName\MachineName para una cola pública y MachineName QueueName\\Private$para una cola privada.QueueName La FormatName propiedad permite el acceso sin conexión a las colas de mensajes. Por último, puede usar la propiedad de Label la cola para establecer el valor de Pathla cola.

Para obtener una lista de valores de propiedad iniciales para una instancia de MessageQueue, vea el MessageQueue constructor .

Constructores

Nombre	Description
MessageQueue()	Inicializa una nueva instancia de la clase MessageQueue. Una vez que el constructor sin parámetros inicializa la nueva instancia, debe establecer la propiedad de Path la instancia para poder usar la instancia.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicializa una nueva instancia de la clase MessageQueue.
MessageQueue(String, Boolean, Boolean)	Inicializa una nueva instancia de la clase MessageQueue.
MessageQueue(String, Boolean)	Inicializa una nueva instancia de la MessageQueue clase que hace referencia a la cola Message Queuing en la ruta de acceso especificada y con la restricción de acceso de lectura especificada.
MessageQueue(String, QueueAccessMode)	Inicializa una nueva instancia de la clase MessageQueue.
MessageQueue(String)	Inicializa una nueva instancia de la MessageQueue clase que hace referencia a la cola Message Queuing en la ruta de acceso especificada.

Campos

Nombre	Description
InfiniteQueueSize	Especifica que no existe ninguna restricción de tamaño para una cola.
InfiniteTimeout	Especifica que no existe ningún tiempo de espera para los métodos que inspeccionan o reciben mensajes.

Propiedades

Nombre	Description
AccessMode	Obtiene un valor que indica el modo de acceso de la cola.
Authenticate	Obtiene o establece un valor que indica si la cola solo acepta mensajes autenticados.
BasePriority	Obtiene o establece la prioridad base que Message Queuing usa para enrutar los mensajes de una cola pública a través de la red.
CanRaiseEvents	Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component)
CanRead	Obtiene un valor que indica si MessageQueue se puede leer .
CanWrite	Obtiene un valor que indica si se puede escribir en MessageQueue .
Category	Obtiene o establece la categoría de cola.
Container	Obtiene el IContainer objeto que contiene el Componentobjeto . (Heredado de Component)
CreateTime	Obtiene la hora y la fecha en que se creó la cola en Message Queuing.
DefaultPropertiesToSend	Obtiene o establece los valores de propiedad del mensaje que se van a usar de forma predeterminada cuando la aplicación envía mensajes a la cola.
DenySharedReceive	Obtiene o establece un valor que indica si tiene MessageQueue acceso exclusivo para recibir mensajes de la cola Message Queuing.
DesignMode	Obtiene un valor que indica si Component el objeto está actualmente en modo de diseño. (Heredado de Component)
EnableConnectionCache	Obtiene o establece un valor que indica si la aplicación mantendrá una memoria caché de conexiones.
EncryptionRequired	Obtiene o establece un valor que indica si la cola solo acepta mensajes no privados (no cifrados).
Events	Obtiene la lista de controladores de eventos que están asociados a este Componentobjeto . (Heredado de Component)
FormatName	Obtiene el nombre de cola único que Message Queuing generó en el momento de la creación de la cola.
Formatter	Obtiene o establece el formateador usado para serializar un objeto en o deserializar un objeto del cuerpo de un mensaje leído o escrito en la cola.
Id	Obtiene el identificador único de Message Queuing de la cola.
Label	Obtiene o establece la descripción de la cola.
LastModifyTime	Obtiene la última vez que se modificaron las propiedades de una cola.
MachineName	Obtiene o establece el nombre del equipo donde se encuentra la cola message Queuing.
MaximumJournalSize	Obtiene o establece el tamaño máximo de la cola de diario.
MaximumQueueSize	Obtiene o establece el tamaño máximo de la cola.
MessageReadPropertyFilter	Obtiene o establece el filtro de propiedad para recibir o examinar mensajes.
MulticastAddress	Obtiene o establece la dirección de multidifusión asociada a la cola.
Path	Obtiene o establece la ruta de acceso de la cola. Establecer hace Path que apunte MessageQueue a una nueva cola.
QueueName	Obtiene o establece el nombre descriptivo que identifica la cola.
ReadHandle	Obtiene el identificador nativo que se usa para leer mensajes de la cola de mensajes.
Site	Obtiene o establece el ISite objeto de .Component (Heredado de Component)
SynchronizingObject	Obtiene o establece el objeto que serializa la llamada del controlador de eventos resultante de un ReceiveCompleted evento o PeekCompleted .
Transactional	Obtiene un valor que indica si la cola solo acepta transacciones.
UseJournalQueue	Obtiene o establece un valor que indica si los mensajes recibidos se copian en la cola del diario.
WriteHandle	Obtiene el identificador nativo que se usa para enviar mensajes a la cola de mensajes.

Métodos

Nombre	Description
BeginPeek()	Inicia una operación de inspección asincrónica que no tiene tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y que usa un cursor especificado, una acción de inspección especificada y un objeto de estado especificado. El objeto de estado proporciona información asociada durante toda la vigencia de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek(TimeSpan, Object, AsyncCallback)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek(TimeSpan, Object)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginPeek(TimeSpan)	Inicia una operación de inspección asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginReceive()	Inicia una operación de recepción asincrónica que no tiene tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado y usa un cursor especificado y un objeto de estado especificado. El objeto de estado proporciona información asociada durante toda la vigencia de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginReceive(TimeSpan, Object, AsyncCallback)	Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. Esta sobrecarga recibe una notificación, a través de una devolución de llamada, de la identidad del controlador de eventos para la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginReceive(TimeSpan, Object)	Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado y un objeto de estado especificado, que proporciona información asociada durante toda la duración de la operación. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
BeginReceive(TimeSpan)	Inicia una operación de recepción asincrónica que tiene un tiempo de espera especificado. La operación no se completa hasta que un mensaje esté disponible en la cola o se produzca el tiempo de espera.
ClearConnectionCache()	Borra la memoria caché de conexión.
Close()	Libera todos los recursos asignados por .MessageQueue
Create(String, Boolean)	Crea una cola de Message Queuing transaccional o no transaccional en la ruta de acceso especificada.
Create(String)	Crea una cola de Message Queuing no transaccional en la ruta de acceso especificada.
CreateCursor()	Crea un nuevo Cursor para la cola de mensajes actual.
CreateObjRef(Type)	Crea un objeto que contiene toda la información pertinente necesaria para generar un proxy usado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Delete(String)	Elimina una cola en un servidor message Queuing.
Dispose()	Libera todos los recursos usados por .Component (Heredado de Component)
Dispose(Boolean)	Elimina los recursos (excepto la memoria) usados por .MessageQueue
EndPeek(IAsyncResult)	Completa la operación de inspección asincrónica especificada.
EndReceive(IAsyncResult)	Completa la operación de recepción asincrónica especificada.
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
Exists(String)	Determina si existe una cola de Message Queuing en la ruta de acceso especificada.
GetAllMessages()	Devuelve todos los mensajes que están en la cola.
GetEnumerator()	Obsoletos. Enumera los mensajes de una cola. GetEnumerator() está en desuso. Se debe usar GetMessageEnumerator2() en su lugar.
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetMachineId(String)	Obtiene el identificador del equipo en el que se encuentra la cola a la que hace referencia este MessageQueue .
GetMessageEnumerator()	Obsoletos. Crea un objeto enumerador para todos los mensajes de la cola. GetMessageEnumerator() está en desuso. Se debe usar GetMessageEnumerator2() en su lugar.
GetMessageEnumerator2()	Crea un objeto enumerador para todos los mensajes de la cola.
GetMessageQueueEnumerator()	Proporciona semántica de cursor de solo avance para enumerar todas las colas públicas de la red.
GetMessageQueueEnumerator(MessageQueueCriteria)	Proporciona semántica de cursor de solo avance para enumerar todas las colas públicas de la red que cumplen los criterios especificados.
GetPrivateQueuesByMachine(String)	Recupera todas las colas privadas del equipo especificado.
GetPublicQueues()	Recupera todas las colas públicas de la red.
GetPublicQueues(MessageQueueCriteria)	Recupera todas las colas públicas de la red que cumplen los criterios especificados.
GetPublicQueuesByCategory(Guid)	Recupera todas las colas públicas de la red que pertenecen a la categoría especificada.
GetPublicQueuesByLabel(String)	Recupera todas las colas públicas de la red que llevan la etiqueta especificada.
GetPublicQueuesByMachine(String)	Recupera todas las colas públicas que residen en el equipo especificado.
GetSecurityContext()	Recupera el contexto de seguridad que MSMQ asocia al usuario actual (identidad de subproceso) en el momento de esta llamada.
GetService(Type)	Devuelve un objeto que representa un servicio proporcionado por Component o por su Container. (Heredado de Component)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto actual MarshalByRefObject . (Heredado de MarshalByRefObject)
Peek()	Devuelve sin quitar (ver) el primer mensaje de la cola a la que hace referencia este MessageQueue. El Peek() método es sincrónico, por lo que bloquea el subproceso actual hasta que un mensaje esté disponible.
Peek(TimeSpan, Cursor, PeekAction)	Devuelve sin quitar (ver) el mensaje actual o siguiente de la cola mediante el cursor especificado. El Peek() método es sincrónico, por lo que bloquea el subproceso actual hasta que un mensaje esté disponible o se produzca el tiempo de espera especificado.
Peek(TimeSpan)	Devuelve sin quitar (ver) el primer mensaje de la cola a la que hace referencia este MessageQueue. El Peek() método es sincrónico, por lo que bloquea el subproceso actual hasta que un mensaje esté disponible o se produzca el tiempo de espera especificado.
PeekByCorrelationId(String, TimeSpan)	Consulta el mensaje que coincide con el identificador de correlación especificado y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o expire el tiempo de espera.
PeekByCorrelationId(String)	Consulta el mensaje que coincide con el identificador de correlación especificado y genera inmediatamente una excepción si no existe ningún mensaje con el identificador de correlación especificado actualmente en la cola.
PeekById(String, TimeSpan)	Consulta el mensaje cuyo identificador de mensaje coincide con el `id` parámetro . Espera hasta que aparezca el mensaje en la cola o se agote el tiempo de espera.
PeekById(String)	Consulta el mensaje cuyo identificador de mensaje coincide con el `id` parámetro .
PeekByLookupId(Int64)	Se introdujo en MSMQ 3.0. Examina el mensaje que coincide con el identificador de búsqueda especificado de una cola no transaccional.
PeekByLookupId(MessageLookupAction, Int64)	Se introdujo en MSMQ 3.0. Examina un mensaje específico de la cola. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición en el front o end de la cola.
Purge()	Elimina todos los mensajes contenidos en la cola.
Receive()	Recibe el primer mensaje disponible en la cola a la que hace referencia .MessageQueue Esta llamada es sincrónica y bloquea el subproceso actual de ejecución hasta que haya un mensaje disponible.
Receive(MessageQueueTransaction)	Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia .MessageQueue Esta llamada es sincrónica y bloquea el subproceso actual de ejecución hasta que haya un mensaje disponible.
Receive(MessageQueueTransactionType)	Recibe el primer mensaje disponible en la cola a la que hace referencia .MessageQueue Esta llamada es sincrónica y bloquea el subproceso actual de ejecución hasta que haya un mensaje disponible.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Recibe el mensaje actual de la cola mediante un cursor especificado. Si no hay ningún mensaje disponible, este método espera hasta que haya un mensaje disponible o expire el tiempo de espera.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Recibe el mensaje actual de la cola mediante un cursor especificado. Si no hay ningún mensaje disponible, este método espera hasta que haya un mensaje disponible o expire el tiempo de espera.
Receive(TimeSpan, Cursor)	Recibe el mensaje actual de la cola mediante un cursor especificado. Si no hay ningún mensaje disponible, este método espera hasta que haya un mensaje disponible o expire el tiempo de espera.
Receive(TimeSpan, MessageQueueTransaction)	Recibe el primer mensaje disponible en la cola transaccional a la MessageQueue que hace referencia y espera hasta que un mensaje esté disponible en la cola o expire el tiempo de espera.
Receive(TimeSpan, MessageQueueTransactionType)	Recibe el primer mensaje disponible en la cola a la que hace referencia .MessageQueue Esta llamada es sincrónica y espera hasta que un mensaje esté disponible en la cola o expire el tiempo de espera.
Receive(TimeSpan)	Recibe el primer mensaje disponible en la cola a la MessageQueue que hace referencia y espera hasta que un mensaje esté disponible en la cola o expire el tiempo de espera.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Recibe el mensaje que coincide con el identificador de correlación especificado (de una cola transaccional) y genera inmediatamente una excepción si no existe ningún mensaje con el identificador de correlación especificado actualmente en la cola.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Recibe el mensaje que coincide con el identificador de correlación especificado y genera inmediatamente una excepción si no existe ningún mensaje con el identificador de correlación especificado actualmente en la cola.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Recibe el mensaje que coincide con el identificador de correlación especificado (de una cola transaccional) y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Recibe el mensaje que coincide con el identificador de correlación especificado y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveByCorrelationId(String, TimeSpan)	Recibe el mensaje que coincide con el identificador de correlación especificado (de una cola no transaccional) y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveByCorrelationId(String)	Recibe el mensaje que coincide con el identificador de correlación especificado (de una cola no transaccional) y genera inmediatamente una excepción si no existe ningún mensaje con el identificador de correlación especificado actualmente en la cola.
ReceiveById(String, MessageQueueTransaction)	Recibe el mensaje que coincide con el identificador especificado (de una cola transaccional) y genera inmediatamente una excepción si no existe ningún mensaje con el identificador especificado actualmente en la cola.
ReceiveById(String, MessageQueueTransactionType)	Recibe el mensaje que coincide con el identificador especificado y genera inmediatamente una excepción si no existe ningún mensaje con el identificador especificado actualmente en la cola.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Recibe el mensaje que coincide con el identificador especificado (de una cola transaccional) y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Recibe el mensaje que coincide con el identificador especificado y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveById(String, TimeSpan)	Recibe el mensaje que coincide con el identificador especificado (de una cola no transaccional) y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o expire el tiempo de espera.
ReceiveById(String)	Recibe el mensaje que coincide con el identificador especificado de una cola no transaccional y genera inmediatamente una excepción si no existe ningún mensaje con el identificador especificado actualmente en la cola.
ReceiveByLookupId(Int64)	Se introdujo en MSMQ 3.0. Recibe el mensaje que coincide con el identificador de búsqueda especificado de una cola no transaccional.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	Se introdujo en MSMQ 3.0. Recibe un mensaje específico de una cola transaccional. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición en el front o end de la cola.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	Se introdujo en MSMQ 3.0. Recibe un mensaje específico de la cola mediante el contexto de transacción especificado. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición en el front o end de la cola.
Refresh()	Actualiza las propiedades presentadas por MessageQueue para reflejar el estado actual del recurso.
ResetPermissions()	Restablece la lista de permisos a los valores predeterminados del sistema operativo. Quita los permisos de cola que haya anexado a la lista predeterminada.
Send(Object, MessageQueueTransaction)	Envía un objeto a la cola transaccional a la que hace referencia este MessageQueue.
Send(Object, MessageQueueTransactionType)	Envía un objeto a la cola a la que hace referencia este MessageQueueobjeto .
Send(Object, String, MessageQueueTransaction)	Envía un objeto a la cola transaccional a la que hace referencia y MessageQueue especifica una etiqueta para el mensaje.
Send(Object, String, MessageQueueTransactionType)	Envía un objeto a la cola a la que hace referencia y MessageQueue especifica una etiqueta para el mensaje.
Send(Object, String)	Envía un objeto a la cola no transaccional a la que hace MessageQueue referencia y especifica una etiqueta para el mensaje.
Send(Object)	Envía un objeto a una cola no transaccional a la que hace referencia este MessageQueue.
SetPermissions(AccessControlList)	Asigna derechos de acceso a la cola en función del contenido de una lista de control de acceso.
SetPermissions(MessageQueueAccessControlEntry)	Asigna derechos de acceso a la cola en función del contenido de una entrada de control de acceso.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Proporciona a un equipo, grupo o usuario los derechos de acceso especificados, con el tipo de control de acceso especificado (permitir, denegar, revocar o establecer).
SetPermissions(String, MessageQueueAccessRights)	Proporciona a un equipo, grupo o usuario los derechos de acceso especificados.
ToString()	Devuelve un String objeto que contiene el nombre de Component, si existe. Este método no se debe invalidar. (Heredado de Component)

Eventos

Nombre	Description
Disposed	Se produce cuando el componente se elimina mediante una llamada al Dispose() método . (Heredado de Component)
PeekCompleted	Se produce cuando se lee un mensaje sin quitarse de la cola. Este es el resultado de la operación asincrónica, BeginPeek().
ReceiveCompleted	Se produce cuando se ha quitado un mensaje de la cola. Esta operación asincrónica genera este evento, BeginReceive().

Métodos de extensión

Nombre	Description
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte un IEnumerable en un IQueryable.
Cast<TResult>(IEnumerable)	Convierte los elementos de un IEnumerable al tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de un IEnumerable en función de un tipo especificado.

Se aplica a

Compartir por