MessageQueue Classe
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.
Fornisce l'accesso a una coda su un server di Accodamento messaggi.
public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
type MessageQueue = class
inherit Component
interface IEnumerable[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
inherit Component
interface IEnumerablePublic Class MessageQueue
Inherits Component
Implements IEnumerable- Ereditarietà
- Attributi
- Implementazioni
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
L'esempio di codice seguente invia un messaggio a una coda e riceve un messaggio da una coda, usando una classe specifica dell'applicazione denominata Order.
#using <system.dll>
#using <system.messaging.dll>
using namespace System;
using namespace System::Messaging;
// This class represents an object the following example
// sends to a queue and receives from a queue.
ref class Order
{
public:
int orderId;
DateTime orderTime;
};
/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:
//*************************************************
// Sends an Order to a queue.
//*************************************************
void SendMessage()
{
// Create a new order and set values.
Order^ sentOrder = gcnew Order;
sentOrder->orderId = 3;
sentOrder->orderTime = DateTime::Now;
// Connect to a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
// Send the Order to the queue.
myQueue->Send( sentOrder );
return;
}
//*************************************************
// Receives a message containing an Order.
//*************************************************
void ReceiveMessage()
{
// Connect to the a queue on the local computer.
MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
// Set the formatter to indicate body contains an Order.
array<Type^>^p = gcnew array<Type^>(1);
p[ 0 ] = Order::typeid;
myQueue->Formatter = gcnew XmlMessageFormatter( p );
try
{
// Receive and format the message.
Message^ myMessage = myQueue->Receive();
Order^ myOrder = static_cast<Order^>(myMessage->Body);
// Display message information.
Console::WriteLine( "Order ID: {0}", myOrder->orderId );
Console::WriteLine( "Sent: {0}", myOrder->orderTime );
}
catch ( MessageQueueException^ )
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch ( InvalidOperationException^ e )
{
Console::WriteLine( e->Message );
}
// Catch other exceptions as necessary.
return;
}
};
//*************************************************
// Provides an entry point into the application.
//
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
// Create a new instance of the class.
MyNewQueue^ myNewQueue = gcnew MyNewQueue;
// Send a message to a queue.
myNewQueue->SendMessage();
// Receive a message from a queue.
myNewQueue->ReceiveMessage();
return 0;
}
using System;
using System.Messaging;
namespace MyProject
{
// This class represents an object the following example
// sends to a queue and receives from a queue.
public class Order
{
public int orderId;
public DateTime orderTime;
};
/// <summary>
/// Provides a container class for the example.
/// </summary>
public class MyNewQueue
{
//**************************************************
// Provides an entry point into the application.
//
// This example sends and receives a message from
// a queue.
//**************************************************
public static void Main()
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
// Send a message to a queue.
myNewQueue.SendMessage();
// Receive a message from a queue.
myNewQueue.ReceiveMessage();
return;
}
//**************************************************
// Sends an Order to a queue.
//**************************************************
public void SendMessage()
{
// Create a new order and set values.
Order sentOrder = new Order();
sentOrder.orderId = 3;
sentOrder.orderTime = DateTime.Now;
// Connect to a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Send the Order to the queue.
myQueue.Send(sentOrder);
return;
}
//**************************************************
// Receives a message containing an Order.
//**************************************************
public void ReceiveMessage()
{
// Connect to the a queue on the local computer.
MessageQueue myQueue = new MessageQueue(".\\myQueue");
// Set the formatter to indicate body contains an Order.
myQueue.Formatter = new XmlMessageFormatter(new Type[]
{typeof(MyProject.Order)});
try
{
// Receive and format the message.
Message myMessage = myQueue.Receive();
Order myOrder = (Order)myMessage.Body;
// Display message information.
Console.WriteLine("Order ID: " +
myOrder.orderId.ToString());
Console.WriteLine("Sent: " +
myOrder.orderTime.ToString());
}
catch (MessageQueueException)
{
// Handle Message Queuing exceptions.
}
// Handle invalid serialization format.
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
// Catch other exceptions as necessary.
return;
}
}
}
Imports System.Messaging
' This class represents an object the following example
' sends to a queue and receives from a queue.
Public Class Order
Public orderId As Integer
Public orderTime As DateTime
End Class
Public Class MyNewQueue
'
' Provides an entry point into the application.
'
' This example sends and receives a message from
' a qeue.
'
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue()
' Send a message to a queue.
myNewQueue.SendMessage()
' Receive a message from a queue.
myNewQueue.ReceiveMessage()
Return
End Sub
'
' Sends an Order to a queue.
'
Public Sub SendMessage()
' Create a new order and set values.
Dim sentOrder As New Order()
sentOrder.orderId = 3
sentOrder.orderTime = DateTime.Now
' Connect to a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Send the Order to the queue.
myQueue.Send(sentOrder)
Return
End Sub
'
' Receives a message containing an Order.
'
Public Sub ReceiveMessage()
' Connect to the a queue on the local computer.
Dim myQueue As New MessageQueue(".\myQueue")
' Set the formatter to indicate the body contains an Order.
myQueue.Formatter = New XmlMessageFormatter(New Type() _
{GetType(Order)})
Try
' Receive and format the message.
Dim myMessage As Message = myQueue.Receive()
Dim myOrder As Order = CType(myMessage.Body, Order)
' Display message information.
Console.WriteLine(("Order ID: " + _
myOrder.orderId.ToString()))
Console.WriteLine(("Sent: " + _
myOrder.orderTime.ToString()))
Catch m As MessageQueueException
' Handle Message Queuing exceptions.
Catch e As InvalidOperationException
' Handle invalid serialization format.
Console.WriteLine(e.Message)
' Catch other exceptions as necessary.
End Try
Return
End Sub
End Class
Commenti
La tecnologia accodamento messaggi consente alle applicazioni in esecuzione in momenti diversi di comunicare tra reti eterogenee e sistemi che potrebbero essere temporaneamente offline. Le applicazioni inviano, ricevono o visualizzano i messaggi (letti senza rimuovere) dalle code. Accodamento messaggi è un componente facoltativo di Windows 2000 e Windows NT e deve essere installato separatamente.
La MessageQueue classe è un wrapper intorno a Accodamento messaggi. Esistono più versioni di Accodamento messaggi e l'uso della MessageQueue classe può comportare un comportamento leggermente diverso, a seconda del sistema operativo in uso.
La MessageQueue classe fornisce un riferimento a una coda accodamento messaggi. È possibile specificare un percorso nel MessageQueue costruttore per connettersi a una risorsa esistente oppure creare una nuova coda nel server. Prima di poter chiamare Send(Object), Peeko Receive, è necessario associare la nuova istanza della MessageQueue classe a una coda esistente. A questo punto, è possibile modificare le proprietà della coda, Category ad esempio e Label.
MessageQueue supporta due tipi di recupero dei messaggi: sincrono e asincrono. I metodi Peek sincroni e Receive, determinano che il thread del processo attenda un intervallo di tempo specificato per l'arrivo di un nuovo messaggio nella coda. I metodi BeginPeek asincroni e BeginReceive, consentono alle attività principali dell'applicazione di continuare in un thread separato fino all'arrivo di un messaggio nella coda. Questi metodi funzionano usando oggetti di callback e oggetti di stato per comunicare informazioni tra thread.
Quando si crea una nuova istanza della MessageQueue classe , non si crea una nuova coda accodamento messaggi. È invece possibile usare i Create(String)metodi , Delete(String)e Purge per gestire le code nel server.
A differenza di Purge, Create(String) e Delete(String) sono static membri, quindi è possibile chiamarli senza creare una nuova istanza della MessageQueue classe .
È possibile impostare la MessageQueue proprietà dell'oggetto Path con uno dei tre nomi seguenti: il nome descrittivo, l'oggetto FormatNameo .Label Il nome descrittivo, definito dalle proprietà e della MachineName coda, è MachineName\QueueName per una coda pubblica e MachineNameQueueName\\Private$per una coda privata.QueueName La FormatName proprietà consente l'accesso offline alle code dei messaggi. Infine, è possibile usare la proprietà della Label coda per impostare l'oggetto della Pathcoda.
Per un elenco dei valori iniziali delle proprietà per un'istanza di MessageQueue, vedere il MessageQueue costruttore .
Costruttori
| 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, Boolean, Boolean) |
Inizializza una nuova istanza della classe MessageQueue. |
| MessageQueue(String, Boolean, Boolean, QueueAccessMode) |
Inizializza una nuova istanza della classe MessageQueue. |
| MessageQueue(String, QueueAccessMode) |
Inizializza una nuova istanza della classe MessageQueue. |
Campi
| InfiniteQueueSize |
Specifica che non sono previste restrizioni relative alle dimensioni di una coda. |
| InfiniteTimeout |
Specifica che non è previsto un timeout per i metodi che leggono o ricevono messaggi. |
Proprietà
| AccessMode |
Ottiene un valore che indica la modalità di accesso per la coda. |
| Authenticate |
Ottiene o imposta un valore che indica se la coda accetta solo messaggi autenticati. |
| BasePriority |
Ottiene o imposta la priorità di base utilizzata da Accodamento messaggi per effettuare il routing dei messaggi di una coda pubblica sulla rete. |
| CanRaiseEvents |
Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component) |
| CanRead |
Ottiene un valore che indica se è possibile leggere l'oggetto MessageQueue. |
| CanWrite |
Ottiene un valore che indica se è possibile scrivere nell'oggetto MessageQueue. |
| Category |
Ottiene o imposta la categoria della coda. |
| Container |
Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component) |
| CreateTime |
Ottiene la data e l'ora di creazione della coda in Accodamento messaggi. |
| DefaultPropertiesToSend |
Ottiene o imposta i valori di proprietà dei messaggi da utilizzare per impostazione predefinita quando vengono inviati messaggi alla coda dall'applicazione. |
| DenySharedReceive |
Ottiene o imposta un valore che indica se l'oggetto MessageQueue dispone dell'accesso esclusivo per la ricezione dei messaggi dalla coda di Accodamento messaggi. |
| DesignMode |
Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component) |
| EnableConnectionCache |
Ottiene o imposta un valore che indica se l'applicazione gestirà una cache di connessioni. |
| EncryptionRequired |
Ottiene o imposta un valore che indica se la coda accetta solo messaggi non privati (non crittografati). |
| Events |
Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component) |
| FormatName |
Ottiene il nome univoco generato per la coda da Accodamento messaggi al momento della creazione della coda. |
| Formatter |
Ottiene o imposta il formattatore utilizzato per serializzare o deserializzare un oggetto dal corpo di un messaggio letto o scritto in una coda. |
| Id |
Ottiene l'identificatore univoco di Accodamento messaggi per la coda. |
| Label |
Ottiene o imposta la descrizione della coda. |
| LastModifyTime |
Ottiene la data e l'ora dell'ultima modifica delle proprietà di una coda. |
| MachineName |
Ottiene o imposta il nome del computer in cui si trova la coda di Accodamento messaggi. |
| MaximumJournalSize |
Ottiene o imposta la dimensione massima della coda del giornale di registrazione. |
| MaximumQueueSize |
Ottiene o imposta la dimensione massima della coda. |
| MessageReadPropertyFilter |
Ottiene o imposta il filtro di proprietà per la ricezione o la visualizzazione dei messaggi. |
| MulticastAddress |
Introdotto in MSMQ 3.0. Ottiene o imposta l'indirizzo multicast associato alla coda. |
| Path |
Ottiene o imposta il percorso della coda. Impostando la proprietà Path, MessageQueue punta a una nuova coda. |
| QueueName |
Ottiene o imposta il nome descrittivo che identifica la coda. |
| ReadHandle |
Ottiene l'handle nativo utilizzato per leggere i messaggi dalla coda di messaggi. |
| Site |
Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component) |
| SynchronizingObject |
Ottiene o imposta l'oggetto utilizzato per effettuare il marshalling della chiamata al gestore eventi risultante da un evento ReceiveCompleted o PeekCompleted. |
| Transactional |
Ottiene un valore che indica se la coda accetta solo transazioni. |
| UseJournalQueue |
Ottiene o imposta un valore che indica se i messaggi ricevuti vengono copiati nella coda del giornale di registrazione. |
| WriteHandle |
Ottiene l'handle nativo utilizzato per inviare messaggi alla coda di messaggi. |
Metodi
| BeginPeek() |
Avvia un'operazione di visualizzazione in anteprima asincrona senza timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda. |
| BeginPeek(TimeSpan) |
Avvia un'operazione di visualizzazione in anteprima asincrona con un timeout specificato. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback) |
Avvia un'operazione di lettura asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginPeek(TimeSpan, Object) |
Avvia un'operazione di lettura asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginPeek(TimeSpan, Object, AsyncCallback) |
Avvia un'operazione di lettura asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginReceive() |
Avvia un'operazione di ricezione asincrona senza timeout. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda. |
| BeginReceive(TimeSpan) |
Avvia un'operazione di ricezione asincrona con timeout specificato. L'operazione non viene completata finché un messaggio non diventa disponibile nella coda o si verifica il timeout. |
| BeginReceive(TimeSpan, Cursor, Object, AsyncCallback) |
Avvia un'operazione di ricezione asincrona che presenta il timeout specificato e che utilizza il cursore specificato, l'azione di lettura specificata e l'oggetto di stato specificato. L'oggetto di stato fornisce informazioni associate per l'intera durata dell'operazione. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginReceive(TimeSpan, Object) |
Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| BeginReceive(TimeSpan, Object, AsyncCallback) |
Avvia un'operazione di ricezione asincrona per la quale sono stati specificati un timeout e un oggetto di stato, che fornisce le informazioni associate per tutta la durata dell'operazione. Questo overload riceve mediante un callback la notifica dell'identità del gestore eventi per l'operazione. L'operazione non è completa fino a quando un messaggio non viene reso disponibile nella coda o non si verifica il timeout. |
| ClearConnectionCache() |
Svuota la cache delle connessioni. |
| Close() |
Libera tutte le risorse allocate da MessageQueue. |
| Create(String) |
Crea una coda non transazionale di Accodamento messaggi nel percorso specificato. |
| Create(String, Boolean) |
Crea una coda transazionale o non transazionale di Accodamento messaggi nel percorso specificato. |
| CreateCursor() |
Crea un nuovo oggetto Cursor per la coda messaggi corrente. |
| CreateObjRef(Type) |
Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject) |
| Delete(String) |
Elimina una coda su un server di Accodamento messaggi. |
| Dispose() |
Rilascia tutte le risorse usate da Component. (Ereditato da Component) |
| Dispose(Boolean) |
Elimina le risorse, diverse dalla memoria, usate dall'oggetto MessageQueue. |
| EndPeek(IAsyncResult) |
Completa l'operazione di visualizzazione asincrona specificata. |
| EndReceive(IAsyncResult) |
Completa l'operazione di ricezione asincrona specificata. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| Exists(String) |
Determina se una coda di Accodamento messaggi è presente nel percorso specificato. |
| GetAllMessages() |
Restituisce tutti i messaggi presenti nella coda. |
| GetEnumerator() |
Obsoleti.
Enumera i messaggi in una coda. L'oggetto GetEnumerator() è deprecato. È consigliabile utilizzare invece GetMessageEnumerator2(). |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetLifetimeService() |
Obsoleti.
Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject) |
| GetMachineId(String) |
Ottiene l'identificatore del computer in cui viene posizionata la coda cui MessageQueue fa riferimento. |
| GetMessageEnumerator() |
Obsoleti.
Crea un oggetto enumeratore per tutti i messaggi contenuti nella coda. L'oggetto GetMessageEnumerator() è deprecato. È consigliabile utilizzare invece GetMessageEnumerator2(). |
| GetMessageEnumerator2() |
Crea un oggetto enumeratore per tutti i messaggi contenuti nella coda. |
| GetMessageQueueEnumerator() |
Fornisce la semantica del cursore forward-only per enumerare tutte le code pubbliche sulla rete. |
| GetMessageQueueEnumerator(MessageQueueCriteria) |
Fornisce la semantica del cursore forward-only per enumerare tutte le code pubbliche sulla rete che soddisfano i criteri specificati. |
| GetPrivateQueuesByMachine(String) |
Recupera tutte le code private sul computer specificato. |
| GetPublicQueues() |
Recupera tutte le code pubbliche sulla rete. |
| GetPublicQueues(MessageQueueCriteria) |
Recupera tutte le code pubbliche sulla rete che soddisfano i criteri specificati. |
| GetPublicQueuesByCategory(Guid) |
Recupera tutte le code pubbliche sulla rete appartenenti alla categoria specificata. |
| GetPublicQueuesByLabel(String) |
Recupera tutte le code pubbliche sulla rete contenenti l'etichetta specificata. |
| GetPublicQueuesByMachine(String) |
Recupera tutte le code pubbliche che risiedono sul computer specificato. |
| GetSecurityContext() |
Recupera il contesto di sicurezza che MSMQ associa all'utente corrente (identità del thread) nel momento in cui viene eseguita questa chiamata. |
| GetService(Type) |
Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component) |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| InitializeLifetimeService() |
Obsoleti.
Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject) |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| MemberwiseClone(Boolean) |
Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject) |
| Peek() |
Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio. |
| Peek(TimeSpan) |
Termina senza rimuovere (legge) il primo messaggio nella coda a cui l'oggetto MessageQueue fa riferimento. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato. |
| Peek(TimeSpan, Cursor, PeekAction) |
Termina senza rimuovere (legge) il messaggio corrente o successivo della coda, utilizzando il cursore specificato. Poiché il metodo Peek() è sincrono, blocca il thread corrente finché non viene reso disponibile un messaggio o non si verifica il timeout specificato. |
| PeekByCorrelationId(String) |
Legge il messaggio che corrisponde all'identificatore di correlazione specificato e, se nella coda non è disponibile correntemente alcun messaggio con l'identificatore di correlazione specificato, genererà immediatamente un'eccezione. |
| PeekByCorrelationId(String, TimeSpan) |
Legge il messaggio che corrisponde all'identificatore di correlazione specificato e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda o che il timeout scada. |
| PeekById(String) |
Legge il messaggio il cui identificatore corrisponde al parametro |
| PeekById(String, TimeSpan) |
Legge il messaggio il cui identificatore corrisponde al parametro |
| PeekByLookupId(Int64) |
Introdotto in MSMQ 3.0. Legge il messaggio che corrisponde all'identificatore di ricerca specificato da una coda non transazionale. |
| PeekByLookupId(MessageLookupAction, Int64) |
Introdotto in MSMQ 3.0. Legge un messaggio specifico nella coda. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda. |
| Purge() |
Elimina tutti i messaggi contenuti nella coda. |
| Receive() |
Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio. |
| Receive(MessageQueueTransaction) |
Riceve il primo messaggio disponibile nella coda transazionale a cui MessageQueue fa riferimento. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio. |
| Receive(MessageQueueTransactionType) |
Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento. Questa chiamata è sincrona e blocca il thread corrente di esecuzione finché non è disponibile un messaggio. |
| Receive(TimeSpan) |
Riceve il primo messaggio disponibile nella coda cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada. |
| Receive(TimeSpan, Cursor) |
Riceve il messaggio corrente nella coda, utilizzando il cursore specificato. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout. |
| Receive(TimeSpan, Cursor, MessageQueueTransaction) |
Riceve il messaggio corrente nella coda, utilizzando il cursore specificato. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout. |
| Receive(TimeSpan, Cursor, MessageQueueTransactionType) |
Riceve il messaggio corrente nella coda, utilizzando il cursore specificato. Se non è disponibile alcun messaggio, il metodo aspetta finché non risulta disponibile un messaggio o finché non scade il periodo di timeout. |
| Receive(TimeSpan, MessageQueueTransaction) |
Riceve il primo messaggio disponibile nella coda transazionale cui l'oggetto MessageQueue fa riferimento e attende che un messaggio sia disponibile nella coda o che il timeout scada. |
| Receive(TimeSpan, MessageQueueTransactionType) |
Riceve il primo messaggio disponibile nella coda a cui MessageQueue fa riferimento. Questa chiamata è sincrona e attende che un messaggio venga reso disponibile nella coda o il timeout scada. |
| ReceiveByCorrelationId(String) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda non transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato. |
| ReceiveByCorrelationId(String, MessageQueueTransaction) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato. |
| ReceiveByCorrelationId(String, MessageQueueTransactionType) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore di correlazione specificato. |
| ReceiveByCorrelationId(String, TimeSpan) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda non transazionale) e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda oppure che il timeout scada. |
| ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato (da una coda transazionale) e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda oppure che il timeout scada. |
| ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType) |
Riceve il messaggio che corrisponde all'identificatore di correlazione specificato e attende che un messaggio con l'identificatore di correlazione specificato sia disponibile nella coda o che il timeout scada. |
| ReceiveById(String) |
Riceve il messaggio che corrisponde all'identificatore specificato da una coda non transazionale e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato. |
| ReceiveById(String, MessageQueueTransaction) |
Riceve il messaggio che corrisponde all'identificatore specificato (da una coda transazionale) e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato. |
| ReceiveById(String, MessageQueueTransactionType) |
Riceve il messaggio corrispondente all'identificatore specificato e genera subito un'eccezione se nella coda non è disponibile alcun messaggio con l'identificatore specificato. |
| ReceiveById(String, TimeSpan) |
Riceve il messaggio corrispondente all'identificatore specificato (da una coda non transazionale) e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada. |
| ReceiveById(String, TimeSpan, MessageQueueTransaction) |
Riceve il messaggio corrispondente all'identificatore specificato (da una coda transazionale) e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada. |
| ReceiveById(String, TimeSpan, MessageQueueTransactionType) |
Riceve il messaggio che corrisponde all'identificatore specificato e attende che un messaggio con l'identificatore specificato sia disponibile nella coda o che il timeout scada. |
| ReceiveByLookupId(Int64) |
Introdotto in MSMQ 3.0. Riceve il messaggio che corrisponde all'identificatore di ricerca specificato da una coda non transazionale. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction) |
Introdotto in MSMQ 3.0. Riceve un messaggio specifico da una coda transazionale. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda. |
| ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType) |
Introdotto in MSMQ 3.0. Riceve un messaggio specifico della coda, utilizzando il contesto di transazione specificato. Il messaggio può essere specificato da un identificatore di ricerca o in base alla relativa posizione all'inizio o alla fine della coda. |
| Refresh() |
Aggiorna le proprietà presentate da MessageQueue per riflettere lo stato corrente della risorsa. |
| ResetPermissions() |
Reimposta l'elenco delle autorizzazioni sui valori predefiniti del sistema operativo. Rimuove tutte le autorizzazioni relative alla coda aggiunte all'elenco predefinito. |
| Send(Object) |
Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento. |
| Send(Object, MessageQueueTransaction) |
Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento. |
| Send(Object, MessageQueueTransactionType) |
Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento. |
| Send(Object, String) |
Invia un oggetto alla coda non transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio. |
| Send(Object, String, MessageQueueTransaction) |
Invia un oggetto alla coda transazionale a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio. |
| Send(Object, String, MessageQueueTransactionType) |
Invia un oggetto alla coda a cui l'oggetto MessageQueue fa riferimento e specifica un'etichetta per il messaggio. |
| SetPermissions(AccessControlList) |
Assegna i diritti di accesso alla coda in base al contenuto di un elenco di controllo di accesso. |
| SetPermissions(MessageQueueAccessControlEntry) |
Assegna i diritti di accesso alla coda in base al contenuto di una voce di controllo di accesso. |
| SetPermissions(String, MessageQueueAccessRights) |
Fornisce a un computer, a un gruppo o a un utente i diritti di accesso specificati. |
| SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType) |
Concede a un computer, a un utente o a un gruppo di utenti i diritti di accesso specificati con il tipo di controllo di accesso specificato (concessione, rifiuto, revoca o impostazione). |
| ToString() |
Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override. (Ereditato da Component) |
Eventi
| Disposed |
Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component) |
| PeekCompleted |
Viene generato quando un messaggio viene letto senza essere rimosso dalla coda. Si tratta del risultato dell'operazione asincrona BeginPeek(). |
| ReceiveCompleted |
Viene generato quando un messaggio è stato rimosso dalla coda. Questo evento viene generato dall'operazione asincrona BeginReceive(). |
Metodi di estensione
| Cast<TResult>(IEnumerable) |
Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato. |
| OfType<TResult>(IEnumerable) |
Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato. |
| AsParallel(IEnumerable) |
Consente la parallelizzazione di una query. |
| AsQueryable(IEnumerable) |
Converte un oggetto IEnumerable in un oggetto IQueryable. |
Si applica a
Thread safety
Solo il GetAllMessages() metodo è thread-safe.
Vedi anche
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per