MessageQueue Costruttori

Riferimento

Definizione

Spazio dei nomi:: System.Messaging

Assembly:: System.Messaging.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza una nuova istanza della classe MessageQueue.

Overload

MessageQueue()	Inizializza una nuova istanza della classe MessageQueue. Dopo che il costruttore senza parametri inizializza la nuova istanza, è necessario impostare la proprietà Path dell'istanza prima di poter usare l'istanza.
MessageQueue(String)	Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda accodamento messaggi nel percorso specificato.
MessageQueue(String, Boolean)	Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda accodamento messaggi nel percorso specificato e con la restrizione di accesso in lettura specificata.
MessageQueue(String, QueueAccessMode)	Inizializza una nuova istanza della classe MessageQueue.
MessageQueue(String, Boolean, Boolean)	Inizializza una nuova istanza della classe MessageQueue.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inizializza una nuova istanza della classe MessageQueue.

MessageQueue()

Inizializza una nuova istanza della classe MessageQueue. Dopo che il costruttore senza parametri inizializza la nuova istanza, è necessario impostare la proprietà Path dell'istanza prima di poter usare l'istanza.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Esempio

Nell'esempio di codice seguente viene creato un nuovo 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";

Commenti

Utilizzare questo overload per creare una nuova istanza della classe MessageQueue che non è immediatamente associata a una coda nel server Accodamento messaggi. Prima di usare questa istanza, è necessario connetterla a una coda di accodamento messaggi esistente impostando la proprietà Path. In alternativa, è possibile impostare il riferimento MessageQueue sul valore restituito del metodo Create(String), creando così una nuova coda di accodamento messaggi.

Il costruttore MessageQueue crea un'istanza di una nuova istanza della classe MessageQueue; non crea una nuova coda di accodamento messaggi.

Nella tabella seguente vengono illustrati i valori iniziali delle proprietà per un'istanza di MessageQueue.

Proprietà	Valore iniziale
DefaultPropertiesToSend	Valori impostati dal costruttore senza parametri della classe DefaultPropertiesToSend.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Valori impostati dal costruttore senza parametri della classe MessagePropertyFilter. Tutti i valori del filtro sono impostati su `true`.
DenySharedReceive	`false`

Vedi anche

Si applica a

MessageQueue(String)

Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda accodamento messaggi nel percorso specificato.

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

public MessageQueue (string path);

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

Public Sub New (path As String)

Parametri

path: String

Posizione della coda a cui fa riferimento questo MessageQueue.

Eccezioni

ArgumentException

La proprietà Path non è valida, probabilmente perché non è stata impostata.

Esempio

Nell'esempio di codice seguente vengono creati nuovi oggetti MessageQueue usando vari tipi di sintassi dei nomi di percorso. In ogni caso, invia un messaggio alla coda il cui percorso è definito nel costruttore.

#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

Commenti

Usare questo overload quando si desidera associare la nuova istanza di MessageQueue a una particolare coda di accodamento messaggi, per cui si conosce il percorso, il nome del formato o l'etichetta. Se si vuole concedere l'accesso esclusivo alla prima applicazione che fa riferimento alla coda, è necessario impostare la proprietà DenySharedReceive su true o usare il costruttore che passa un parametro di restrizione di accesso in lettura.

Il costruttore MessageQueue crea un'istanza di una nuova istanza della classe MessageQueue; non crea una nuova coda di accodamento messaggi. Per creare una nuova coda in Accodamento messaggi, usare Create(String).

La sintassi del parametro path dipende dal tipo di coda a cui fa riferimento, come illustrato nella tabella seguente.

Tipo di coda	Sintassi
Coda pubblica	`MachineName`\`QueueName`
Coda privata	`MachineName`\`Private$`\`QueueName`
Coda journal	`MachineName`\`QueueName`\`Journal$`
Coda del journal del computer	`MachineName`\`Journal$`
Coda messaggi non recapitabili del computer	`MachineName`\`Deadletter$`
Coda di messaggi non recapitabili transazionali del computer	`MachineName`\`XactDeadletter$`

In alternativa, è possibile usare il FormatName o Label per descrivere il percorso della coda, come illustrato nella tabella seguente.

Riferimento	Sintassi	Esempio
Nome formato	`FormatName:` [ nome formato ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Etichetta	`Label:` [ etichetta ]	`Label:` TheLabel

Per funzionare offline, è necessario usare la sintassi del nome di formato, non la sintassi del nome del percorso per il costruttore. In caso contrario, viene generata un'eccezione perché il controller di dominio primario non è disponibile per risolvere il percorso del nome di formato.

Nella tabella seguente vengono illustrati i valori iniziali delle proprietà per un'istanza di MessageQueue. Questi valori si basano sulle proprietà della coda accodamento messaggi con il percorso specificato dal parametro path.

Proprietà	Valore iniziale
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Valori impostati dal costruttore senza parametri della classe DefaultPropertiesToSend.
EncryptionRequired	`true`, se l'impostazione del livello di privacy della coda accodamento messaggi è "Corpo"; in caso contrario, `false`.
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Valore della proprietà nome computer della coda accodamento messaggi.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Valori impostati dal costruttore senza parametri della classe MessagePropertyFilter.
Path	Empty, se non impostato dal costruttore .
QueueName	Empty, se non impostato dal costruttore .
DenySharedReceive	`false`
UseJournalQueue	`true`, se l'impostazione journal dell'oggetto Accodamento messaggi è abilitata; in caso contrario, `false`.

Vedi anche

Si applica a

MessageQueue(String, Boolean)

Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda accodamento messaggi nel percorso specificato e con la restrizione di accesso in lettura specificata.

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)

