Wie Sie eine Visual C#-Methode asynchron aufrufen

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 315582 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Microsoft.NET Framework erleichtert aufrufen asynchron fungiert. Aufrufen von Funktionen asynchron fährt das system Führen Sie sie in den Hintergrund in einem sekundären Thread während der aufrufenden Funktion weiterhin andere Arbeiten fortsetzen. In einem typischen (synchrone) Funktionsaufruf der Funktion wird sofort auf dem gleichen Thread ausgeführt, die den Aufruf ausgeführt hat. Die wartet darauf, dass der Aufruf abgeschlossen und empfängt die Ergebnisse der Funktion der Rufen Sie auf, bevor Sie fortfahren. Wenn Sie hingegen einen asynchronen Aufruf vornehmen Sie Rufen Sie die Ergebnisse des asynchronen Aufrufs später. Dieser Artikel beschreibt wie Sie dies tun, indem Sie mit Visual C#.

Anforderungen


Die folgende Liste führt die empfohlene Hardware, Software, Netzwerkinfrastruktur und Servicepacks, die erforderlich sind:
  • Microsoft Windows 2000 oder Microsoft Windows XP oder Microsoft Windows Server 2003
  • Visual Studio .NET oder Visual Studio 2005
In diesem Artikel wird davon ausgegangen, dass Sie mit den folgenden Punkten vertraut sind Themen:
  • Aufrufen von Methoden in Visual C#
  • Gewusst wie: Verwenden von Delegaten

Wie bei asynchrone Aufrufen

Asynchrone Aufrufe werden mithilfe von Delegaten ausgeführt. Ein Delegat ist ein Objekt, das eine Funktion umschließt. Delegaten eine synchrone-Funktion bereitstellen und auch Stellen Sie Methoden für die umschlossene Funktion asynchron aufrufen. Diese Methoden sind BeginInvoke() und EndInvoke(). Die Parameterlisten der folgenden Methoden variieren je nach der Signatur der Funktion, die der Delegat umschließt. Beachten Sie, dass die Visual Studio .NET IntelliSense-Feature wird nicht angezeigt, BeginInvoke() und EndInvoke(), so dass Sie nicht sehen, sie in der Funktion Listen erscheinen, während der Eingabe.

BeginInvoke() wird verwendet, um den asynchronen Aufruf zu initiieren. Es hat die gleichen Parameter wie die umschlossene Funktion sowie zwei zusätzliche Parameter, die werden weiter unten in diesem Artikel beschrieben. BeginInvoke() wird sofort beendet und wartet nicht, bis der asynchrone Aufruf um zu vervollständigen. BeginInvoke() gibt eine IAsyncResult -Objekt zurück.

Die EndInvoke() -Funktion dient zum Abrufen der Ergebnisse der asynchronen Rufen Sie. Sie können jederzeit nach BeginInvoke()aufgerufen werden. Wenn der asynchrone Aufruf noch nicht, EndInvoke() Blöcke abgeschlossen wurde, bis er abgeschlossen ist. Die Parameter der EndInvoke() -Funktion umfasst die Out und REF Parameter, die die umschlossene Funktion enthält, plus das IAsyncResult -Objekt, das von BeginInvoke()zurückgegeben wird.

Es folgt ein Beispiel für einen Delegaten und die zugehörigen Methoden BeginInvoke() und 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) ;
				
Es gibt vier gebräuchlichen Arten der BeginInvoke() und EndInvoke() verwenden, um asynchrone Aufrufe durchführen. Nach dem Aufruf von BeginInvoke() können Sie:
  • Optional leisten Sie einige andere Arbeit, und verwenden Sie EndInvoke().
  • Rufen Sie ein WaitHandle , die durch das IAsyncResult -Objekt bereitgestellt wird, mit der zugehörigen WaitOne -Methode blockiert, bis das WaitHandle signalisiert wird, und rufen Sie EndInvoke().
  • Das IAsyncResult -Objekt, um zu bestimmen, wann der asynchrone Aufruf beendet wurde, abrufen und Rufen Sie dann EndInvoke().
  • Lassen Sie das System eine Callback-Funktion aufrufen, die Sie angeben. Diese Callback-Funktionsaufrufen EndInvoke() und Prozesse die Ergebnisse der asynchronen Aufrufen, wenn es abgeschlossen ist.
