MessageQueue MessageQueue MessageQueue MessageQueue Class

Definición

Proporciona acceso a una cola en un servidor de Message Queuing.Provides access to a queue on a Message Queuing server.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable
[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
Herencia
Atributos
Implementaciones

Ejemplos

En el ejemplo de código siguiente MessageQueue se crean nuevos objetos con varios tipos de sintaxis de nombre de ruta de acceso.The following code example creates new MessageQueue objects using various path name syntax types. En cada caso, envía un mensaje a la cola cuya ruta de acceso está definida en el constructor.In each case, it sends a message to the queue whose path is defined in the constructor.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		 
        // This example demonstrates several ways to set
        // a queue's path.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();

            return;
        }
        
        // References public queues.
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        }

        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new 
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new 
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" + 
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new 
                MessageQueue(".\\Journal$");
            while(true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new 
                MessageQueue(".\\myQueue\\Journal$");
            while(true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }
        
        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new 
                MessageQueue(".\\DeadLetter$");
            while(true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new 
                MessageQueue(".\\XactDeadLetter$");
            while(true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.
            }
        }

    }
}
Imports System.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, utilizando una clase específica Orderde la aplicación denominada.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called Order.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}
using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example 
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		 
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }


        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }


        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message. 
                Message myMessage =	myQueue.Receive(); 
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " + 
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " + 
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}
Imports System.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 de Message Queue Server permite que las aplicaciones que se ejecutan en momentos diferentes puedan comunicarse a través de redes y sistemas heterogéneos que podrían estar sin conexión temporalmente.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. Las aplicaciones envían, reciben o inspeccionan (leen sin quitar) mensajes de las colas.Applications send, receive, or peek (read without removing) messages from queues. Message Queue Server es un componente Windows 2000Windows 2000 opcional de y Windows NT, y debe instalarse por separado.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

La MessageQueue clase es un contenedor alrededor de Message Queue Server.The MessageQueue class is a wrapper around Message Queuing. Hay varias versiones de Message Queue Server y el uso MessageQueue de la clase puede dar lugar a un comportamiento ligeramente diferente, dependiendo del sistema operativo que esté usando.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. Para obtener información acerca de las características específicas de cada versión de Message Queue Server, vea el tema acerca de las novedades de Message Queue Server en el SDK de la plataforma en MSDN.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

La MessageQueue clase proporciona una referencia a una cola de Message Queue Server.The MessageQueue class provides a reference to a Message Queuing queue. Puede especificar una ruta de acceso en MessageQueue el constructor para conectarse a un recurso existente, o puede crear una nueva cola en el servidor.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. Antes de poder llamar Send(Object)a Peek, o Receive, debe asociar la nueva instancia de la MessageQueue clase a una cola existente.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. En ese momento, puede manipular las propiedades de la cola, Category como y. LabelAt that point, you can manipulate the queue properties such as Category and Label.

MessageQueueadmite dos tipos de recuperación de mensajes: sincrónicos y asincrónicos.MessageQueue supports two types of message retrieval: synchronous and asynchronous. Los métodos sincrónicos Peek , Receivey, hacen que el subproceso de proceso espere un intervalo de tiempo especificado para que llegue un nuevo mensaje a la cola.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. Los métodos asincrónicos, BeginPeek y BeginReceive, permiten que las tareas de aplicación principales continúen en un subproceso independiente hasta que llegue un mensaje en la cola.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. Estos métodos funcionan mediante el uso de objetos de devolución de llamada y objetos de estado para comunicar información entre subprocesos.These methods work by using callback objects and state objects to communicate information between threads.

Cuando se crea una nueva instancia de la MessageQueue clase, no se crea una nueva cola de Message Queue Server.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. En su lugar, puede usar los Create(String)métodos Delete(String), y Purge para administrar las colas en el servidor.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

A diferencia Purgede Create(String) , Delete(String) y sonstatic miembros, por lo que puede llamarlos sin crear una nueva instancia MessageQueue de la clase.Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

Puede establecer la MessageQueue propiedad del Path objeto con uno de estos tres nombres: el nombre descriptivo, el FormatNameo el Label.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. El nombre descriptivo, que se define por las propiedades y MachineName QueueName de la cola, MachineName es Private$ \ QueueName para una cola pública y MachineName \ \ QueueName para una cola privada.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. La FormatName propiedad permite el acceso sin conexión a las colas de mensajes.The FormatName property allows offline access to message queues. Por último, puede usar la propiedad de Label la cola para establecer la propiedad de Pathla cola.Lastly, you can use the queue's Label property to set the queue's Path.

