MessageQueue Constructores

Referencia

Definición

Espacio de nombres:: System.Messaging

Ensamblado:: System.Messaging.dll

Importante

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

Inicializa una nueva instancia de la clase MessageQueue.

Sobrecargas

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

MessageQueue()

Inicializa una nueva instancia de la clase MessageQueue. Una vez que el constructor sin parámetros inicializa la nueva instancia, debe establecer la propiedad Path de la instancia para poder usar la instancia.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Ejemplos

En el ejemplo de código siguiente se crea una nueva MessageQueue.

// Connect to a queue on the local computer. You must set the queue's
// Path property before you can use the queue.
MessageQueue queue = new MessageQueue();
queue.Path = ".\\exampleQueue";

Comentarios

Use esta sobrecarga para crear una nueva instancia de la clase MessageQueue que no está asociada inmediatamente a una cola en el servidor Message Queuing. Antes de usar esta instancia, debe conectarla a una cola de Message Queuing existente estableciendo la propiedad Path. Como alternativa, puede establecer la referencia de MessageQueue al valor devuelto del método Create(String), creando así una nueva cola de Message Queuing.

El constructor MessageQueue crea una instancia nueva de la clase MessageQueue; no crea una nueva cola de Message Queuing.

En la tabla siguiente se muestran los valores de propiedad iniciales de una instancia de MessageQueue.

Propiedad	Valor inicial
DefaultPropertiesToSend	Los valores establecidos por el constructor sin parámetros de la clase DefaultPropertiesToSend.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Los valores establecidos por el constructor sin parámetros de la clase MessagePropertyFilter. Todos los valores de filtro se establecen en `true`.
DenySharedReceive	`false`

Consulte también

Se aplica a

MessageQueue(String)

Inicializa una nueva instancia de la clase MessageQueue que hace referencia a la cola Message Queuing en la ruta de acceso especificada.

public:
 MessageQueue(System::String ^ path);

public MessageQueue (string path);

new System.Messaging.MessageQueue : string -> System.Messaging.MessageQueue

Public Sub New (path As String)

Parámetros

path: String

Ubicación de la cola a la que hace referencia este MessageQueue.

Excepciones

ArgumentException

La propiedad Path no es válida, posiblemente porque no se ha establecido.

Ejemplos

En el ejemplo de código siguiente se crean nuevos objetos MessageQueue 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

Comentarios

Use esta sobrecarga cuando desee vincular la nueva instancia de MessageQueue a una cola de Message Queuing determinada, para la que conoce la ruta de acceso, el nombre de formato o la etiqueta. Si desea conceder acceso exclusivo a la primera aplicación que hace referencia a la cola, debe establecer la propiedad DenySharedReceive en true o usar el constructor que pasa un parámetro de restricción de acceso de lectura.

El constructor MessageQueue crea una instancia nueva de la clase MessageQueue; no crea una nueva cola de Message Queuing. Para crear una nueva cola en Message Queuing, use Create(String).

La sintaxis del parámetro path depende del tipo de cola a la que hace referencia, como se muestra en la tabla siguiente.

Tipo de cola	Sintaxis
Cola pública	`MachineName`\`QueueName`
Cola privada	`MachineName`\`Private$`\`QueueName`
Cola de diario	`MachineName`\`QueueName`\`Journal$`
Cola de diario de máquinas	`MachineName`\`Journal$`
Cola de mensajes fallidos de la máquina	`MachineName`\`Deadletter$`
Cola de mensajes fallidos transaccionales de la máquina	`MachineName`\`XactDeadletter$`

Como alternativa, puede usar el FormatName o Label para describir la ruta de acceso de la cola, como se muestra en la tabla siguiente.

Referencia	Sintaxis	Ejemplo
Nombre de formato	`FormatName:` [ nombre de formato ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Etiqueta	[ de etiqueta de ]	`Label:` TheLabel

Para trabajar sin conexión, debe usar la sintaxis de nombre de formato, no la sintaxis de nombre de ruta de acceso para el constructor. De lo contrario, se produce una excepción porque el controlador de dominio principal no está disponible para resolver la ruta de acceso al nombre de formato.

En la tabla siguiente se muestran los valores de propiedad iniciales de una instancia de MessageQueue. Estos valores se basan en las propiedades de la cola Message Queuing con la ruta de acceso especificada por el parámetro path.

Propiedad	Valor inicial
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Los valores establecidos por el constructor sin parámetros de la clase DefaultPropertiesToSend.
EncryptionRequired	`true`, si la configuración del nivel de privacidad de la cola Message Queuing es "Body"; de lo contrario, `false`.
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Valor de la propiedad de nombre de equipo de la cola Message Queuing.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Los valores establecidos por el constructor sin parámetros de la clase MessagePropertyFilter.
Path	Empty, si el constructor no lo establece.
QueueName	Empty, si el constructor no lo establece.
DenySharedReceive	`false`
UseJournalQueue	`true`, si la configuración del diario del objeto Message Queuing está habilitada; de lo contrario, `false`.

Consulte también

Se aplica a

MessageQueue(String, Boolean)

Inicializa una nueva instancia de la clase MessageQueue que hace referencia a la cola Message Queuing en la ruta de acceso especificada y con la restricción de acceso de lectura especificada.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive);

