MessageQueue Construtores

Referência

Definição

Namespace:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicializa uma nova instância da classe MessageQueue.

Sobrecargas

MessageQueue()	Inicializa uma nova instância da classe MessageQueue. Depois que o construtor sem parâmetros inicializar a nova instância, você deverá definir a propriedade Path da instância antes de poder usar a instância.
MessageQueue(String)	Inicializa uma nova instância da classe MessageQueue que faz referência à fila de Enfileiramento de Mensagens no caminho especificado.
MessageQueue(String, Boolean)	Inicializa uma nova instância da classe MessageQueue que faz referência à fila de Enfileiramento de Mensagens no caminho especificado e com a restrição de acesso de leitura especificada.
MessageQueue(String, QueueAccessMode)	Inicializa uma nova instância da classe MessageQueue.
MessageQueue(String, Boolean, Boolean)	Inicializa uma nova instância da classe MessageQueue.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicializa uma nova instância da classe MessageQueue.

MessageQueue()

Inicializa uma nova instância da classe MessageQueue. Depois que o construtor sem parâmetros inicializar a nova instância, você deverá definir a propriedade Path da instância antes de poder usar a instância.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Exemplos

O exemplo de código a seguir cria um novo 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";

Comentários

Use essa sobrecarga para criar uma nova instância da classe MessageQueue que não esteja imediatamente vinculada a uma fila no servidor de Enfileiramento de Mensagens. Antes de usar essa instância, você deve conectá-la a uma fila de Enfileiramento de Mensagens existente definindo a propriedade Path. Como alternativa, você pode definir a referência MessageQueue ao valor retornado do método Create(String), criando assim uma nova fila de Enfileiramento de Mensagens.

O construtor MessageQueue cria uma instância nova da classe MessageQueue; ele não cria uma nova fila de Enfileiramento de Mensagens.

A tabela a seguir mostra valores de propriedade iniciais para uma instância de MessageQueue.

Propriedade	Valor inicial
DefaultPropertiesToSend	Os valores definidos pelo construtor sem parâmetros da classe DefaultPropertiesToSend.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Os valores definidos pelo construtor sem parâmetros da classe MessagePropertyFilter. Todos os valores de filtro são definidos como `true`.
DenySharedReceive	`false`

Confira também

Aplica-se a

MessageQueue(String)

Inicializa uma nova instância da classe MessageQueue que faz referência à fila de Enfileiramento de Mensagens no caminho especificado.

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

O local da fila referenciada por este MessageQueue.

Exceções

ArgumentException

A propriedade Path não é válida, possivelmente porque não foi definida.

Exemplos

O exemplo de código a seguir cria novos objetos MessageQueue usando vários tipos de sintaxe de nome de caminho. Em cada caso, ele envia uma mensagem para a fila cujo caminho é definido no construtor.

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

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

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


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


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


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


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


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


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


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

};


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

using System;
using System.Messaging;

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

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

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

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

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

            return;
        }

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

            return;
        }

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

            return;
        }

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

            return;
        }

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

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

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

Imports System.Messaging

Public Class MyNewQueue


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

        Public Shared Sub Main()

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

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

            Return

        End Sub


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub

End Class

Comentários

Use essa sobrecarga quando quiser vincular a nova instância de MessageQueue a uma fila de Enfileiramento de Mensagens específica, para a qual você conhece o caminho, o nome do formato ou o rótulo. Se você quiser conceder acesso exclusivo ao primeiro aplicativo que faz referência à fila, deverá definir a propriedade DenySharedReceive para true ou usar o construtor que passa um parâmetro de restrição de acesso de leitura.

O construtor MessageQueue cria uma instância nova da classe MessageQueue; ele não cria uma nova fila de Enfileiramento de Mensagens. Para criar uma nova fila no Enfileiramento de Mensagens, use Create(String).

A sintaxe do parâmetro path depende do tipo de fila que ele faz referência, conforme mostrado na tabela a seguir.

