Al momento sei offline in attesa che la connessione Internet venga ristabilita

Procedura: chiamare un metodo C# in modo asincrono

IMPORTANTE: il presente articolo è stato tradotto tramite un software di traduzione automatica di Microsoft ed eventualmente revisionato dalla community Microsoft tramite la tecnologia CTF (Community Translation Framework) o da un traduttore professionista. Microsoft offre articoli tradotti manualmente e altri tradotti automaticamente e rivisti dalla community con l’obiettivo di consentire all'utente di accedere a tutti gli articoli della Knowledge Base nella propria lingua. Tuttavia, un articolo tradotto automaticamente, anche se rivisto dalla community, non sempre è perfetto. Potrebbe contenere errori di vocabolario, di sintassi o di grammatica. Microsoft declina ogni responsabilità per imprecisioni, errori o danni causati da una traduzione sbagliata o dal relativo utilizzo da parte dei clienti. Microsoft aggiorna frequentemente il software e gli strumenti di traduzione automatica per continuare a migliorare la qualità della traduzione.

Clicca qui per visualizzare la versione originale in inglese dell’articolo: 315582
Sommario
Il.NET Framework di Microsoft semplifica la chiamata di funzioni in modo asincrono. La chiamata di funzioni in modo asincrono, il sistema per l'esecuzione in background su un thread secondario mentre la funzione chiamante continua a eseguire altre operazioni. In una chiamata di funzione (sincrono) tipico, la funzione viene eseguita immediatamente sullo stesso thread che ha effettuato la chiamata. La funzione chiamante attende il completamento della chiamata e riceve i risultati della chiamata prima di continuare. Al contrario, quando si effettua una chiamata asincrona, recuperare i risultati della chiamata asincrona in un secondo momento. In questo articolo viene illustrato come eseguire questa operazione utilizzando Visual C#.

back to the top

Requisiti


Nell'elenco seguente vengono indicati l'hardware consigliato, software, infrastruttura di rete e i service pack necessari:
  • Microsoft Windows 2000 o Microsoft Windows XP o Microsoft Windows Server 2003
  • Visual Studio .NET o Visual Studio 2005
In questo articolo si presuppone che si abbia familiarità con i seguenti argomenti:
  • Chiamata di metodi in Visual C#
  • Utilizzo di delegati
back to the top

Come effettuare chiamate asincrone

Chiamate asincrone vengono effettuate tramite delegati. Un delegato è un oggetto che esegue il wrapping di una funzione. I delegati forniscono una funzione sincrona e forniscono metodi per chiamare la funzione wrapper in modo asincrono. Tali metodi sono BeginInvoke() ed EndInvoke(). Elenchi di parametri di questi metodi variano a seconda della firma della funzione che esegue il wrapping del delegato. Si noti che la funzionalità di Visual Studio .NET IntelliSense non visualizza BeginInvoke() ed EndInvoke(), in modo che non ne vengono visualizzati negli elenchi di funzione durante la digitazione.

BeginInvoke() viene utilizzato per avviare la chiamata asincrona. E presenta gli stessi parametri della funzione di capo, oltre a due parametri aggiuntivi che verranno descritti più avanti in questo articolo. BeginInvoke() restituisce immediatamente e senza attendere il completamento della chiamata asincrona. BeginInvoke() restituisce un oggetto IAsyncResult .

La funzione EndInvoke() viene utilizzata per recuperare i risultati della chiamata asincrona. Può essere chiamato in qualsiasi momento dopo BeginInvoke(). Se la chiamata asincrona non è ancora completata, EndInvoke() blocchi fino al completamento. I parametri della funzione EndInvoke() include il out e ref parametri che ha la funzione di capo, nonché l'oggetto IAsyncResult restituito da BeginInvoke().