Para obtener una lista de los valores de propiedad iniciales de MessageQueueuna instancia de MessageQueue , vea el constructor.For a list of initial property values for an instance of MessageQueue, see the MessageQueue constructor.

Constructores

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

Inicializa una nueva instancia de la clase MessageQueue.Initializes a new instance of the MessageQueue class. Una vez que el constructor sin parámetros inicialice la nueva instancia, hay que establecer la propiedad Path de la instancia para poder utilizarla.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

MessageQueue(String) MessageQueue(String) MessageQueue(String) MessageQueue(String)

Inicializa una nueva instancia de la clase MessageQueue que hace referencia a la cola de Message Queuing en la ruta de acceso especificada.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

MessageQueue(String, Boolean) MessageQueue(String, Boolean) MessageQueue(String, Boolean) MessageQueue(String, Boolean)

Inicializa 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.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean) MessageQueue(String, Boolean, Boolean)

Inicializa una nueva instancia de la clase MessageQueue.Initializes a new instance of the MessageQueue class.

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

Inicializa una nueva instancia de la clase MessageQueue.Initializes a new instance of the MessageQueue class.

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

Inicializa una nueva instancia de la clase MessageQueue.Initializes a new instance of the MessageQueue class.

Campos

InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize InfiniteQueueSize

Especifica que no existan limitaciones de tamaño para una cola.Specifies that no size restriction exists for a queue.

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Especifica que no exista tiempo de espera para los métodos que busquen o reciban mensajes.Specifies that no time-out exists for methods that peek or receive messages.

Propiedades

AccessMode AccessMode AccessMode AccessMode

Obtiene un valor que indica el modo de acceso para la cola.Gets a value that indicates the access mode for the queue.

Authenticate Authenticate Authenticate Authenticate

Obtiene o establece un valor que indica si la cola acepta únicamente mensajes autenticados.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority BasePriority BasePriority 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.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtiene un valor que indica si el componente puede generar un evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
CanRead CanRead CanRead CanRead

Obtiene un valor que indica si el objeto MessageQueue admite operaciones de lectura.Gets a value that indicates whether the MessageQueue can be read.

CanWrite CanWrite CanWrite CanWrite

Obtiene un valor que indica si el objeto MessageQueue admite operaciones de escritura.Gets a value that indicates whether the MessageQueue can be written to.

Category Category Category Category

Obtiene o establece la categoría de la cola.Gets or sets the queue category.

Container Container Container Container

Obtiene IContainer que contiene Component.Gets the IContainer that contains the Component.

(Inherited from Component)
CreateTime CreateTime CreateTime CreateTime

Obtiene la fecha y la hora en que se creó la cola en Message Queuing.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend DefaultPropertiesToSend DefaultPropertiesToSend 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.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive DenySharedReceive DenySharedReceive DenySharedReceive

Obtiene o establece un valor que indica si esta MessageQueue tiene acceso exclusivo para recibir mensajes de la cola de Message Queuing.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode DesignMode DesignMode DesignMode

Obtiene un valor que indica si Component está actualmente en modo de diseño.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableConnectionCache EnableConnectionCache EnableConnectionCache EnableConnectionCache

Obtiene o establece un valor que indica si la aplicación va a mantener una caché de conexiones.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired EncryptionRequired EncryptionRequired EncryptionRequired

Obtiene o establece un valor que indica si la cola acepta únicamente mensajes no privados (no cifrados).Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events Events Events Events

Obtiene la lista de controladores de eventos asociados a Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
FormatName FormatName FormatName FormatName

Obtiene el nombre de cola único generado por Message Queuing al crear la cola.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter Formatter Formatter 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.Gets or sets the formatter used to serialize an object into or deserialize an object from the body of a message read from or written to the queue.

Id Id Id Id

Obtiene el identificador único de Message Queuing de la cola.Gets the unique Message Queuing identifier of the queue.

Label Label Label Label

Obtiene o establece la descripción de la cola.Gets or sets the queue description.

LastModifyTime LastModifyTime LastModifyTime LastModifyTime

Obtiene la hora en que se modificaron por última vez las propiedades de una cola.Gets the last time the properties of a queue were modified.

MachineName MachineName MachineName MachineName

Obtiene o establece el nombre del equipo en el que se encuentra la cola de Message Queuing.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize MaximumJournalSize MaximumJournalSize MaximumJournalSize

Obtiene o establece el tamaño máximo de la cola del diario.Gets or sets the maximum size of the journal queue.

MaximumQueueSize MaximumQueueSize MaximumQueueSize MaximumQueueSize