public MessageQueue (string path, bool sharedModeDenyReceive);

new System.Messaging.MessageQueue : string * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean)

Parámetros

path: String

La ubicación de la cola a la que hace referencia este MessageQueue, que puede ser "." para el equipo local.

sharedModeDenyReceive: Boolean

true conceder acceso de lectura exclusivo a la primera aplicación que accede a la cola; de lo contrario, false.

Excepciones

ArgumentException

La propiedad Path no es válida, posiblemente porque no se ha establecido.

Ejemplos

En el ejemplo de código siguiente se crea un nuevo MessageQueue con acceso exclusivo, se establece su ruta de acceso y se envía un mensaje a la cola.

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

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

   // Requests exlusive read access to the queue. If
   // access is granted, receives a message from the 
   // queue.
   void GetExclusiveAccess()
   {
      try
      {
         
         // Request exclusive read access to the queue.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue",true );
         
         // Receive a message. This is where SharingViolation 
         // exceptions would be thrown.
         Message^ myMessage = myQueue->Receive();
      }
      catch ( MessageQueueException^ e ) 
      {
         
         // Handle request for denial of exclusive read access.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::SharingViolation )
         {
            Console::WriteLine( "Denied exclusive read access" );
         }

         
         // Handle other sources of a MessageQueueException.
      }

      
      // Handle other exceptions as necessary.
      return;
   }

};


// Provides an entry point into the application.
// This example connects to a message queue, and
// requests exclusive read access to the queue.
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Output the count of Lowest priority messages.
   myNewQueue->GetExclusiveAccess();
   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 connects to a message queue, and
        // requests exclusive read access to the queue.
        //**************************************************

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

            // Output the count of Lowest priority messages.
            GetExclusiveAccess();
                        
            return;
        }

        //**************************************************
        // Requests exlusive read access to the queue. If
        // access is granted, receives a message from the
        // queue.
        //**************************************************
        
        public static void GetExclusiveAccess()
        {
            try
            {
                // Request exclusive read access to the queue.
                MessageQueue myQueue = new
                    MessageQueue(".\\myQueue", true);

                // Receive a message. This is where SharingViolation
                // exceptions would be thrown.
                Message myMessage = myQueue.Receive();
            }
            
            catch (MessageQueueException e)
            {
                // Handle request for denial of exclusive read access.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.SharingViolation)
                {
                    Console.WriteLine("Denied exclusive read access");
                }

                // Handle other sources of a MessageQueueException.
            }

            // Handle other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example connects to a message queue, and
        ' requests exclusive read access to the queue.
 

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Output the count of Lowest priority messages.
            myNewQueue.GetExclusiveAccess()

            Return

        End Sub


  
        ' Requests exlusive read access to the queue. If
        ' access is granted, receives a message from the 
        ' queue.
  

        Public Sub GetExclusiveAccess()

            Try

                ' Request exclusive read access to the queue.
                Dim myQueue As New MessageQueue(".\myQueue", True)

                ' Receive a message. This is where a SharingViolation 
                ' exception would be thrown.
                Dim myMessage As Message = myQueue.Receive()

            Catch e As MessageQueueException

                ' Handle request for denial of exclusive read access.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.SharingViolation Then

                    Console.WriteLine("Denied exclusive read access.")

                End If

                ' Handle other sources of a MessageQueueException.

                ' Handle other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Comentarios

Use esta sobrecarga cuando desee vincular la nueva MessageQueue a una cola de Message Queuing determinada, para la que conoce la ruta de acceso, el nombre de formato o la etiqueta. Si desea conceder acceso exclusivo a la primera aplicación que hace referencia a la cola, establezca el parámetro sharedModeDenyReceive en true. De lo contrario, establezca sharedModeDenyReceive en false o use el constructor que solo tiene un parámetro path.

Establecer sharedModeDenyReceive en true afecta a todos los objetos que acceden a la cola de Message Queuing, incluidas otras aplicaciones. Los efectos del parámetro no están restringidos a esta aplicación.

El constructor MessageQueue crea una nueva instancia de la clase MessageQueue; no crea una nueva cola de Message Queuing. Para crear una nueva cola en Message Queuing, use Create(String).

La sintaxis del parámetro path depende del tipo de cola.

Tipo de cola	Sintaxis
Cola pública	`MachineName`\`QueueName`
Cola privada	`MachineName`\`Private$`\`QueueName`
Cola de diario	`MachineName`\`QueueName`\`Journal$`
Cola de diario de máquinas	`MachineName`\`Journal$`
Cola de mensajes fallidos de la máquina	`MachineName`\`Deadletter$`
Cola de mensajes fallidos transaccionales de la máquina	`MachineName`\`XactDeadletter$`

Como alternativa, puede usar el nombre de formato o la etiqueta de una cola de Message Queuing para describir la ruta de acceso de la cola.

Referencia	Sintaxis	Ejemplo
Nombre de formato	`FormatName:` [ nombre de formato ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Etiqueta	[ de etiqueta de ]	`Label:` TheLabel

Para trabajar sin conexión, debe usar la sintaxis de nombre de formato, en lugar de la sintaxis de nombre descriptivo. De lo contrario, se produce una excepción porque el controlador de dominio principal (en el que reside Active Directory) no está disponible para resolver la ruta de acceso al nombre de formato.

Si un MessageQueue abre una cola con el parámetro sharedModeDenyReceive establecido en true, cualquier MessageQueue que intente leer posteriormente de la cola genera un MessageQueueException debido a una infracción de uso compartido. También se produce un MessageQueueException si un MessageQueue intenta acceder a la cola en modo exclusivo, mientras que otro MessageQueue ya tiene acceso no exclusivo a la cola.

En la tabla siguiente se muestran los valores de propiedad iniciales de una instancia de MessageQueue. Estos valores se basan en las propiedades de la cola Message Queuing, con la ruta de acceso especificada por el parámetro path.

Propiedad	Valor inicial
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Los valores establecidos por el constructor sin parámetros de la clase DefaultPropertiesToSend.
EncryptionRequired	`true`, si la configuración del nivel de privacidad de la cola Message Queuing es "Body"; de lo contrario, `false`.
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Valor de la propiedad de nombre de equipo de la cola Message Queuing.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Los valores establecidos por el constructor sin parámetros de la clase MessagePropertyFilter.
Path	Empty, si el constructor no lo establece.
QueueName	Empty, si el constructor no lo establece.
DenySharedReceive	Valor del parámetro `sharedModeDenyReceive`.
UseJournalQueue	`true`, si la configuración del diario del objeto Message Queuing está habilitada; de lo contrario, `false`.

Consulte también

Se aplica a

MessageQueue(String, QueueAccessMode)

Inicializa una nueva instancia de la clase MessageQueue.

public:
 MessageQueue(System::String ^ path, System::Messaging::QueueAccessMode accessMode);

public MessageQueue (string path, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, accessMode As QueueAccessMode)

Parámetros

path: String

La ubicación de la cola a la que hace referencia este MessageQueue, que puede ser "." para el equipo local.

accessMode: QueueAccessMode

Uno de los valores de QueueAccessMode.

Se aplica a

MessageQueue(String, Boolean, Boolean)

Inicializa una nueva instancia de la clase MessageQueue.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache);

public MessageQueue (string path, bool sharedModeDenyReceive, bool enableCache);

new System.Messaging.MessageQueue : string * bool * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean)