Demonstrieren Sie die folgenden Codebeispiele aufrufen, Muster und Vergleichen sie mit der Herstellung eines synchronen Aufrufs mithilfe der folgenden Funktion:
string LongRunningMethod (int iCallTime, out int iExecThread)
{
	Thread.Sleep (iCallTime) ;
	iExecThread = AppDomain.GetCurrentThreadId ();
	return "MyCallTime was " + iCallTime.ToString() ;
}

				
LongRunningMethod() simuliert eine Funktion, die für längere Zeit von sleeping ausgeführt wird. Es Gibt die Zeit für Ruhezustand und die ID des Threads, die sie ausgeführt wird. Wenn Sie aufrufen es asynchron, Sie suchen, die die Thread-ID des ausgeführten Thread ist sich von der aufrufenden Thread.

Der erste Schritt besteht darin Definieren der Delegat, der die Funktion umschließt:
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;
				

Beispiel 1: Aufrufen einer Methode synchron

Dieses Beispiel veranschaulicht, wie LongRunningMethod() synchron mit einen MethodDelegate-Delegaten aufgerufen wird. Die anderen Beispiele vergleichen Sie dies durch Aufrufe asynchron.
  1. Starten Sie Microsoft Visual Studio .NET oder Microsoft Visual Studio 2005.
  2. Erstellen Sie ein neues Konsolenanwendung in Visual C#-Projekt mit dem Namen AsyncDemo.
  3. Fügen Sie eine Klasse mit dem Namen AsyncDemo, die wie folgt definiert ist das Projekt in eine neue CS-Datei:
    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() ) );
    	}
    }
    					
    Diese Klasse wird später veranschaulicht, wie bei asynchrone aufrufen. Anfangs enthält allerdings es nur die DemoSyncCall() -Methode, die veranschaulicht, wie Sie den Delegaten aufrufen synchron.
  4. Fügen Sie folgenden Code im Hauptteil der Main -Funktion, die Visual Studio automatisch in erstellt Ihre Projekt:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoSyncCall() ;
    }
    					
  5. Drücken Sie STRG + F5, um die Anwendung auszuführen.

Beispiel 2: Aufrufen einer Methode asynchron mit das EndInvoke() -Aufruf-Muster

In diesem Abschnitt im Beispiel ruft die dieselbe Methode asynchron. Das Aufruf-Muster, das verwendet wird, ist: BeginInvoke() aufrufen, einige Arbeiten im Haupthread durchführen, und dann EndInvoke() aufrufen. Beachten Sie, dass EndInvoke() nicht zurückgegeben wird, bis der asynchrone Aufruf abgeschlossen wurde. Dies Call-Muster ist nützlich, wenn Sie dem aufrufenden Thread möchten funktionieren bei der derselben Zeit an, der asynchrone Aufruf ausgeführt wird. Mit der Arbeit, die bei Auftreten der gleichzeitig kann die Leistung vieler Anwendungen verbessern. Allgemeine Aufgaben ausführen asynchron werden auf diese Weise Datei- oder Netzwerkvorgänge.
  1. Fügen Sie eine Methode mit dem Namen DemoEndInvoke() , AsyncDemo -Klasse. Die DemoEndInvoke -Funktion veranschaulicht, wie der Delegat asynchron aufgerufen.
    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. Bearbeiten Sie den Quellcode für Main , so dass sie den folgenden Code enthält:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoEndInvoke() ;
    }
    					
  3. Drücken Sie STRG + F5, um die Anwendung auszuführen.

Beispiel 3: Eine Methode asynchron aufrufen und mit eine WaitHandle zu warten, für den Aufruf abgeschlossen


In diesem Abschnitt wird im Beispiel die Methode asynchron und wartet auf ein WaitHandle bevor EndInvoke()aufgerufen. Von BeginInvoke() zurückgegebene IAsyncResult verfügt über eine AsyncWaitHandle -Eigenschaft. Diese Eigenschaft gibt ein WaitHandle , das signalisiert wird, wenn der asynchrone Aufruf abgeschlossen ist. Warten auf ein WaitHandle ist ein gebräuchliches Verfahren des Thread-Synchronisierung verwendet. Der aufrufende thread auf das WaitHandle wartet durch mithilfe der WaitOne() -Methode des WaitHandle. WaitOne() blockiert, bis das WaitHandle signalisiert wird. Wenn WaitOne() zurückgibt, können Sie noch weitere Arbeiten ausführen, vor dem Aufruf von EndInvoke(). Wie aus dem vorherigen Beispiel eignet sich diese Technik zum Ausführen von Datei- oder Netzwerkoperationen, die andernfalls würde das aufrufende blockieren Hauptthread.
  1. Fügen Sie eine Funktion namens DemoWaitHandle() auf die AsyncDemo -Klasse. Die DemoWaitHandle() -Funktion veranschaulicht, wie der Delegat asynchron aufgerufen.
    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. Bearbeiten Sie den Quellcode für Main , so dass sie den folgenden Code enthält:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoWaitHandle () ;
    }
    					
  3. Drücken Sie STRG + F5, um die Anwendung auszuführen.