Parametri

path: String

Posizione della coda a cui fa riferimento questo MessageQueue, che può essere "." per il computer locale.

sharedModeDenyReceive: Boolean

true di concedere l'accesso in lettura esclusivo alla prima applicazione che accede alla coda; in caso contrario, false.

Eccezioni

ArgumentException

La proprietà Path non è valida, probabilmente perché non è stata impostata.

Esempio

Nell'esempio di codice seguente viene creato un nuovo MessageQueue con accesso esclusivo, viene impostato il percorso e viene inviato un messaggio alla coda.

#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

Commenti

Usare questo overload quando si desidera associare il nuovo MessageQueue a una particolare coda di accodamento messaggi, per cui si conosce il percorso, il nome del formato o l'etichetta. Se si vuole concedere l'accesso esclusivo alla prima applicazione che fa riferimento alla coda, impostare il parametro sharedModeDenyReceive su true. In caso contrario, impostare sharedModeDenyReceive su false o usare il costruttore con solo un parametro path.

L'impostazione di sharedModeDenyReceive su true influisce su tutti gli oggetti che accedono alla coda di accodamento messaggi, incluse altre applicazioni. Gli effetti del parametro non sono limitati a questa applicazione.

Il costruttore MessageQueue crea una nuova istanza della classe MessageQueue; non crea una nuova coda di accodamento messaggi. Per creare una nuova coda in Accodamento messaggi, usare Create(String).

La sintassi del parametro path dipende dal tipo di coda.

Tipo di coda	Sintassi
Coda pubblica	`MachineName`\`QueueName`
Coda privata	`MachineName`\`Private$`\`QueueName`
Coda journal	`MachineName`\`QueueName`\`Journal$`
Coda del journal del computer	`MachineName`\`Journal$`
Coda messaggi non recapitabili del computer	`MachineName`\`Deadletter$`
Coda di messaggi non recapitabili transazionali del computer	`MachineName`\`XactDeadletter$`

In alternativa, è possibile usare il nome del formato o l'etichetta di una coda di accodamento messaggi per descrivere il percorso della coda.

Riferimento	Sintassi	Esempio
Nome formato	`FormatName:` [ nome formato ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
Etichetta	`Label:` [ etichetta ]	`Label:` TheLabel

Per funzionare offline, è necessario usare la sintassi del nome del formato anziché la sintassi del nome descrittivo. In caso contrario, viene generata un'eccezione perché il controller di dominio primario (in cui si trova Active Directory) non è disponibile per risolvere il percorso del nome di formato.

Se un MessageQueue apre una coda con il parametro sharedModeDenyReceive impostato su true, qualsiasi MessageQueue che successivamente tenta di leggere dalla coda genera un MessageQueueException a causa di una violazione di condivisione. Viene generata anche una MessageQueueException se un MessageQueue tenta di accedere alla coda in modalità esclusiva mentre un altro MessageQueue ha già accesso non esclusivo alla coda.

Proprietà	Valore iniziale
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Valori impostati dal costruttore senza parametri della classe DefaultPropertiesToSend.
EncryptionRequired	`true`, se l'impostazione del livello di privacy della coda accodamento messaggi è "Corpo"; in caso contrario, `false`.
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Valore della proprietà nome computer della coda accodamento messaggi.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Valori impostati dal costruttore senza parametri della classe MessagePropertyFilter.
Path	Empty, se non impostato dal costruttore .
QueueName	Empty, se non impostato dal costruttore .
DenySharedReceive	Valore del parametro `sharedModeDenyReceive`.
UseJournalQueue	`true`, se l'impostazione journal dell'oggetto Accodamento messaggi è abilitata; in caso contrario, `false`.

Vedi anche

Si applica a

MessageQueue(String, QueueAccessMode)

Inizializza una nuova istanza della 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)

Parametri

path: String

Posizione della coda a cui fa riferimento questo MessageQueue, che può essere "." per il computer locale.

accessMode: QueueAccessMode

Uno dei valori di QueueAccessMode.

Si applica a

MessageQueue(String, Boolean, Boolean)

Inizializza una nuova istanza della 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)

Parametri

path: String

Posizione della coda a cui fa riferimento questo MessageQueue, che può essere "." per il computer locale.

sharedModeDenyReceive: Boolean

true di concedere l'accesso in lettura esclusivo alla prima applicazione che accede alla coda; in caso contrario, false.

enableCache: Boolean

true creare e usare una cache di connessione; in caso contrario, false.

Esempio

Nell'esempio di codice seguente viene creato un nuovo MessageQueue con accesso in lettura esclusivo e con la memorizzazione nella cache delle connessioni abilitata.

// 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);

Si applica a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inizializza una nuova istanza della 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)

Parametri

path: String

Posizione della coda a cui fa riferimento questo MessageQueue, che può essere "." per il computer locale.

sharedModeDenyReceive: Boolean

true di concedere l'accesso in lettura esclusivo alla prima applicazione che accede alla coda; in caso contrario, false.

enableCache: Boolean

true creare e usare una cache di connessione; in caso contrario, false.

accessMode: QueueAccessMode

Uno dei valori di QueueAccessMode.

Si applica a

Condividi tramite

MessageQueue Costruttori

Definizione

Overload

MessageQueue()

Esempio

Commenti

Vedi anche

Si applica a

MessageQueue(String)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

MessageQueue(String, Boolean)

Parametri

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

MessageQueue(String, QueueAccessMode)

Parametri

Si applica a

MessageQueue(String, Boolean, Boolean)

Parametri

Esempio

Si applica a

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parametri

Si applica a

Commenti e suggerimenti

Risorse aggiuntive