Parámetros

path: String

La ubicación de la cola a la que hace referencia este MessageQueue, que puede ser "." para el equipo local.

sharedModeDenyReceive: Boolean

true conceder acceso de lectura exclusivo a la primera aplicación que accede a la cola; de lo contrario, false.

enableCache: Boolean

true crear y usar una caché de conexiones; de lo contrario, false.

Ejemplos

En el ejemplo de código siguiente se crea una nueva MessageQueue con acceso de lectura exclusivo y con el almacenamiento en caché de conexiones habilitado.

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue", true, true);

queue->Close();

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue queue = new MessageQueue(".\\exampleQueue", true, true);

Se aplica a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inicializa una nueva instancia de la clase MessageQueue.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache, System::Messaging::QueueAccessMode accessMode);

public MessageQueue (string path, bool sharedModeDenyReceive, bool enableCache, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * bool * bool * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean, accessMode As QueueAccessMode)

Parámetros

path: String

La ubicación de la cola a la que hace referencia este MessageQueue, que puede ser "." para el equipo local.

sharedModeDenyReceive: Boolean

true conceder acceso de lectura exclusivo a la primera aplicación que accede a la cola; de lo contrario, false.

enableCache: Boolean

true crear y usar una caché de conexiones; de lo contrario, false.

accessMode: QueueAccessMode

Uno de los valores de QueueAccessMode.

Se aplica a

Compartir vía

MessageQueue Constructores

Definición

Sobrecargas

MessageQueue()

Ejemplos

Comentarios

Consulte también

Se aplica a

MessageQueue(String)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

MessageQueue(String, Boolean)

Parámetros

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

MessageQueue(String, QueueAccessMode)

Parámetros

Se aplica a

MessageQueue(String, Boolean, Boolean)

Parámetros

Ejemplos

Se aplica a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parámetros

Se aplica a

Recursos adicionales