Di seguito è riportato un esempio di un delegato e i metodi BeginInvoke() ed EndInvoke() :
// The following delegate delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;// will have the following BeginInvoke() and EndInvoke methods:IAsyncResult MethodDelegate.BeginInvoke(int iCallTime, out int iExecThread, AsyncCallback cb, object AsyncState); string MethodDelegate.EndInvoke (out int iExecThread, IAsyncResult ar) ;				
Esistono quattro modi comuni di utilizzare BeginInvoke() ed EndInvoke() per effettuare chiamate asincrone. Dopo aver chiamato BeginInvoke(), è possibile:
  • Facoltativamente fare altre operazioni, quindi utilizzare EndInvoke().
  • Ottenere un WaitHandle fornito dall'oggetto IAsyncResult , utilizzare il metodo WaitOne per bloccare fino a quando il WaitHandle viene segnalato e quindi chiamare EndInvoke().
  • Effettuare il polling dell'oggetto IAsyncResult per determinare quando la chiamata asincrona è completata, chiamata andthen EndInvoke().
  • Che il sistema chiama una funzione di callback specificato. Questa funzione di callback chiama EndInvoke() e processi i risultati di asincrona chiamare quando si itcompletes.
Gli esempi di codice seguenti dimostrano questi modelli di chiamare e li differenzia effettua una chiamata sincrona utilizzando la seguente funzione:
string LongRunningMethod (int iCallTime, out int iExecThread){	Thread.Sleep (iCallTime) ;	iExecThread = AppDomain.GetCurrentThreadId ();	return "MyCallTime was " + iCallTime.ToString() ;}				
LongRunningMethod() simula una funzione che viene eseguito per molto tempo per la sospensione. Restituisce il periodo di inattività e l'ID del thread che viene eseguito. Se si chiama in modo asincrono, si noterà che l'ID del thread del thread in esecuzione è diverso da quello del thread chiamante.

Il primo passaggio consiste nel definire il delegato che esegue il wrapping della funzione:
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;				

Esempio 1: Chiamata a un metodo in modo sincrono