Tipo de fila	Sintaxe
Fila pública	`MachineName`\`QueueName`
Fila privada	`MachineName`\`Private$`\`QueueName`
Fila de diários	`MachineName`\`QueueName`\`Journal$`
Fila de diários do computador	`MachineName`\`Journal$`
Fila de mensagens mortas do computador	`MachineName`\`Deadletter$`
Fila de mensagens mortas transacionais do computador	`MachineName`\`XactDeadletter$`

Como alternativa, você pode usar o FormatName ou Label para descrever o caminho da fila, conforme mostrado na tabela a seguir.

Referência	Sintaxe	Exemplo
Nome do formato	`FormatName:` [ nome do 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 rótulo ]	`Label:` TheLabel

Para trabalhar offline, você deve usar a sintaxe de nome de formato, não a sintaxe do nome do caminho para o construtor. Caso contrário, uma exceção será gerada porque o controlador de domínio primário não está disponível para resolver o caminho para o nome do formato.

A tabela a seguir mostra valores de propriedade iniciais para uma instância de MessageQueue. Esses valores são baseados nas propriedades da fila de Enfileiramento de Mensagens com o caminho especificado pelo parâmetro path.

Propriedade	Valor inicial
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Os valores definidos pelo construtor sem parâmetros da classe DefaultPropertiesToSend.
EncryptionRequired	`true`, se a configuração de nível de privacidade da fila de Enfileiramento de Mensagens for "Corpo"; caso contrário, `false`.
Formatter	XmlMessageFormatter
Label	Empty
MachineName	O valor da propriedade de nome do computador da fila de Enfileiramento de Mensagens.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Os valores definidos pelo construtor sem parâmetros da classe MessagePropertyFilter.
Path	Empty, se não for definido pelo construtor.
QueueName	Empty, se não for definido pelo construtor.
DenySharedReceive	`false`
UseJournalQueue	`true`, se a configuração de diário do objeto Enfileiramento de Mensagem estiver habilitada; caso contrário, `false`.

Confira também

Aplica-se a

MessageQueue(String, Boolean)

Inicializa uma nova instância da classe MessageQueue que faz referência à fila de Enfileiramento de Mensagens no caminho especificado e com a restrição de acesso de leitura 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

O local da fila referenciada por este MessageQueue, que pode ser "" para o computador local.

sharedModeDenyReceive: Boolean

true conceder acesso de leitura exclusivo ao primeiro aplicativo que acessa a fila; caso contrário, false.

Exceções

ArgumentException

A propriedade Path não é válida, possivelmente porque não foi definida.

Exemplos

O exemplo de código a seguir cria uma nova MessageQueue com acesso exclusivo, define seu caminho e envia uma mensagem para a fila.

#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

Comentários

Use essa sobrecarga quando quiser vincular o novo MessageQueue a uma fila de Enfileiramento de Mensagens específica, para a qual você conhece o caminho, o nome do formato ou o rótulo. Se você quiser conceder acesso exclusivo ao primeiro aplicativo que faz referência à fila, defina o parâmetro sharedModeDenyReceive como true. Caso contrário, defina sharedModeDenyReceive para false ou use o construtor que tenha apenas um parâmetro path.

A configuração sharedModeDenyReceive para true afeta todos os objetos que acessam a fila de Enfileiramento de Mensagens, incluindo outros aplicativos. Os efeitos do parâmetro não são restritos a este aplicativo.

O construtor MessageQueue cria uma nova instância da classe MessageQueue; ele não cria uma nova fila de Enfileiramento de Mensagens. Para criar uma nova fila no Enfileiramento de Mensagens, use Create(String).

A sintaxe do parâmetro path depende do tipo de fila.

Tipo de fila	Sintaxe
Fila pública	`MachineName`\`QueueName`
Fila privada	`MachineName`\`Private$`\`QueueName`
Fila de diários	`MachineName`\`QueueName`\`Journal$`
Fila de diários do computador	`MachineName`\`Journal$`
Fila de mensagens mortas do computador	`MachineName`\`Deadletter$`
Fila de mensagens mortas transacionais do computador	`MachineName`\`XactDeadletter$`

