Come chiamare un metodo C# in modo asincrono

Traduzione articoli Traduzione articoli
Identificativo articolo: 315582 - Visualizza i prodotti a cui si riferisce l?articolo.
Espandi tutto | Chiudi tutto

In questa pagina

Sommario

Microsoft .NET Framework semplifica le operazioni chiamare le funzioni in modo asincrono. Chiamare le funzioni in modo asincrono, il sistema eseguire in background su un thread secondario mentre la funzione chiamante continua a eseguire altre operazioni. In una chiamata di funzione (sincrono) tipica, la funzione viene eseguita immediatamente sullo stesso thread che ha effettuato la chiamata. La funzione chiamante attende il completamento di 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 effettuare questa operazione utilizzando C#.

Requisiti


Nell'elenco seguente sono indicati hardware, 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 presume la conoscenza dei seguenti argomenti:
  • Chiamata di metodi in Visual C#
  • L'utilizzo di delegati

Come effettuare chiamate asincrone

Chiamate asincrone vengono apportate utilizzando i delegati. Un delegato Ŕ un oggetto che include una funzione. I delegati forniscono una funzione sincrona e forniscono inoltre metodi per chiamare la funzione di cui Ŕ stato eseguito il wrapping in modo asincrono. Questi metodi sono BeginInvoke() e EndInvoke() . Gli elenchi di parametri di questi metodi variano a seconda della firma della funzione che esegue il wrapping il delegato. Si noti che Visual Studio BeginInvoke() e EndInvoke() non visualizzati funzionalitÓ .NET IntelliSense, in modo da non visualizzare vengono visualizzati nella funzione elenchi durante la digitazione.

BeginInvoke() viene utilizzato per avviare la chiamata asincrona. Contiene gli stessi parametri della funzione in cui Ŕ stato eseguito il wrapping, oltre a due parametri aggiuntivi che verranno descritti pi¨ avanti in questo articolo. BeginInvoke() restituisce immediatamente e non attende che la chiamata asincrona per il completamento. BeginInvoke() restituisce un oggetto IAsyncResult .

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

Di seguito Ŕ riportato un esempio di un delegato e i metodi BeginInvoke() e 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) ;
				
eseguita in quattro modi comuni utilizzare BeginInvoke() e EndInvoke() per effettuare chiamate asincrone. Dopo aver chiamato BeginInvoke() , Ŕ possibile:
  • Se lo si desidera eseguire alcune altre operazioni e quindi utilizzare EndInvoke() .
  • Ottenere un WaitHandle fornito con l'oggetto IAsyncResult , utilizzare il metodo WaitOne per bloccare fino a quando il WaitHandle viene segnalato e quindi chiamare EndInvoke() .
  • L'oggetto IAsyncResult per determinare quando la chiamata asincrona Ŕ stata completata e quindi chiamare EndInvoke() di polling.
  • Impostare il sistema chiamare una funzione callback specificato dall'utente. Questa funzione di callback chiama EndInvoke() ed elabora i risultati della chiamata asincrona al termine.
Esempi di codice riportato di seguito vengono illustrati questi chiamare modelli e si contrasto loro di eseguire 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 lungo periodo di tempo per inattivo. Restituisce l'ora di sospensione e l'ID del thread che viene eseguito. Se si chiama in modo asincrono, Ŕ possibile trovare che l'ID del thread del thread in esecuzione Ŕ diverso da quello del thread chiamante.

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

Esempio 1: Chiamata di metodo in modo sincrono

Questo esempio viene illustrato come chiamare LongRunningMethod() in modo sincrono utilizzando un delegato MethodDelegate . Altri esempi ci˛ si differenzia effettuando chiamate in modo asincrono.
  1. Avviare Microsoft Visual Studio .NET o Microsoft Visual Studio 2005.
  2. Creare un nuovo progetto applicazione console in Visual C# denominato AsyncDemo.
  3. Aggiungere una classe denominata AsyncDemo definito come indicato di seguito per il progetto in un nuovo file con estensione 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() ) );
    	}
    }
    					
    in seguito, questa classe viene illustrato come effettuare chiamate asincrone. Tuttavia, solo inizialmente il metodo DemoSyncCall() , che illustra come chiamare il delegato in modo sincrono.
  4. Aggiungere il seguente codice nel corpo della funzione principale che verrÓ creato automaticamente nel progetto:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoSyncCall() ;
    }
    					
  5. Premere CTRL+F5 per eseguire l'applicazione.

Esempio 2: Chiamata di metodo asincrono utilizzando il modello EndInvoke() chiamata

In questa sezione, l'esempio richiama in modo asincrono lo stesso metodo. Il modello di chiamata utilizzato consiste nel chiamare BeginInvoke , eseguire alcune lavorare sul thread principale e quindi chiamare EndInvoke() . Si noti che EndInvoke() non risultato finchÚ non viene completata la chiamata asincrona. Questo modello di chiamata Ŕ utile quando si desidera che il thread chiamante funzionano allo stesso tempo che sta eseguendo la chiamata asincrona. Con stesso orario di lavoro, Ŕ possibile migliorare le prestazioni di molte applicazioni. AttivitÓ comuni per 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 codice riportato di seguito:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoEndInvoke() ;
    }
    					
  3. Premere CTRL+F5 per eseguire l'applicazione.

Esempio 3: Chiamata di metodo asincrono e utilizzando un WaitHandle per attesa la chiamata per completamento


In questa sezione, l'esempio chiama il metodo in modo asincrono e attende un WaitHandle prima di chiamare EndInvoke() . IAsyncResult restituito da BeginInvoke() dispone di una proprietÓ AsyncWaitHandle . Questa proprietÓ restituisce un WaitHandle che viene segnalato quando la chiamata asincrona viene completata. In attesa di un WaitHandle Ŕ una tecnica di sincronizzazione di thread comune. Il thread chiamante attende il WaitHandle utilizzando il metodo WaitOne() di WaitHandle . WaitOne() blocca fino a quando il WaitHandle viene segnalato. Quando restituisce WaitOne() , Ŕ possibile eseguire altre operazioni prima di chiamare EndInvoke() . Come nell'esempio precedente, questa tecnica Ŕ utile per l'esecuzione di file o di rete operazioni che altrimenti sarebbero bloccate il thread principale chiamante.
  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 codice riportato di seguito:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoWaitHandle () ;
    }
    					
  3. Premere CTRL+F5 per eseguire l'applicazione.

Esempio 4: Chiamata di metodo asincrono utilizzando il modello di chiamate di polling

In questa sezione, l'esempio esegue il polling l'oggetto IAsyncResult per individuare la chiamata asincrona Ŕ stata completata. L'oggetto IAsyncResult restituito da BeginInvoke() dispone di una proprietÓ IsCompleted che restituisce true dopo il completamento della chiamata asincrona. ╚ quindi possibile chiamare EndInvoke() . Questo modello di chiamata Ŕ utile se l'applicazione non lavoro continuo che non si desidera avere bloccato da una chiamata di funzione a esecuzione prolungata. Un'applicazione di Microsoft Windows Ŕ un esempio. Il thread principale dell'applicazione di Windows possono continuare a gestire l'input utente mentre viene eseguita una chiamata asincrona. ╚ possibile verificare periodicamente IsCompleted per verificare se la chiamata Ŕ stata completata. Chiama EndInvoke quando IsCompleted restituisce true . PoichÚ EndInvoke() blocca fino al termine dell'operazione asincrona, l'applicazione non viene chiamato, finchÚ non sa che l'operazione Ŕ completata.
  1. Aggiungere una funzione denominata DemoPolling() alla classe AsyncDemo . La funzione DemoPolling() viene illustrato come chiamare il delegato in modo asincrono e utilizzare 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.

Esempio 5: Esecuzione di una richiamata quando un metodo asincrono completa

In questa sezione, nell'esempio viene fornita 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 il thread che avvia la chiamata asincrona non Ŕ necessario elaborare i risultati della chiamata. Il sistema richiama il callback in un thread diverso dal thread che iniziato quando la chiamata asincrona viene completata.

Per utilizzare questo modello di chiamata, Ŕ necessario passare un delegato del tipo AsyncCallback come secondo all'ultimo parametro della funzione BeginInvoke() . BeginInvoke() ha inoltre un parametro finale di tipo oggetto in cui Ŕ possibile passare qualsiasi oggetto. Questo oggetto Ŕ disponibile per la funzione di richiamata quando viene richiamato. Un utilizzo importante di questo parametro consiste nel passare il delegato viene utilizzato per avviare la chiamata. La funzione di richiamata quindi la EndInvoke() funzione consente di tale delegato per completare la chiamata. Questo modello di chiamata Ŕ illustrato di seguito.
  1. Aggiungere un due metodi denominati DemoCallback() e MyAsyncCallback() alla classe AsyncDemo . Il metodo DemoCallback() viene illustrato come chiamare il delegato in modo asincrono. Viene utilizzato un delegato per racchiudere il metodo di MyAsyncCallback() , il sistema chiama al termine dell'operazione 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.

ProprietÓ

Identificativo articolo: 315582 - Ultima modifica: lunedý 11 dicembre 2006 - Revisione: 4.3
Le informazioni in questo articolo si applicano a:
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
Chiavi:á
kbmt kbhowtomaster KB315582 KbMtit
Traduzione automatica articoli
Il presente articolo Ŕ stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell?utente. Tuttavia, un articolo tradotto in modo automatico non Ŕ sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, pi¨ o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non Ŕ la sua. Microsoft non Ŕ responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell?utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.
Clicca qui per visualizzare la versione originale in inglese dell?articolo: 315582
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com