Obtiene o establece el tamaño máximo de la cola.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter MessageReadPropertyFilter

Obtiene o establece el filtro de propiedad para recibir o buscar mensajes.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress MulticastAddress MulticastAddress MulticastAddress

Introducido en MSMQ 3.0.Introduced in MSMQ 3.0. Obtiene o establece la dirección de multidifusión asociada a la cola.Gets or sets the multicast address associated with the queue.

Path Path Path Path

Obtiene o establece la ruta de acceso a la cola.Gets or sets the queue's path. Al establecer la propiedad Path, el objeto MessageQueue indica una nueva cola.Setting the Path causes the MessageQueue to point to a new queue.

QueueName QueueName QueueName QueueName

Obtiene o establece el nombre descriptivo que identifica la cola.Gets or sets the friendly name that identifies the queue.

ReadHandle ReadHandle ReadHandle ReadHandle

Obtiene el identificador nativo utilizado para leer mensajes de la cola de mensajes.Gets the native handle used to read messages from the message queue.

Site Site Site Site

Obtiene o establece el ISite de Component.Gets or sets the ISite of the Component.

(Inherited from Component)
SynchronizingObject SynchronizingObject SynchronizingObject 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.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional Transactional Transactional Transactional

Obtiene un valor que indica si la cola acepta solo transacciones.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

Obtiene o establece un valor que indica si los mensajes recibidos se copian en la cola del diario.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle WriteHandle WriteHandle WriteHandle

Obtiene el identificador nativo utilizado para enviar mensajes a la cola de mensajes.Gets the native handle used to send messages to the message queue.

Métodos

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

Inicia una operación de búsqueda peek asincrónica sin tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan) BeginPeek(TimeSpan)

Inicia una operación de búsqueda peek asincrónica con un tiempo de espera específico. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

Inicia 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.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación.The state object provides associated information throughout the lifetime of the operation. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación.This overload receives notification, through a callback, of the identity of the event handler for the operation. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object) BeginPeek(TimeSpan, Object)

Inicia 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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback) BeginPeek(TimeSpan, Object, AsyncCallback)

Inicia 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.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación.This overload receives notification, through a callback, of the identity of the event handler for the operation. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Inicia una operación de recepción asincrónica sin tiempo de espera. La operación no se completa hasta que un mensaje esté disponible en la cola.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan) BeginReceive(TimeSpan)

Inicia una operación de recepción asincrónica con un tiempo de espera específico. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Inicia 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.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. El objeto de estado proporciona la información asociada a lo largo del período de duración de la operación.The state object provides associated information throughout the lifetime of the operation. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación.This overload receives notification, through a callback, of the identity of the event handler for the operation. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object) BeginReceive(TimeSpan, Object)

Inicia 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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback) BeginReceive(TimeSpan, Object, AsyncCallback)

Inicia 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.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. Esta sobrecarga recibe una notificación, mediante una devolución de llamada, de la identidad del controlador de eventos de la operación.This overload receives notification, through a callback, of the identity of the event handler for the operation. La operación no se completa hasta que haya un mensaje en la cola disponible o finalice el tiempo de espera.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

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

Vacía la memoria caché de conexiones.Clears the connection cache.

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

Libera todos los recursos asignados por MessageQueue.Frees all resources allocated by the MessageQueue.

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

Crea una cola no transaccional de Message Queuing en la ruta de acceso especificada.Creates a non-transactional Message Queuing queue at the specified path.

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

Crea una cola transaccional o no transaccional de Message Queuing en la ruta de acceso especificada.Creates a transactional or non-transactional Message Queuing queue at the specified path.

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

Crea un objeto Cursor nuevo para la cola de mensajes actual.Creates a new Cursor for the current message queue.

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

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Delete(String) Delete(String) Delete(String) Delete(String)

Elimina una cola en un servidor de Message Queuing.Deletes a queue on a Message Queuing server.

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

Libera todos los recursos que usa Component.Releases all resources used by the Component.

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

Se deshace de los recursos (distintos de la memoria) que usa MessageQueue.Disposes of the resources (other than memory) used by the MessageQueue.

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

Completa la operación de búsqueda peek asincrónica especificada.Completes the specified asynchronous peek operation.

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

Completa la operación de recepción asincrónica especificada.Completes the specified asynchronous receive operation.

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

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

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

Determina si existe una cola de Message Queuing en la ruta de acceso especificada.Determines whether a Message Queuing queue exists at the specified path.

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

Devuelve todos los mensajes que se encuentran en la cola.Returns all the messages that are in the queue.

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

