Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo MessageQueue.BeginPeek (TimeSpan, Object)

 

Data di pubblicazione: ottobre 2016

Avvia un'operazione di lettura asincrona con un timeout specificato e un oggetto di stato, che fornisce informazioni per l'intera durata dell'operazione. L'operazione non è completa fino a quando un messaggio diventa disponibile nella coda o si verifica il timeout.

Spazio dei nomi:   System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public IAsyncResult BeginPeek(
	TimeSpan timeout,
	object stateObject
)

Parametri

timeout
Type: System.TimeSpan

Oggetto TimeSpan che indica l'intervallo di tempo di attesa per un messaggio diventi disponibile.

stateObject
Type: System.Object

Un oggetto di stato, specificato dall'applicazione, che contiene le informazioni associate all'operazione asincrona.

Valore restituito

Type: System.IAsyncResult

Il IAsyncResult che identifica la richiesta asincrona inviata.

Exception Condition
ArgumentException

Il valore specificato per il timeout parametro non è valido.

MessageQueueException

Si è verificato un errore quando si accede a un metodo di Accodamento messaggi.

.NET Framework
Disponibile da 1.1

Il metodo non è thread-safe.

Nell'elaborazione asincrona, utilizzare BeginPeek per generare il PeekCompleted evento quando un messaggio diventa disponibile nella coda o quando l'intervallo di tempo specificato è scaduto.

PeekCompleted viene generato anche se esiste già un messaggio nella coda.

Utilizzare questo overload per associare le informazioni con l'operazione che verrà mantenuta per tutta la durata dell'operazione. Il gestore eventi può accedere a queste informazioni esaminando la AsyncState proprietà del IAsyncResult che viene associato all'operazione.

Utilizzare BeginPeek, creare un gestore eventi che elabora i risultati dell'operazione asincrona e associarlo al delegato dell'evento. BeginPeek Avvia un'operazione di lettura asincrona. il MessageQueue viene informato, tramite la generazione del PeekCompleted evento, se un messaggio arriva nella coda. Il MessageQueue può quindi accedere al messaggio chiamando EndPeek(IAsyncResult) o recuperando il risultato mediante la PeekCompletedEventArgs.

Il BeginPeek metodo termina immediatamente, ma l'operazione asincrona non viene completata finché non viene chiamato il gestore dell'evento.

Poiché BeginPeek è asincrona, è possibile chiamare questo metodo per leggere la coda senza bloccare il thread di esecuzione corrente. Per leggere in modo sincrono la coda, utilizzare il Peek metodo.

Al termine dell'operazione asincrona, è possibile chiamare BeginPeek o BeginReceive nuovamente nel gestore eventi per continuare a ricevere le notifiche.

BeginPeek Restituisce un IAsyncResult che identifica l'operazione asincrona avviata dal metodo. È possibile utilizzare questo IAsyncResult tutta la durata dell'operazione, sebbene in genere non si utilizza solo EndPeek(IAsyncResult) viene chiamato. Tuttavia, se si avviano più operazioni asincrone, è possibile posizionare i IAsyncResult valori in una matrice e specificare se attendere il completamento o tutte le operazioni. In questo caso, utilizzare il AsyncWaitHandle di proprietà di IAsyncResult per identificare l'operazione completata.

Questo overload specifica un timeout e un oggetto di stato. Se l'intervallo specificato per il timeout parametro scade, questo componente genera il PeekCompleted evento. Poiché è disponibile alcun messaggio, una chiamata successiva a EndPeek(IAsyncResult) genererà un'eccezione.

L'oggetto di stato associa le informazioni sullo stato dell'operazione. Ad esempio, se si chiama BeginPeek più volte per avviare più operazioni, è possibile identificare ogni operazione mediante un oggetto di stato separato definiti. Per un'illustrazione di questo scenario, vedere la sezione esempio.

È inoltre possibile utilizzare l'oggetto di stato per passare informazioni attraverso i thread del processo. Se viene avviato un thread, ma il callback è su un thread diverso in uno scenario asincrono, l'oggetto stato è il marshalling e passato insieme alle informazioni relative all'evento.

Se CanRead è false, viene generato l'evento di completamento, ma verrà generata un'eccezione quando si chiama EndPeek(IAsyncResult).

Nella tabella seguente indica se questo metodo è disponibile in diverse modalità gruppo di lavoro.

Modalità gruppo di lavoro

Disponibile

Computer locale

Computer locale e il nome di formato direct

Computer remoto

No

Computer remoto e il nome di formato direct

L'esempio di codice seguente crea un'operazione di lettura asincrona, utilizzando il percorso della coda ". \myQueue". Crea un gestore eventi, MyPeekCompleted, e lo collega al PeekCompleted delegato del gestore eventi. BeginPeek viene chiamato con un timeout di un minuto. Ogni chiamata a BeginPeek è associato un intero univoco che identifica la specifica operazione. Quando un PeekCompleted viene generato l'evento o della scadenza del timeout, viene recuperato il messaggio, se presente, e il relativo corpo e l'identificatore di tipo integer specifici dell'operazione vengono scritti nella schermata. Quindi BeginPeek viene nuovamente chiamata per avviare una nuova operazione di lettura asincrona con lo stesso timeout e l'intero associato dell'operazione appena completata.

using System;
using System.Messaging;

namespace MyProject
{
	/// <summary>
	/// Provides a container class for the example.
	/// </summary>
	public class MyNewQueue
	{
		// Represents a state object associated with each message.
		static int messageNumber = 0;

		//**************************************************
		// Provides an entry point into the application.
		//		 
		// This example performs asynchronous peek operation
		// processing.
		//**************************************************

		public static void Main()
		{
			// Create an instance of MessageQueue. Set its formatter.
			MessageQueue myQueue = new MessageQueue(".\\myQueue");
			myQueue.Formatter = new XmlMessageFormatter(new Type[]
				{typeof(String)});

			// Add an event handler for the PeekCompleted event.
			myQueue.PeekCompleted += new 
				PeekCompletedEventHandler(MyPeekCompleted);

			// Begin the asynchronous peek operation with a time-out 
			// of one minute.
			myQueue.BeginPeek(new TimeSpan(0,1,0), messageNumber++);

			// Do other work on the current thread.

			return;
		}


		//**************************************************
		// Provides an event handler for the PeekCompleted
		// event.
		//**************************************************

		private static void MyPeekCompleted(Object source, 
			PeekCompletedEventArgs asyncResult)
		{
			try
			{
				// Connect to the queue.
				MessageQueue mq = (MessageQueue)source;

				// End the asynchronous peek operation.
				Message m = mq.EndPeek(asyncResult.AsyncResult);

				// Display message information on the screen, 
				// including the message number (state object).
				Console.WriteLine("Message: " + 
					(int)asyncResult.AsyncResult.AsyncState + " " 
					+(string)m.Body);

				// Restart the asynchronous peek operation, with the 
				// same time-out.
				mq.BeginPeek(new TimeSpan(0,1,0), messageNumber++);

			}

			catch(MessageQueueException e)
			{
				if (e.MessageQueueErrorCode == 
					MessageQueueErrorCode.IOTimeout)
				{
					Console.WriteLine(e.ToString());
				}

				// Handle other sources of MessageQueueException.
			}

			// Handle other exceptions.

			return; 
		}
	}
}
Torna all'inizio
Mostra: