MessageQueue Costruttori
Definizione
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 ha inizializzato la nuova istanza, è necessario impostare la proprietà Path dell'istanza prima di poterla usare. |
MessageQueue(String) |
Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda di Accodamento messaggi nel percorso specificato. |
MessageQueue(String, Boolean) |
Inizializza una nuova istanza della classe MessageQueue che fa riferimento alla coda di Accodamento messaggi nel percorso specificato e con la restrizione specificata per l'accesso in lettura. |
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 ha inizializzato la nuova istanza, è necessario impostare la proprietà Path dell'istanza prima di poterla usare.
public:
MessageQueue();
public MessageQueue ();
Public Sub New ()
Esempio
Nell'esempio di codice seguente viene creato un nuovo MessageQueueoggetto .
// 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 MessageQueue classe 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 Path proprietà . In alternativa, è possibile impostare il MessageQueue riferimento sul Create(String) valore restituito del metodo, creando così una nuova coda accodamento messaggi.
Il MessageQueue costruttore crea un'istanza di una nuova istanza della MessageQueue classe e non crea una nuova coda 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 DefaultPropertiesToSend classe . |
Formatter | XmlMessageFormatter |
MessageReadPropertyFilter | Valori impostati dal costruttore senza parametri della MessagePropertyFilter classe . 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 di 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 l'oggetto MessageQueue fa riferimento.
Eccezioni
La proprietà Path non è valida, probabilmente perché non è stata impostata.
Esempio
Nell'esempio di codice seguente vengono creati nuovi MessageQueue oggetti 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 vuole associare la nuova MessageQueue istanza a una determinata 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 DenySharedReceive proprietà su true
o usare il costruttore che supera un parametro di restrizione di accesso in lettura.
Il MessageQueue costruttore crea un'istanza di una nuova istanza della MessageQueue classe e non crea una nuova coda accodamento messaggi. Per creare una nuova coda in Accodamento messaggi, usare Create(String).
La sintassi del path
parametro 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 del diario | MachineName \QueueName \Journal$ |
Coda del journal del computer | MachineName \Journal$ |
Coda dei messaggi non recapitabili del computer | MachineName \Deadletter$ |
Coda di messaggi non recapitabili transazionali | MachineName \XactDeadletter$ |
In alternativa, è possibile usare o FormatNameLabel 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-845C2AFF7112FormatName:DIRECT=SPX: NetworkNumber ; HostNumber \QueueName FormatName:DIRECT=TCP: IPAddress \QueueName FormatName:DIRECT=OS: MachineName \QueueName |
Etichetta | Label: [ label ] |
Label: TheLabel |
Per funzionare offline, è necessario usare la sintassi del nome del 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 del 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 path
parametro .
Proprietà | Valore iniziale |
---|---|
Authenticate | false |
BasePriority | 0 |
Category | Empty |
DefaultPropertiesToSend | Valori impostati dal costruttore senza parametri della DefaultPropertiesToSend classe . |
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 MessagePropertyFilter classe . |
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 di Accodamento messaggi nel percorso specificato e con la restrizione specificata per l'accesso in lettura.
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 l'oggetto MessageQueue fa riferimento, che può essere "." per il computer locale.
- sharedModeDenyReceive
- Boolean
true
per concedere l'accesso esclusivo in lettura alla prima applicazione con cui viene eseguito l'accesso alla coda; in caso contrario, false
.
Eccezioni
La proprietà Path non è valida, probabilmente perché non è stata impostata.
Esempio
L'esempio di codice seguente crea un nuovo MessageQueue oggetto con accesso esclusivo, ne imposta il percorso e invia 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 vuole associare il nuovo MessageQueue oggetto a una determinata 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 sharedModeDenyReceive
parametro su true
. In caso contrario, impostare su sharedModeDenyReceive
false
o usare il costruttore che ha solo un path
parametro.
L'impostazione di sharedModeDenyReceive
su true
influisce su tutti gli oggetti che accedono alla coda accodamento messaggi, incluse altre applicazioni. Gli effetti del parametro non sono limitati a questa applicazione.
Il MessageQueue costruttore crea una nuova istanza della MessageQueue classe e non crea una nuova coda accodamento messaggi. Per creare una nuova coda in Accodamento messaggi, usare Create(String).
La sintassi del path
parametro dipende dal tipo di coda.
Tipo di coda | Sintassi |
---|---|
Coda pubblica | MachineName \QueueName |
Coda privata | MachineName \Private$ \QueueName |
Coda del diario | MachineName \QueueName \Journal$ |
Coda del journal del computer | MachineName \Journal$ |
Coda dei messaggi non recapitabili del computer | MachineName \Deadletter$ |
Coda di messaggi non recapitabili transazionali | 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-845C2AFF7112FormatName:DIRECT=SPX: NetworkNumber ; HostNumber \QueueName FormatName:DIRECT=TCP: IPAddress \QueueName FormatName:DIRECT=OS: MachineName \QueueName |
Etichetta | Label: [ label ] |
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 del formato.
Se un MessageQueue oggetto apre una coda con il sharedModeDenyReceive
parametro impostato su true
, qualsiasi MessageQueue oggetto che successivamente tenta di leggere dalla coda genera un oggetto MessageQueueException a causa di una violazione di condivisione. Viene MessageQueueException generata anche un'eccezione se un MessageQueue oggetto tenta di accedere alla coda in modalità esclusiva mentre un altro MessageQueue ha già accesso non esclusivo alla coda.
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 path
parametro .
Proprietà | Valore iniziale |
---|---|
Authenticate | false . |
BasePriority | 0. |
Category | Empty. |
DefaultPropertiesToSend | Valori impostati dal costruttore senza parametri della DefaultPropertiesToSend classe . |
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 MessagePropertyFilter classe . |
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 l'oggetto MessageQueue fa riferimento, 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 l'oggetto MessageQueue fa riferimento, che può essere "." per il computer locale.
- sharedModeDenyReceive
- Boolean
true
per concedere l'accesso esclusivo in lettura alla prima applicazione con cui viene eseguito l'accesso alla coda; in caso contrario, false
.
- enableCache
- Boolean
true
per creare e utilizzare una cache di connessioni; in caso contrario, false
.
Esempio
Nell'esempio di codice seguente viene creato un nuovo MessageQueue oggetto con accesso in lettura esclusivo e con la memorizzazione nella cache della connessione 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 l'oggetto MessageQueue fa riferimento, che può essere "." per il computer locale.
- sharedModeDenyReceive
- Boolean
true
per concedere l'accesso esclusivo in lettura alla prima applicazione con cui viene eseguito l'accesso alla coda; in caso contrario, false
.
- enableCache
- Boolean
true
per creare e utilizzare una cache di connessioni; in caso contrario, false
.
- accessMode
- QueueAccessMode
Uno dei valori di QueueAccessMode.
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per