Enumera los mensajes en una cola.Enumerates the messages in a queue. GetEnumerator() está desusada.GetEnumerator() is deprecated. Se debe usar GetMessageEnumerator2() en su lugar.GetMessageEnumerator2() should be used instead.

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

Sirve como la función hash predeterminada.Serves as the default hash function.

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

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetMachineId(String) GetMachineId(String) GetMachineId(String) GetMachineId(String)

Obtiene el identificador del equipo en el que se encuentra la cola a la que hace referencia MessageQueue.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

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

Crea un objeto enumerador para todos los mensajes de la cola.Creates an enumerator object for all the messages in the queue. GetMessageEnumerator() está desusada.GetMessageEnumerator() is deprecated. Se debe usar GetMessageEnumerator2() en su lugar.GetMessageEnumerator2() should be used instead.

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

Crea un objeto enumerador para todos los mensajes de la cola.Creates an enumerator object for all the messages in the queue.

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

Proporciona el funcionamiento de un cursor de solo avance para enumerar todas las colas públicas de la red.Provides forward-only cursor semantics to enumerate through all public queues on the network.

GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) GetMessageQueueEnumerator(MessageQueueCriteria) 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.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String) GetPrivateQueuesByMachine(String)

Recupera todas las colas privadas del equipo especificado.Retrieves all the private queues on the specified computer.

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

Recupera todas las colas públicas de la red.Retrieves all the public queues on the network.

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

Recupera todas las colas públicas de la red que cumplan los criterios especificados.Retrieves all the public queues on the network that meet the specified criteria.

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

Recupera todas las colas públicas de la red que pertenezcan a la categoría especificada.Retrieves all the public queues on the network that belong to the specified category.

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

Recupera todas las colas públicas de la red que tengan la etiqueta especificada.Retrieves all the public queues on the network that carry the specified label.

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

Recupera todas las colas públicas que residen en el equipo especificado.Retrieves all the public queues that reside on the specified computer.

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

Recupera el contexto de seguridad que MSMQ asocia al usuario actual (identidad de subproceso) en el momento de esta llamada.Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Devuelve un objeto que representa el servicio suministrado por Component o por Container.Returns an object that represents a service provided by the Component or by its Container.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

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

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

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

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. El método Peek() es sincrónico, por lo que se bloquea el subproceso actual hasta que haya un mensaje disponible.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

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

Devuelve sin quitar (búsqueda peek) el primer mensaje de la cola a la que hace referencia esta MessageQueue.Returns without removing (peeks) the first message in the queue referenced by this 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.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction) Peek(TimeSpan, Cursor, PeekAction)

Vuelve sin quitar (búsquedas peek) el mensaje actual o próximo de la cola, utilizando el cursor especificado.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. 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.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

PeekByCorrelationId(String) PeekByCorrelationId(String) PeekByCorrelationId(String) PeekByCorrelationId(String)

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.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan) PeekByCorrelationId(String, TimeSpan)

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.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String) PeekById(String) PeekById(String) PeekById(String)

Busca el mensaje cuyo identificador de mensaje coincida con el parámetro id.Peeks the message whose message identifier matches the id parameter.

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

Busca el mensaje cuyo identificador de mensaje coincida con el parámetro id.Peeks the message whose message identifier matches the id parameter. Espera hasta que el mensaje aparezca en la cola o hasta que finalice el tiempo de espera.Waits until the message appears in the queue or a time-out occurs.

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

Introducido en MSMQ 3.0.Introduced in 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.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64) PeekByLookupId(MessageLookupAction, Int64)

Introducido en MSMQ 3.0.Introduced in MSMQ 3.0. Ejecuta el método Peek en un mensaje concreto de la cola.Peeks at a specific message from the queue. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final de la cola.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge() Purge() Purge() Purge()

Elimina todos los mensajes contenidos en la cola.Deletes all the messages contained in the queue.

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

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Recibe el primer mensaje disponible en la cola transaccional a la que hace referencia MessageQueue.Receives the first message available in the transactional queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

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

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the MessageQueue. Esta llamada es sincrónica y bloquea el subproceso de ejecución actual hasta que se encuentre disponible un mensaje.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan) Receive(TimeSpan) Receive(TimeSpan) 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.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor) Receive(TimeSpan, Cursor)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction) Receive(TimeSpan, Cursor, MessageQueueTransaction)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType) Receive(TimeSpan, Cursor, MessageQueueTransactionType)