Como alternativa, você pode usar o nome do formato ou o rótulo de uma fila de Enfileiramento de Mensagens para descrever o caminho da fila.

Referência	Sintaxe	Exemplo
Nome do formato	`FormatName:` [ nome do 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 rótulo ]	`Label:` TheLabel

Para trabalhar offline, você deve usar a sintaxe de nome de formato, em vez da sintaxe de nome amigável. Caso contrário, uma exceção é gerada porque o controlador de domínio primário (no qual o Active Directory reside) não está disponível para resolver o caminho para o nome do formato.

Se um MessageQueue abrir uma fila com o parâmetro sharedModeDenyReceive definido como true, qualquer MessageQueue que tente ler posteriormente da fila gerará um MessageQueueException devido a uma violação de compartilhamento. Um MessageQueueException também será gerado se um MessageQueue tentar acessar a fila no modo exclusivo, enquanto outro MessageQueue já tiver acesso não exclusivo à fila.

A tabela a seguir mostra valores de propriedade iniciais para uma instância de MessageQueue. Esses valores são baseados nas propriedades da fila de Enfileiramento de Mensagens, com o caminho especificado pelo parâmetro path.

Propriedade	Valor inicial
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Os valores definidos pelo construtor sem parâmetros da classe DefaultPropertiesToSend.
EncryptionRequired	`true`, se a configuração de nível de privacidade da fila de Enfileiramento de Mensagens for "Corpo"; caso contrário, `false`.
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	O valor da propriedade de nome do computador da fila de Enfileiramento de Mensagens.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Os valores definidos pelo construtor sem parâmetros da classe MessagePropertyFilter.
Path	Empty, se não for definido pelo construtor.
QueueName	Empty, se não for definido pelo construtor.
DenySharedReceive	O valor do parâmetro `sharedModeDenyReceive`.
UseJournalQueue	`true`, se a configuração de diário do objeto Enfileiramento de Mensagem estiver habilitada; caso contrário, `false`.

Confira também

Aplica-se a

MessageQueue(String, QueueAccessMode)

Inicializa uma nova instância da classe 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

O local da fila referenciada por este MessageQueue, que pode ser "" para o computador local.

accessMode: QueueAccessMode

Um dos valores QueueAccessMode.

Aplica-se a

MessageQueue(String, Boolean, Boolean)

Inicializa uma nova instância da classe 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

O local da fila referenciada por este MessageQueue, que pode ser "" para o computador local.

sharedModeDenyReceive: Boolean

true conceder acesso de leitura exclusivo ao primeiro aplicativo que acessa a fila; caso contrário, false.

enableCache: Boolean

true criar e usar um cache de conexão; caso contrário, false.

Exemplos

O exemplo de código a seguir cria uma nova MessageQueue com acesso de leitura exclusivo e com o cache de conexão 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);

Aplica-se a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inicializa uma nova instância da classe 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

O local da fila referenciada por este MessageQueue, que pode ser "" para o computador local.

sharedModeDenyReceive: Boolean

true conceder acesso de leitura exclusivo ao primeiro aplicativo que acessa a fila; caso contrário, false.

enableCache: Boolean

true criar e usar um cache de conexão; caso contrário, false.

accessMode: QueueAccessMode

Um dos valores QueueAccessMode.

Aplica-se a

Compartilhar via

MessageQueue Construtores

Definição

Sobrecargas

MessageQueue()

Exemplos

Comentários

Confira também

Aplica-se a

MessageQueue(String)

Parâmetros

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

MessageQueue(String, Boolean)

Parâmetros

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

MessageQueue(String, QueueAccessMode)

Parâmetros

Aplica-se a

MessageQueue(String, Boolean, Boolean)

Parâmetros

Exemplos

Aplica-se a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parâmetros

Aplica-se a

Recursos adicionais