MessageQueue Clase
Definición
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 de 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 IEnumerablePublic Class MessageQueue
Inherits Component
Implements IEnumerable- Herencia
- Atributos
- Implementaciones
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 la cola, como Category y Label.
MessageQueue admite dos tipos de recuperación de mensajes: sincrónico y asincrónico. Los métodos sincrónicos y Receive, hacen que el subproceso Peek del proceso espere un intervalo de tiempo especificado para que un mensaje nuevo llegue a la cola. Los métodos asincrónicos y BeginPeekBeginReceive, 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 las 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, o FormatNameLabel. El nombre descriptivo, definido por las propiedades y de MachineName la cola, esQueueName\MachineName para una cola pública y MachineNameQueueName\\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 la cola Path.
Para obtener una lista de valores de propiedad iniciales para una instancia de MessageQueue, vea el MessageQueue constructor .
Constructores
| MessageQueue() |
Inicializa una nueva instancia de la clase MessageQueue. Una vez que el constructor sin parámetros inicialice la nueva instancia, hay que establecer la propiedad Path de la instancia para poder utilizarla. |
| MessageQueue(String) |
Inicializa una nueva instancia de la clase MessageQueue que hace referencia a la cola de Message Queuing en la ruta de acceso especificada. |
| MessageQueue(String, Boolean) |
Inicializa una nueva instancia de la clase MessageQueue que hace referencia a la cola de Message Queuing en la ruta de acceso especificada y con la restricción de acceso de lectura especificada. |
| MessageQueue(String, Boolean, Boolean) |
Inicializa una nueva instancia de la clase MessageQueue. |
| MessageQueue(String, Boolean, Boolean, QueueAccessMode) |
Inicializa una nueva instancia de la clase MessageQueue. |
| MessageQueue(String, QueueAccessMode) |
Inicializa una nueva instancia de la clase MessageQueue. |
Campos
| InfiniteQueueSize |
Especifica que no existan limitaciones de tamaño para una cola. |
| InfiniteTimeout |
Especifica que no exista tiempo de espera para los métodos que busquen o reciban mensajes. |
Propiedades
| AccessMode |
Obtiene un valor que indica el modo de acceso para la cola. |
| Authenticate |
Obtiene o establece un valor que indica si la cola acepta únicamente mensajes autenticados. |
| BasePriority |
Obtiene o establece la prioridad básica que Message Queuing utiliza 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 el objeto MessageQueue admite operaciones de lectura. |
| CanWrite |
Obtiene un valor que indica si el objeto MessageQueue admite operaciones de escritura. |
| Category |
Obtiene o establece la categoría de la cola. |
| Container |
Obtiene la interfaz IContainer que contiene la clase Component. (Heredado de Component) |
| CreateTime |
Obtiene la fecha y la hora en que se creó la cola en Message Queuing. |
| DefaultPropertiesToSend |
Obtiene o establece los valores de propiedad de mensaje que se utilizarán de forma predeterminada cuando la aplicación envíe mensajes a la cola. |
| DenySharedReceive |
Obtiene o establece un valor que indica si esta MessageQueue tiene acceso exclusivo para recibir mensajes de la cola de Message Queuing. |
| DesignMode |
Obtiene un valor que indica si Component está actualmente en modo de diseño. (Heredado de Component) |
| EnableConnectionCache |
Obtiene o establece un valor que indica si la aplicación va a mantener una caché de conexiones. |
| EncryptionRequired |
Obtiene o establece un valor que indica si la cola acepta únicamente mensajes no privados (no cifrados). |
| Events |
Obtiene la lista de controladores de eventos asociados a Component. (Heredado de Component) |
| FormatName |
Obtiene el nombre de cola único generado por Message Queuing al crear la cola. |
| Formatter |
Obtiene o establece el formateador empleado para serializar o deserializar un objeto en el cuerpo de un mensaje que se ha 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 hora en que se modificaron por última vez las propiedades de una cola. |
| MachineName |
Obtiene o establece el nombre del equipo en el que se encuentra la cola de Message Queuing. |
| MaximumJournalSize |
Obtiene o establece el tamaño máximo de la cola del diario. |
| MaximumQueueSize |
Obtiene o establece el tamaño máximo de la cola. |
| MessageReadPropertyFilter |
Obtiene o establece el filtro de propiedad para recibir o buscar mensajes. |
| MulticastAddress |
Introducido en MSMQ 3.0. Obtiene o establece la dirección de multidifusión asociada a la cola. |
| Path |
Obtiene o establece la ruta de acceso a la cola. Al establecer la propiedad Path, el objeto MessageQueue indica una nueva cola. |
| QueueName |
Obtiene o establece el nombre descriptivo que identifica la cola. |
| ReadHandle |
Obtiene el identificador nativo utilizado para leer mensajes de la cola de mensajes. |
| Site |
Obtiene o establece ISite de Component. (Heredado de Component) |
| SynchronizingObject |
Obtiene o establece el objeto que calcula las referencias a la llamada al controlador de eventos generada a partir de un evento ReceiveCompleted o PeekCompleted. |
| Transactional |
Obtiene un valor que indica si la cola acepta solo 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 utilizado para enviar mensajes a la cola de mensajes. |
Métodos
| BeginPeek() |
Inicia una operación de ver el código sin salir asincrónica sin tiempo de espera. La operación no se completa hasta que hay un mensaje disponible en la cola. |
| BeginPeek(TimeSpan) |
Inicia una operación de ver el código sin salir asincrónica con un tiempo de espera especificado. La operación no se completa hasta que haya un mensaje disponible en la cola o hasta que se agote el tiempo de espera. |
| BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) |
Inicia una operación de búsqueda peek asincrónica que tiene especificado un tiempo de espera y utiliza un cursor, una acción de búsqueda peek y un objeto de estado especificados. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| BeginPeek(TimeSpan, Object) |
Inicia una operación de búsqueda peek asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| BeginPeek(TimeSpan, Object, AsyncCallback) |
Inicia una operación de búsqueda peek asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| BeginReceive() |
Inicia una operación de recepción asincrónica sin tiempo de espera. La operación no se completa hasta que haya un mensaje disponible en la cola. |
| 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 haya un mensaje disponible en la cola o hasta que se agote el tiempo de espera. |
| BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) |
Inicia una operación de recepción asincrónica que tiene especificado un tiempo de espera y utiliza un cursor y un objeto de estado especificados. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| BeginReceive(TimeSpan, Object) |
Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| BeginReceive(TimeSpan, Object, AsyncCallback) |
Inicia una operación de recepción asincrónica con un tiempo de espera y un objeto de estado específicos, lo que proporciona información relacionada durante toda la operación. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera. |
| ClearConnectionCache() |
Vacía la memoria caché de conexiones. |
| Close() |
Libera todos los recursos asignados por MessageQueue. |
| Create(String) |
Crea una cola no transaccional de Message Queuing en la ruta de acceso especificada. |
| Create(String, Boolean) |
Crea una cola transaccional o no transaccional de Message Queuing en la ruta de acceso especificada. |
| CreateCursor() |
Crea un objeto Cursor nuevo para la cola de mensajes actual. |
| CreateObjRef(Type) |
Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject) |
| Delete(String) |
Elimina una cola en un servidor de Message Queuing. |
| Dispose() |
Libera todos los recursos que usa Component. (Heredado de Component) |
| Dispose(Boolean) |
Se deshace de los recursos (distintos de la memoria) que usa MessageQueue. |
| EndPeek(IAsyncResult) |
Completa la operación de búsqueda peek asincrónica especificada. |
| EndReceive(IAsyncResult) |
Completa la operación de recepción asincrónica especificada. |
| Equals(Object) |
Determina si el objeto especificado es igual que el 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 se encuentran en la cola. |
| GetEnumerator() |
Obsoletos.
Enumera los mensajes en una cola. GetEnumerator() está desusada. Se debe usar GetMessageEnumerator2() en su lugar. |
| GetHashCode() |
Sirve como la 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 MessageQueue. |
| GetMessageEnumerator() |
Obsoletos.
Crea un objeto enumerador para todos los mensajes de la cola. GetMessageEnumerator() está desusada. Se debe usar GetMessageEnumerator2() en su lugar. |
| GetMessageEnumerator2() |
Crea un objeto enumerador para todos los mensajes de la cola. |
| GetMessageQueueEnumerator() |
Proporciona el funcionamiento de un cursor de solo avance para enumerar todas las colas públicas de la red. |
| GetMessageQueueEnumerator(MessageQueueCriteria) |
Proporciona el funcionamiento de un cursor de solo avance para enumerar todas las colas públicas de la red que cumplan 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 cumplan los criterios especificados. |
| GetPublicQueuesByCategory(Guid) |
Recupera todas las colas públicas de la red que pertenezcan a la categoría especificada. |
| GetPublicQueuesByLabel(String) |
Recupera todas las colas públicas de la red que tengan 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 el servicio suministrado por Component o por 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 Object actual. (Heredado de Object) |
| MemberwiseClone(Boolean) |
Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject) |
| Peek() |
Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible. |
| Peek(TimeSpan) |
Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado. |
| Peek(TimeSpan, Cursor, PeekAction) |
Vuelve sin quitar (búsquedas peek) el mensaje actual o próximo de la cola, utilizando el cursor especificado. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible o hasta que finalice el tiempo de espera especificado. |
| PeekByCorrelationId(String) |
Busca el mensaje que coincida con el identificador de correlación dado e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador de correlación especificado. |
| PeekByCorrelationId(String, TimeSpan) |
Lee el mensaje que coincida con el identificador de correlación dado y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| PeekById(String) |
Busca el mensaje cuyo identificador de mensaje coincida con el parámetro |
| PeekById(String, TimeSpan) |
Busca el mensaje cuyo identificador de mensaje coincida con el parámetro |
| PeekByLookupId(Int64) |
Introducido en MSMQ 3.0. Ejecuta el método Peek en el mensaje que coincide con el identificador de búsqueda determinado de una cola no transaccional. |
| PeekByLookupId(MessageLookupAction, Int64) |
Introducido en MSMQ 3.0. Ejecuta el método Peek en un mensaje concreto de la cola. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final 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 de ejecución actual hasta que se encuentre disponible un mensaje. |
| 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 de ejecución actual hasta que se encuentre disponible un mensaje. |
| 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 de ejecución actual hasta que se encuentre disponible un mensaje. |
| Receive(TimeSpan) |
Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera. |
| Receive(TimeSpan, Cursor) |
Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera. |
| Receive(TimeSpan, Cursor, MessageQueueTransaction) |
Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera. |
| Receive(TimeSpan, Cursor, MessageQueueTransactionType) |
Recibe el mensaje actual en la cola, utilizando un cursor especificado. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera. |
| Receive(TimeSpan, MessageQueueTransaction) |
Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue y espera hasta que haya un mensaje en la cola o hasta que expire el tiempo de espera. |
| Receive(TimeSpan, MessageQueueTransactionType) |
Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue. La llamada es sincrónica y espera hasta que haya un mensaje disponible en la cola o hasta que expira el tiempo de espera. |
| ReceiveByCorrelationId(String) |
Recibe el mensaje que coincide con el identificador de correlación dado (desde una cola no transaccional) e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador de correlación especificado. |
| ReceiveByCorrelationId(String, MessageQueueTransaction) |
Recibe el mensaje que coincide con el identificador de correlación dado (desde una cola transaccional) e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador de correlación especificado. |
| ReceiveByCorrelationId(String, MessageQueueTransactionType) |
Recibe el mensaje que coincide con el identificador de correlación dado e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador de correlación especificado. |
| ReceiveByCorrelationId(String, TimeSpan) |
Recibe el mensaje que coincide con el identificador de correlación dado (desde una cola no transaccional) y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) |
Recibe el mensaje que coincide con el identificador de correlación dado (desde una cola transaccional) y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) |
Recibe el mensaje que coincide con el identificador de correlación dado y espera hasta que un mensaje con el identificador de correlación especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveById(String) |
Recibe el mensaje que coincide con el identificador dado desde una cola que no es transaccional e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador especificado. |
| ReceiveById(String, MessageQueueTransaction) |
Recibe el mensaje que coincide con el identificador dado (desde una cola transaccional) e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador especificado. |
| ReceiveById(String, MessageQueueTransactionType) |
Recibe el mensaje que coincide con el identificador dado e inmediatamente inicia una excepción si la cola no contiene ningún mensaje con el identificador especificado. |
| ReceiveById(String, TimeSpan) |
Recibe el mensaje que coincide con el identificador dado (desde una cola no transaccional) y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveById(String, TimeSpan, MessageQueueTransaction) |
Recibe el mensaje que coincide con el identificador dado (desde una cola transaccional) y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveById(String, TimeSpan, MessageQueueTransactionType) |
Recibe el mensaje que coincide con el identificador dado y espera hasta que un mensaje con el identificador especificado esté disponible en la cola o hasta que expire el tiempo de espera. |
| ReceiveByLookupId(Int64) |
Introducido en MSMQ 3.0. Recibe el mensaje que coincide con el identificador de búsqueda dado de una cola no transaccional. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) |
Introducido en MSMQ 3.0. Recibe un mensaje concreto de una cola transaccional. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final de la cola. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) |
Introducido en MSMQ 3.0. Recibe un mensaje concreto de la cola, utilizando el contexto de transacción especificado. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final de la cola. |
| Refresh() |
Actualiza las propiedades que presenta MessageQueue para reflejar el estado actual del recurso. |
| ResetPermissions() |
Restablece la lista de permisos con los valores predeterminados del sistema operativo. Quita los permisos de cola que se hayan agregado a la lista predeterminada. |
| Send(Object) |
Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue. |
| Send(Object, MessageQueueTransaction) |
Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue. |
| Send(Object, MessageQueueTransactionType) |
Envía un objeto a la cola a la que hace referencia esta MessageQueue. |
| Send(Object, String) |
Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje. |
| Send(Object, String, MessageQueueTransaction) |
Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje. |
| Send(Object, String, MessageQueueTransactionType) |
Envía un objeto a la cola a la que hace referencia esta MessageQueue y especifica una etiqueta para el mensaje. |
| SetPermissions(AccessControlList) |
Asigna derechos de acceso a la cola de acuerdo con el contenido de una lista de control de acceso. |
| SetPermissions(MessageQueueAccessControlEntry) |
Asigna derechos de acceso a la cola basándose en el contenido de una entrada de control de acceso. |
| SetPermissions(String, MessageQueueAccessRights) |
Concede a un equipo, a un grupo o a un usuario los derechos de acceso especificados. |
| SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) |
Concede a un equipo, grupo o usuario los derechos de acceso especificados, con el tipo de control de acceso indicado (conceder, negar, revocar o establecer). |
| ToString() |
Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar. (Heredado de Component) |
Eventos
| Disposed |
Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose(). (Heredado de Component) |
| PeekCompleted |
Se produce cuando se lee un mensaje sin haberlo quitado de la cola. Es resultado de la operación asincrónica, BeginPeek(). |
| ReceiveCompleted |
Se produce cuando se quita un mensaje de la cola. La operación asincrónica BeginReceive() provoca este evento. |
Métodos de extensión
| Cast<TResult>(IEnumerable) |
Convierte los elementos de IEnumerable en el tipo especificado. |
| OfType<TResult>(IEnumerable) |
Filtra los elementos de IEnumerable en función de un tipo especificado. |
| AsParallel(IEnumerable) |
Habilita la paralelización de una consulta. |
| AsQueryable(IEnumerable) |
Convierte una interfaz IEnumerable en IQueryable. |
Se aplica a
Seguridad para subprocesos
Solo el método es seguro para subprocesos GetAllMessages() .
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de