Recibe el mensaje actual en la cola, utilizando un cursor especificado.Receives the current message in the queue, using a specified cursor. Si no está disponible ningún mensaje, este método espera hasta esté disponible un mensaje o hasta que expire el tiempo de espera.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction) Receive(TimeSpan, MessageQueueTransaction)

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.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType) Receive(TimeSpan, MessageQueueTransactionType)

Recibe el primer mensaje disponible en la cola a la que hace referencia MessageQueue.Receives the first message available in the queue referenced by the 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.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) ReceiveByCorrelationId(String) ReceiveByCorrelationId(String)

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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction) ReceiveByCorrelationId(String, MessageQueueTransaction)

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.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType) ReceiveByCorrelationId(String, MessageQueueTransactionType)

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.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan) ReceiveByCorrelationId(String, TimeSpan)

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.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

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.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

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.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveById(String) ReceiveById(String) ReceiveById(String) ReceiveById(String)

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.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction) ReceiveById(String, MessageQueueTransaction)

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.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType) ReceiveById(String, MessageQueueTransactionType)

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.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan) ReceiveById(String, TimeSpan)

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.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction) ReceiveById(String, TimeSpan, MessageQueueTransaction)

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.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType) ReceiveById(String, TimeSpan, MessageQueueTransactionType)

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.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64) ReceiveByLookupId(Int64)

Introducido en MSMQ 3.0.Introduced in MSMQ 3.0. Recibe el mensaje que coincide con el identificador de búsqueda dado de una cola no transaccional.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

Introducido en MSMQ 3.0.Introduced in MSMQ 3.0. Recibe un mensaje concreto de una cola transaccional.Receives a specific message from a transactional queue. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final de la cola.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

Introducido en MSMQ 3.0.Introduced in MSMQ 3.0. Recibe un mensaje concreto de la cola, utilizando el contexto de transacción especificado.Receives a specific message from the queue, using the specified transaction context. El mensaje se puede especificar mediante un identificador de búsqueda o por su posición al principio o al final de la cola.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh() Refresh() Refresh() Refresh()

Actualiza las propiedades que presenta MessageQueue para reflejar el estado actual del recurso.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

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

Restablece la lista de permisos con los valores predeterminados del sistema operativo.Resets the permission list to the operating system's default values. Quita los permisos de cola que se hayan agregado a la lista predeterminada.Removes any queue permissions you have appended to the default list.

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

Envía un objeto a la cola no transaccional a la que hace referencia este objeto MessageQueue.Sends an object to non-transactional queue referenced by this MessageQueue.

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

Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue.Sends an object to the transactional queue referenced by this MessageQueue.

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

Envía un objeto a la cola a la que hace referencia esta MessageQueue.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String) Send(Object, String) Send(Object, String) 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.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

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

Envía un objeto a la cola transaccional a la que hace referencia este objeto MessageQueue y especifica una etiqueta para el mensaje.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

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

Envía un objeto a la cola a la que hace referencia esta MessageQueue y especifica una etiqueta para el mensaje.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList) SetPermissions(AccessControlList)

Asigna derechos de acceso a la cola de acuerdo con el contenido de una lista de control de acceso.Assigns access rights to the queue based on the contents of an access control list.

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

Asigna derechos de acceso a la cola basándose en el contenido de una entrada de control de acceso.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights) SetPermissions(String, MessageQueueAccessRights)

Concede a un equipo, a un grupo o a un usuario los derechos de acceso especificados.Gives a computer, group, or user the specified access rights.

SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)

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).Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString() ToString() ToString() ToString()

Devuelve una String que contiene el nombre del Component, si existe.Returns a String containing the name of the Component, if any. Este método no se debe invalidar.This method should not be overridden.

(Inherited from Component)

Eventos

Disposed Disposed Disposed Disposed

Se produce cuando el componente se elimina mediante una llamada al método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
PeekCompleted PeekCompleted PeekCompleted PeekCompleted

Se produce cuando se lee un mensaje sin haberlo quitado de la cola.Occurs when a message is read without being removed from the queue. Es resultado de la operación asincrónica, BeginPeek().This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted ReceiveCompleted ReceiveCompleted ReceiveCompleted

Se produce cuando se quita un mensaje de la cola.Occurs when a message has been removed from the queue. La operación asincrónica BeginReceive() provoca este evento.This event is raised by the asynchronous operation, BeginReceive().

Métodos de extensión

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

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

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

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita la paralelización de una consulta.Enables parallelization of a query.

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

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Se aplica a

Seguridad para subprocesos

Solo el GetAllMessages() método es seguro para subprocesos.Only the GetAllMessages() method is thread safe.

Consulte también: