Comment appeler une méthode Visual C# de façon asynchrone

Traductions disponibles Traductions disponibles
Numéro d'article: 315582 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

Résumé

Le Microsoft .NET Framework facilite l'appel des fonctions de façon asynchrone. Appel asynchrone des fonctions provoque le système les exécuter en arrière-plan sur un thread secondaire tandis que la fonction appelante continue à faire autre travail. Dans un appel type fonction (synchrones), la fonction est exécutée immédiatement sur le même thread qui a passé l'appel. La fonction appelante attend que l'appel et reçoit les résultats de l'appel avant de poursuivre. En revanche, lorsque vous effectuez un appel asynchrone, vous récupérer les résultats de l'appel asynchrone ultérieurement. Cet article explique comment procéder à l'aide de Visual C#.

Configuration requise


La liste suivante met en évidence le matériel recommandé, logiciel infrastructure réseau et service packs sont requis :
  • Microsoft Windows 2000 ou les Microsoft Windows XP ou les Microsoft Windows Server 2003
  • Visual Studio .NET ou Visual Studio 2005
Cet article suppose que vous êtes familiarisé avec les sujets suivants :
  • Appel de méthodes dans Visual C#
  • Comment faire pour utiliser les délégués

Comment faire pour créer des appels asynchrones

Appels asynchrones sont effectuées à l'aide de délégués. Un délégué est un objet qui encapsule une fonction. Les délégués fournissent une fonction synchrone et fournissent également des méthodes pour appeler la fonction renvoyé à la ligne en mode asynchrone. Ces méthodes sont BeginInvoke() et EndInvoke() . Les listes de paramètres de ces méthodes varient selon la signature de la fonction qui encapsule le délégué. Notez que le Visual Studio fonctionnalité .NET IntelliSense n'affiche pas BeginInvoke() et EndInvoke() , pour ne pas voir les s'affichent dans la fonction listes en cours de frappe.

BeginInvoke() est utilisée pour lancer l'appel asynchrone. Il a les mêmes paramètres que la fonction renvoyé à la ligne, ainsi que deux paramètres supplémentaires qui va être décrits plus loin dans cet article. BeginInvoke() renvoie immédiatement et n'attendez pas à l'appel asynchrone terminer. BeginInvoke() renvoie un objet IAsyncResult .

La fonction EndInvoke() est utilisée pour récupérer les résultats de l'appel asynchrone. Il peut être appelée à tout moment après BeginInvoke() . Si l'appel asynchrone n'a pas effectué encore EndInvoke() blocs jusqu'à la fin. Les paramètres de la fonction EndInvoke() comprend l' out et paramètres de ref qui la fonction renvoyé à la ligne a plus l'objet IAsyncResult qui est renvoyé par BeginInvoke() .

Voici un exemple d'un délégué et de ses méthodes BeginInvoke() et 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) ;
				
Il existe quatre façons courantes d'utiliser BeginInvoke() et EndInvoke() pour effectuer des appels asynchrones. Une fois que vous appelez BeginInvoke() , vous pouvez :
  • Vous pouvez également effectuer certaines autres tâches, puis utilisez EndInvoke() .
  • Obtenir un WaitHandle qui est fourni par l'objet IAsyncResult , utiliser sa méthode WaitOne pour bloquer jusqu'à ce que le WaitHandle est signalé et appelez ensuite EndInvoke() .
  • Interroger l'objet IAsyncResult pour déterminer une fois l'appel asynchrone terminée, puis appeler EndInvoke() .
  • Que le système une fonction de rappel que vous spécifiez. Cette fonction de rappel appelle EndInvoke() et traite les résultats de l'appel asynchrone lorsqu'elle est terminée.
Les exemples de code suivants montrent ces appellent motifs et les contraste à effectuer un appel synchrone en utilisant la fonction suivante :
string LongRunningMethod (int iCallTime, out int iExecThread)
{
	Thread.Sleep (iCallTime) ;
	iExecThread = AppDomain.GetCurrentThreadId ();
	return "MyCallTime was " + iCallTime.ToString() ;
}

				
LongRunningMethod() simule une fonction qui s'exécute pendant longtemps en veille. Elle renvoie l'heure de mise en veille et l'ID du thread qui exécute. Si vous appelez il asynchrone, vous trouvez que l'ID de thread du thread en cours d'exécution est différent de celui du thread appelant.

La première étape consiste à définir le délégué qui encapsule la fonction :
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;
				

Exemple 1: appel de méthode synchrone

Cet exemple montre comment appeler LongRunningMethod() synchrone en utilisant un délégué MethodDelegate . Les autres exemples contraste en effectuant des appels asynchrone.
  1. Démarrez Microsoft Visual Studio .NET ou Microsoft Visual Studio 2005.
  2. Créez un nouveau projet de Visual application de console Visual c# nommé AsyncDemo.
  3. Ajouter une classe nommée AsyncDemo est définie comme suit au projet dans un nouveau fichier .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() ) );
    	}
    }
    					
    ultérieurement, cette classe explique comment effectuer des appels asynchrones. Initialement, toutefois, il seulement indique la DemoSyncCall() méthode, qui montre comment appeler le délégué de façon synchrone.
  4. Ajoutez le code suivant dans le corps de la fonction principale que Visual Studio crée automatiquement dans votre projet :
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoSyncCall() ;
    }
    					
  5. Appuyez sur CTRL + F5 pour exécuter votre application.

Exemple 2: appel de méthode asynchrone en utilisant le modèle EndInvoke() appel

Dans cette section, l'exemple appelle la méthode même en mode asynchrone. Le motif d'appel qui est utilisé consiste à appeler BeginInvoke , certains travailler sur le thread principal et puis appeler EndInvoke() . Notez que EndInvoke() ne renvoie pas que l'appel asynchrone soit terminée. Ce modèle d'appel est utile lorsque vous souhaitez que le thread d'appel fonctionnent en même temps que l'appel asynchrone s'exécute. Devoir travail se produire à la fois peut améliorer les performances de nombreuses applications. Exécution asynchrone de cette façon de tâches courantes sont opérations de fichier ou un réseau.
  1. Ajoutez une méthode nommée DemoEndInvoke() à la classe AsyncDemo . La fonction DemoEndInvoke montre comment appeler le délégué de façon asynchrone.
    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. Modifiez le code source pour principal afin qu'elle contienne le code suivant :
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoEndInvoke() ;
    }
    					
  3. Appuyez sur CTRL + F5 pour exécuter votre application.

Exemple 3: appel asynchrone de méthode et à l'aide de WaitHandle À attendre pour l'appel À la fin


Dans cette section, l'exemple appelle la méthode asynchrone et attend un WaitHandle avant d'appeler EndInvoke() . Le IAsyncResult retourné par BeginInvoke() possède une propriété AsyncWaitHandle . Cette propriété renvoie un WaitHandle est signalé lorsque l'appel asynchrone se termine. Attend un WaitHandle est une technique de synchronisation de thread courante. Le thread appelant attend la WaitHandle à la méthode WaitOne() de la WaitHandle . blocs WaitOne() jusqu'à ce que le WaitHandle est signalé. Lorsque WaitOne() renvoie, vous pouvez effectuer des opérations supplémentaires avant d'appeler EndInvoke() . Comme dans l'exemple précédent, cette technique est utile pour exécuter des opérations de fichier ou un réseau qui serait sinon bloquer le thread principal appelant.
  1. Ajouter une fonction nommée DemoWaitHandle() à la classe AsyncDemo . La fonction DemoWaitHandle() montre comment appeler le délégué de façon asynchrone.
    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. Modifiez le code source pour principal afin qu'elle contienne le code suivant :
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoWaitHandle () ;
    }
    					
  3. Appuyez sur CTRL + F5 pour exécuter votre application.

Exemple 4: appel de méthode asynchrone en utilisant le modèle d'appel d'interrogation

Dans cette section, L'exemple interroge l'objet IAsyncResult pour savoir lorsque l'appel asynchrone est terminé. L'objet IAsyncResult qui est renvoyé par BeginInvoke() possède une propriété IsCompleted qui renvoie la valeur True une fois l'appel asynchrone est terminée. Vous pouvez ensuite appeler EndInvoke() . Ce modèle d'appel est utile si votre application fonctionne en cours que vous ne souhaitez pas ont bloqué par un appel de fonction longue. Une application Microsoft Windows est un exemple. Le thread principal de l'application Windows peut continuer à traiter l'entrée utilisateur pendant un appel asynchrone s'exécute. Il peut vérifier régulièrement IsCompleted pour voir si l'appel est terminé. Elle appelle EndInvoke lorsque IsCompleted renvoie la valeur True . Car EndInvoke() bloque jusqu'à ce que l'opération asynchrone est terminée, l'application n'appelle pas il jusqu'à ce qu'il sait que l'opération est terminée.
  1. Ajouter une fonction nommée DemoPolling() à la classe AsyncDemo . La fonction DemoPolling() montre comment appeler le délégué de façon asynchrone et d'interrogation permet de voir si le processus est terminé.
    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. Modifiez le code source pour principal . Remplacez le contenu de la fonction par le code suivant :
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoPolling () ;
    }
    					
  3. Appuyez sur CTRL + F5 pour exécuter votre application.

Exemple 5: exécution un rappel lorsqu'une méthode asynchrone termine

Dans cette section, l'exemple fournit un délégué de rappel à la fonction BeginInvoke() qui le système s'exécute lorsque l'appel asynchrone se termine. Le rappel appelle EndInvoke() et traite les résultats de l'appel asynchrone. Ce modèle d'appel est utile si le thread qui lance l'appel asynchrone ne doit pas traiter les résultats de l'appel. Le système appelle le rappel sur un thread autre que le thread d'initialisation Lorsque l'appel asynchrone se termine.

Pour utiliser ce modèle d'appel, vous devez transmettre un délégué du type AsyncCallback comme paramètre de la fonction BeginInvoke() avant-dernière à. BeginInvoke() comporte également un paramètre final de type objet dans lequel vous pouvez transmettre un objet. Cet objet est disponible pour votre fonction de rappel lorsqu'elle est invoquée. Une utilisation importante de ce paramètre consiste à passer le délégué qui sert à lancer l'appel. La fonction de rappel pouvez utiliser ensuite la fonction EndInvoke() de ce délégué pour terminer l'appel. Ce modèle d'appel est illustré ci-dessous.
  1. Ajouter une deux méthodes nommées DemoCallback() et MyAsyncCallback() à la classe AsyncDemo . La méthode DemoCallback() illustre comment appeler le délégué de manière asynchrone. Il utilise un délégué pour ajuster la méthode MyAsyncCallback() , appeler le système lorsque l'opération asynchrone se termine. MyAsyncCallback() appelle 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. Modifiez le code source pour principal . Remplacez le contenu de la fonction par le code suivant :
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoCallback() ;
    }
    					
  3. Appuyez sur CTRL + F5 pour exécuter votre application.

Propriétés

Numéro d'article: 315582 - Dernière mise à jour: lundi 11 décembre 2006 - Version: 4.3
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual C# .NET 2002 Initiation
  • Microsoft Visual C# 2005 Express Edition
Mots-clés : 
kbmt kbhowtomaster KB315582 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 315582
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.

Envoyer des commentaires

 

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