In questo esempio viene illustrato come chiamare LongRunningMethod() in modo sincrono utilizzando un delegato di MethodDelegate . Altri esempi diversamente effettuando chiamate in modo asincrono.
  1. Avviare Microsoft Visual Studio .NET o Microsoft Visual Studio 2005.
  2. Creare un nuovo namedAsyncDemo progetto applicazione Console Visual C#.
  3. Aggiungere una classe denominata AsyncDemo definito come indicato di seguito al progetto in un nuovo file cs:
    using System;using System.Threading ; using System.Windows.Forms ;public class AsyncDemo{	string LongRunningMethod (int iCallTime, out int iExecThread)	{		Thread.Sleep (iCallTime) ;		iExecThread = AppDomain.GetCurrentThreadId ();		return "MyCallTime was " + iCallTime.ToString() ;	}	delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;	public void DemoSyncCall()	{		string s ;		int iExecThread;		// Create an instance of a delegate that wraps LongRunningMethod.		MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;  					// Call LongRunningMethod using the delegate.		s = dlgt(3000, out iExecThread);  					MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\",                                         and the thread ID {1}", s, iExecThread.ToString() ) );	}}					
    Successivamente, questa classe viene illustrato come effettuare chiamate asincrone. Inizialmente, tuttavia, contiene solo il metodo DemoSyncCall() , che viene illustrato come chiamare il delegatesynchronously.
  4. Aggiungere il seguente codice nel corpo della funzione Main che Visual Studio crea automaticamente nel progetto:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoSyncCall() ;}					
  5. Premere CTRL + F5 per eseguire l'applicazione.
back to the top

Esempio 2: Chiamare un metodo in modo asincrono utilizzando il modello di chiamata EndInvoke()

In questa sezione, il codice di esempio richiama in modo asincrono lo stesso metodo. Il modello di chiamata utilizzato consiste nel chiamare BeginInvoke, eseguire alcune operazioni sul thread principale e quindi chiamare EndInvoke(). Si noti che EndInvoke() non fino al completamento della chiamata asincrona. Questo modello di chiamata è utile quando si desidera che il thread chiamante funzionano allo stesso tempo che sta eseguendo la chiamata asincrona. Visto lavoro si verificano contemporaneamente, è possibile migliorare le prestazioni di molte applicazioni. Attività comuni da eseguire in modo asincrono in questo modo sono operazioni di file o di rete.
  1. Aggiungere un metodo denominato DemoEndInvoke() alla classe AsyncDemo . La funzione DemoEndInvoke viene illustrato come chiamare il delegato in modo asincrono.
    public void DemoEndInvoke(){	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;	string s ;	int iExecThread;	// Initiate the asynchronous call.	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null);  	// Do some useful work here. This would be work you want to have	// run at the same time as the asynchronous call.	// Retrieve the results of the asynchronous call.	s = dlgt.EndInvoke (out iExecThread, ar) ;  	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\",                                and the number {1}", s, iExecThread.ToString() ) );}					
  2. Modificare il codice sorgente per Main in modo che contenga il seguente codice:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoEndInvoke() ;}					
  3. Premere CTRL + F5 per eseguire l'applicazione.
back to the top

Esempio 3: Chiamare un metodo in modo asincrono e utilizzando una classe WaitHandle per attendere la chiamata per completare


In questa sezione, l'esempio chiama il metodo in modo asincrono e attende un WaitHandle prima di chiamare EndInvoke(). IAsyncResult restituito da BeginInvoke() ha una proprietà AsyncWaitHandle . Questa proprietà restituisce un WaitHandle che viene segnalato al completamento della chiamata asincrona. In attesa di un WaitHandle è una tecnica di sincronizzazione di thread comuni. Il thread chiamante attende il WaitHandle utilizzando il metodo WaitOne () di WaitHandle. WaitOne () si blocca fino a quando il WaitHandle viene segnalato. Quando restituisce WaitOne () , è possibile eseguire operazioni aggiuntive prima di chiamare EndInvoke(). Come nell'esempio precedente, questa tecnica è utile per eseguire le operazioni di file o di rete che bloccano il thread chiamante principale in caso contrario.
  1. Aggiungere una funzione denominata DemoWaitHandle() alla classe AsyncDemo . La funzione DemoWaitHandle() viene illustrato come chiamare il delegato in modo asincrono.
    public void DemoWaitHandle (){	string s ;	int iExecThread;	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;	// Initiate the asynchronous call.	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null); 	// Do some useful work here. This would be work you want to have	// run at the same time as the asynchronous call.	// Wait for the WaitHandle to become signaled.	ar.AsyncWaitHandle.WaitOne() ;	// Get the results of the asynchronous call.	s = dlgt.EndInvoke (out iExecThread, ar) ;				MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\",                                  and the number {1}", s, iExecThread.ToString() ) );}					
  2. Modificare il codice sorgente per Main in modo che contenga il seguente codice:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoWaitHandle () ;}					
  3. Premere CTRL + F5 per eseguire l'applicazione.
back to the top

Esempio 4: Chiamare un metodo in modo asincrono utilizzando il modello di chiamata di Polling

In questa sezione, il codice di esempio esegue il polling dell'oggetto IAsyncResult per scoprire quando la chiamata asincrona è stata completata. L'oggetto IAsyncResult restituito da BeginInvoke() ha una proprietà IsCompleted restituisce True dopo il completamento della chiamata asincrona. È quindi possibile chiamare EndInvoke(). Questo modello di chiamata è utile se l'applicazione funziona in corso che si desidera sono bloccati da una chiamata di funzione a esecuzione prolungata. Un'applicazione di Microsoft Windows è un esempio. Il thread principale dell'applicazione Windows è possibile continuare a gestire l'input dell'utente durante l'esecuzione di una chiamata asincrona. È possibile verificare periodicamente IsCompleted per vedere se la chiamata è stata completata. Chiama EndInvoke quando IsCompleted restituisce True. Poiché EndInvoke() blocca fino al completamento dell'operazione asincrona, l'applicazione non chiamare questo metodo fino a quando non sa che l'operazione è stata completata.
  1. Aggiungere una funzione denominata DemoPolling() alla classe AsyncDemo . La funzione DemoPolling() viene illustrato come chiamare il delegato in modo asincrono anduse polling per verificare se il processo è completo.
    public void DemoPolling(){	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;	string s ;	int iExecThread;	// Initiate the asynchronous call.	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null); 	// Poll IAsyncResult.IsCompleted	while(ar.IsCompleted == false)	{		Thread.Sleep (10) ;  // pretend to so some useful work	}	s = dlgt.EndInvoke (out iExecThread, ar) ;	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\",                                 and the number {1}", s, iExecThread.ToString() ) );}					
  2. Modificare il codice sorgente per Main. Sostituire il contenuto della funzione con il codice riportato di seguito:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoPolling () ;}					
  3. Premere CTRL + F5 per eseguire l'applicazione.
back to the top

Esempio 5: Esecuzione di un Callback al completamento di un metodo asincrono

In questa sezione vengono forniti un delegato di callback alla funzione BeginInvoke() che il sistema viene eseguito quando la chiamata asincrona viene completata. Il callback chiama EndInvoke() ed elabora i risultati della chiamata asincrona. Questo modello di chiamata è utile se non è necessario elaborare i risultati della chiamata al thread che avvia la chiamata asincrona. Il sistema richiama il callback in un thread diverso da quello iniziale quando la chiamata asincrona viene completata.

Per utilizzare questo modello di chiamata, è necessario passare un delegato di tipo AsyncCallback come penultimo secondo parametro della funzione BeginInvoke() . BeginInvoke() ha inoltre un parametro finale del tipo oggetto in cui è possibile passare qualsiasi oggetto. Questo oggetto è disponibile per la funzione di callback quando viene richiamato. È possibile utilizzare questo parametro importante consiste nel passare il delegato utilizzato per avviare la chiamata. La funzione di callback può quindi utilizzare la funzione EndInvoke() di tale delegato per completare la chiamata. Questo modello di chiamata è illustrato di seguito.
  1. Aggiungere due metodi denominati DemoCallback() e MyAsyncCallback() alla classe AsyncDemo . Il metodo DemoCallback() di seguito viene illustrato come chiamare il delegato in modo asincrono. Un delegato per eseguire il wrapping del metodo MyAsyncCallback() , che viene chiamato quando il sistema di Ituses di operationcompletes asincrona. MyAsyncCallback() chiama EndInvoke().
    public void DemoCallback(){	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;	string s ;	int iExecThread;	// Create the callback delegate.	AsyncCallback cb = new AsyncCallback(MyAsyncCallback);	// Initiate the Asynchronous call passing in the callback delegate	// and the delegate object used to initiate the call.	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, cb, dlgt); }public void MyAsyncCallback(IAsyncResult ar){	string s ;	int iExecThread ;	// Because you passed your original delegate in the asyncState parameter	// of the Begin call, you can get it back here to complete the call.	MethodDelegate dlgt = (MethodDelegate) ar.AsyncState;	// Complete the call.	s = dlgt.EndInvoke (out iExecThread, ar) ;	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\",                                 and the number {1}", s, iExecThread.ToString() ) );}					
  2. Modificare il codice sorgente per Main. Sostituire il contenuto della funzione con il codice riportato di seguito:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoCallback() ;}					
  3. Premere CTRL + F5 per eseguire l'applicazione.
back to the top

Avviso: questo articolo è stato tradotto automaticamente

Proprietà

ID articolo: 315582 - Ultima revisione: 03/23/2016 00:51:00 - Revisione: 5.0

Microsoft Visual Studio .NET 2002 Professional Edition, Microsoft Visual C# .NET 2002 Standard Edition, Microsoft Visual C# 2005 Express Edition

  • kbhowtomaster kbmt KB315582 KbMtit
Feedback