Beispiel 4: Aufrufen einer Methode asynchron mithilfe des Musters Polling-Aufruf

In diesem Abschnitt fragt das Beispiel das IAsyncResult -Objekt, um herauszufinden, wann der asynchrone Aufruf abgeschlossen wurde. Das IAsyncResult -Objekt, das von BeginInvoke() zurückgegeben wird verfügt über eine IsCompleted -Eigenschaft, die True zurückgibt, nachdem der asynchrone Aufruf abgeschlossen ist. Sie können dann EndInvoke()aufrufen. Dieser Aufruf-Muster ist nützlich, wenn Ihre Anwendung laufenden ist Arbeiten Sie, dass Sie nicht durch eine lang andauernde Funktionsaufruf blockiert haben möchten. A Microsoft Windows-Anwendung ist ein Beispiel dafür. Der Hauptthread von der Windows-Anwendung können zur Behandlung von Benutzereingaben während einer asynchronen fortfahren Aufruf ausgeführt wird. Es kann in regelmäßigen Abständen überprüfen, IsCompleted um festzustellen, ob der Aufruf beendet wurde. Es ruft entsprechend EndInvoke , wenn IsCompletedTruezurückgibt. Da EndInvoke() blockiert, bis der asynchrone Vorgang abgeschlossen ist, ist die Anwendung ruft es nicht, wenn bekannt ist, dass der Vorgang abgeschlossen ist.
  1. Fügen Sie eine Funktion namens DemoPolling() auf die AsyncDemo -Klasse. Die DemoPolling() -Funktion veranschaulicht, wie der Delegat asynchron aufgerufen und Verwenden Sie Polling, um festzustellen, ob der Vorgang abgeschlossen ist.
    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. Bearbeiten Sie den Quellcode für Main. Ersetzen Sie den Inhalt der Funktion, mit dem folgenden Code:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoPolling () ;
    }
    					
  3. Drücken Sie STRG + F5, um die Anwendung auszuführen.

Beispiel 5: Einen Rückruf ausführt, wenn eine asynchrone Methode abgeschlossen ist

In diesem Abschnitt das Beispiel stellt einen Rückruf an die BeginInvoke() -Funktion, dass das System bei Eintritt des asynchronen Aufrufs delegieren abgeschlossen ist. Der Rückruf EndInvoke() aufruft und die Ergebnisse des asynchronen Aufrufs verarbeitet. Dieser Aufruf Muster ist nützlich, wenn der Thread, der den asynchronen Aufruf gestartet nicht der Fall ist müssen Sie die Ergebnisse des Aufrufs verarbeitet. Das System Ruft den Rückruf auf einem Thread als dem initiierende Thread bei Beendigung des asynchronen Aufrufs.

Wenn dieser Aufruf Muster verwenden möchten, müssen Sie einen Delegaten vom Typ AsyncCallback als vorletzten-Parameter der Funktion BeginInvoke() übergeben. BeginInvoke() hat auch einen abschließenden Parameter von Objekt Geben Sie in das Sie beliebiges Objekt übergeben können. Dieses Objekt steht zur Verfügung Ihre Callback-Funktion, wenn er aufgerufen wird. Ein wichtiger Verwendungszweck für diesen parameter besteht darin, den Delegaten übergeben, mit der Initiierung des Aufrufs. Der Rückruf die EndInvoke() -Funktion von diesem Delegaten können Funktion klicken Sie dann den Aufruf vollständig auszuführen. Dieser Aufruf-Muster wird unten demonstriert.
  1. Fügen Sie eine zwei Methoden mit dem Namen DemoCallback() und MyAsyncCallback() der AsyncDemo -Klasse. Die DemoCallback() -Methode demonstriert, wie den Delegaten asynchron aufrufen. Es ein Delegat verwendet, um die MyAsyncCallback() -Methode, zu umschließen die das System, wenn aufruft der asynchrone Vorgang abgeschlossen ist. MyAsyncCallback() ruft EndInvoke()auf.
    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. Bearbeiten Sie den Quellcode für Main. Ersetzen Sie den Inhalt der Funktion, mit dem folgenden Code:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoCallback() ;
    }
    					
  3. Drücken Sie STRG + F5, um die Anwendung auszuführen.

Eigenschaften

Artikel-ID: 315582 - Geändert am: Sonntag, 30. Dezember 2012 - Version: 6.0
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
Keywords: 
kbhowtomaster kbmt KB315582 KbMtde
Maschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 315582
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

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