Jak asynchronní volání metody Visual C#

Překlady článku Překlady článku
ID článku: 315582 - Produkty, které se vztahují k tomuto článku.
Rozbalit všechny záložky | Minimalizovat všechny záložky

Na této stránce

Souhrn

Microsoft.NET Framework usnadňuje volání Funkce asynchronně. Asynchronní volání funkcí způsobí, že systém jejich spuštění na pozadí v sekundární podprocesu při volání funkce nadále provádět další operace. Ve volání funkce pro typické (synchronní) provedení funkce okamžitě ve stejném podprocesu, který volání uskutečnil. Na volání funkce čeká na dokončení volání a přijímá výsledky Před pokračováním zavolat. Naopak pokud provedete asynchronní volání, které načtěte výsledky asynchronní volání později. Tento článek ukazuje jak to provést pomocí aplikace Visual C#.

Požadavky


Následující seznam obsahuje doporučený hardware software, síťovou infrastrukturu a požadované aktualizace service Pack:
  • Microsoft Windows 2000 nebo Microsoft Windows XP nebo Microsoft Windows Server 2003
  • Visual Studio.NET nebo Visual Studio 2005
Tento článek předpokládá, že jste obeznámeni s následujícími témata:
  • Volání metody v jazyce Visual C#
  • Jak používat delegáty

Jak vytvořit asynchronní volání

Asynchronní volání jsou uskutečněna pomocí delegátů. Delegát je objekt, který se zalamuje funkce. Delegáti poskytují synchronní funkci a také poskytuje metody pro volání funkce zalomený asynchronně. Tyto metody jsou BeginInvoke() a EndInvoke(). Seznamy parametrů těchto metod se liší v závislosti na podpis funkce, která delegátovi obtéká. Všimněte si, že Visual Studio .Funkce technologie IntelliSense NET nezobrazí. BeginInvoke() a EndInvoke(), tak je zobrazit v nezobrazí funkce seznamy při psaní.

BeginInvoke() slouží k zahájení asynchronní volání. Má stejné Parametry jako funkci zalamování plus dva další parametry, které budou popsané dále v tomto článku. BeginInvoke() Vrátí hodnotu okamžitě a nečeká asynchronní volání k dokončení. BeginInvoke() Vrátí Třída IAsyncResult objekt.

Na EndInvoke() funkce se používá k získání výsledků asynchronní volání. Může být vyvolána kdykoli po BeginInvoke(). Pokud nebyla ještě dokončena asynchronní volání EndInvoke() bloky, dokud nebude dokončena. Parametry EndInvoke() zahrnuje funkce mimo a REF parametry, které má funkci zalamování, plus na Třída IAsyncResult objekt, který je vrácen BeginInvoke().

Následuje příklad delegáta a jeho BeginInvoke() a EndInvoke() metody:
// 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) ;
				
Existují čtyři běžné způsoby použití BeginInvoke() a EndInvoke() pro asynchronní volání. Po volání BeginInvoke(), můžete:
  • Můžete také provést některé další práci a potom použijte EndInvoke().
  • Získat Popisovač WaitHandle zajišťuje, Třída IAsyncResult objekt, použijte jeho WaitOne Metoda blokovat, dokud Popisovač WaitHandle je signalizováno následným tichem a potom volat. EndInvoke().
  • Dotazování Třída IAsyncResult objekt, který chcete určit při dokončení asynchronního volání a Zavolejte EndInvoke().
  • Máte systém volání funkce zpětného volání, který zadáte. Tato funkce zpětné volání EndInvoke() a procesy výsledky asynchronní volání, kdy jej dokončí.
Následující ukázky kódu ukazují tyto vzorky volání a kontrast je s synchronní volání pomocí následující funkce:
string LongRunningMethod (int iCallTime, out int iExecThread)
{
	Thread.Sleep (iCallTime) ;
	iExecThread = AppDomain.GetCurrentThreadId ();
	return "MyCallTime was " + iCallTime.ToString() ;
}

				
LongRunningMethod() napodobuje funkci, která běží dlouhou dobu režimu spánku. Jeho Vrátí čas spánku a ID podprocesu, který ji spustí. Při volání jeho asynchronně, zjistíte, že Identifikátor podprocesu vykonávajícího vlákno je odlišné od volajícího podprocesu.

Prvním krokem je Delegát, který se zalamuje funkce definujte:
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;
				

Příklad 1: Volání metody synchronně

Tento příklad znázorňuje způsob volání LongRunningMethod() synchronně pomocí MethodDelegate delegujte. To ostatních vzorků kontrastu pomocí volání asynchronně.
  1. Spusťte aplikaci Visual Studio.NET nebo Microsoft Visual Studio 2005.
  2. Vytvořit nový projekt aplikace Visual C# konzolové aplikace s názvem AsyncDemo.
  3. Přidat třídu s názvem AsyncDemo na takto definovaná projekt do nového souboru .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() ) );
    	}
    }
    					
    Později tuto třídu demonstruje asynchronní volání. Zpočátku však obsahuje pouze DemoSyncCall() Metoda, která ukazuje, jak volat delegáta synchronně.
  4. V textu, přidejte následující kód Hlavní funkce, která Visual Studio automaticky vytvoří ve vaší Projekt:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoSyncCall() ;
    }
    					
  5. Stiskněte kombinaci kláves CTRL + F5 spuštění aplikace.

Příklad 2: Volání metody asynchronně pomocí EndInvoke() Volání vzorek

V této části vzorku vyvolá stejná metoda asynchronně. Je volání vzorek, který slouží k volání BeginInvoke, proveďte některé práce na základě hlavního podprocesu a potom volat EndInvoke(). Všimněte si, že EndInvoke() nevrátí dokud asynchronní volání. To vzorek volání je užitečné, pokud chcete mít volající vlákno pracovat v době, kdy je provádění asynchronního volání. S dochází při práci současně lze výkon mnoho aplikací. Běžné úlohy ke spuštění asynchronně tímto způsobem jsou soubor nebo síťové operace.
  1. Přidat metodu s názvem DemoEndInvoke() aby AsyncDemo Třída. Na DemoEndInvoke Funkce ukazuje, jak volat delegát asynchronně.
    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. Úpravy zdrojového kódu Hlavní tak, aby obsahoval následující kód:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoEndInvoke() ;
    }
    					
  3. Stiskněte kombinaci kláves CTRL + F5 spuštění aplikace.

Ukázka 3: Volání metody asynchronně a dokončit pomocí popisovač WaitHandle S čekat na volání


V této části vzorku volá metodu asynchronně a čeká Popisovač WaitHandle před volá EndInvoke(). Na Třída IAsyncResult vrácené BeginInvoke()AsyncWaitHandle Vlastnost. Tato vlastnost vrátí Popisovač WaitHandle že je signalizováno následným tichem po dokončení asynchronního volání. Čekání na do Popisovač WaitHandle je běžnou technikou synchronizace podprocesů. Volající vlákno čeká Popisovač WaitHandle pomocí WaitOne() Metoda Popisovač WaitHandle. WaitOne() blokuje až Popisovač WaitHandle je signalizováno následným tichem. Když WaitOne() Vrátí hodnotu, než budete volat můžete provést některé další práce EndInvoke(). Stejně jako v předchozím vzorku Tato technika je užitečná pro spuštění souboru nebo síťové operace, které by jinak blokovat volající hlavní podproces.
  1. Přidat funkci s názvem DemoWaitHandle() aby AsyncDemo Třída. Na DemoWaitHandle() Funkce ukazuje, jak volat delegát asynchronně.
    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. Úpravy zdrojového kódu Hlavní tak, aby obsahoval následující kód:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoWaitHandle () ;
    }
    					
  3. Stiskněte kombinaci kláves CTRL + F5 spuštění aplikace.

Ukázka 4: Volání metody asynchronně pomocí volání dotazování vzorek

V této části vzorku dotazuje Třída IAsyncResult objekt zjistit po dokončení asynchronního volání. Na Třída IAsyncResult objekt, který je vrácen BeginInvoke()IsCompleted Vlastnost, která vrací PRAVDA Po dokončení asynchronního volání. Potom můžete volat EndInvoke(). Tento vzorek volání je užitečné v případě, že aplikace nemá probíhající práce není chcete mít blokovány volání funkce dlouhotrvající. A Aplikace Microsoft Windows je například. Hlavní podproces Aplikace systému Windows mohou nadále zpracovávat vstup uživatele při asynchronní provede volání. Můžete pravidelně kontrolovat IsCompleted zobrazit, pokud volání bylo dokončeno. Volá Funkci EndInvoke Když IsCompleted Vrátí PRAVDA. Protože EndInvoke() blokuje až do dokončení asynchronní operace, aplikace nevyvolá ji nezná, že na dokončení operace.
  1. Přidat funkci s názvem DemoPolling() aby AsyncDemo Třída. Na DemoPolling() Funkce ukazuje, jak volat delegát asynchronně a dotazování pomocí zobrazit, pokud proces je dokončen.
    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. Úpravy zdrojového kódu Hlavní. Obsah funkce nahraďte následující kód:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoPolling () ;
    }
    					
  3. Stiskněte kombinaci kláves CTRL + F5 spuštění aplikace.

Ukázka 5: Provádění zpětné volání po dokončení asynchronního metodu

V této části vzorku poskytuje delegáta, zpětné volání BeginInvoke() Funkce systém provádí při asynchronní volání dokončí. Zpětné volání EndInvoke() procesy a výsledky asynchronní volání. Toto volání vzorek je užitečné, pokud podproces, který iniciuje asynchronní volání není nutné ke zpracování výsledků volání. Systém vyvolá zpětné volání na podprocesu, než zahajující podprocesu po dokončení asynchronního volání.

Chcete-li použít tento vzorec volání, musí projít delegát typu AsyncCallback jako druhý a poslední parametr BeginInvoke() funkce. BeginInvoke() Závěrečný parametr typu má také objekt do kterého můžete předat libovolný objekt. Tento objekt je k dispozici Při vyvolání funkce zpětného volání. Jedno důležité použití tohoto parametru je předat delegát, který slouží k inicializaci volání. Zpětné volání potom můžete použít funkce EndInvoke() Funkce přidělíte k dokončení volání. Tento vzorek volání je znázorněn.
  1. Přidat dvě metody, s názvem DemoCallback() a MyAsyncCallback() aby AsyncDemo Třída. Na DemoCallback() Metoda ukazuje, jak volat delegát asynchronně. Jeho delegát používá zalomení MyAsyncCallback() Metoda, která systému volá při asynchronní operace dokončí. MyAsyncCallback() volání 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. Úpravy zdrojového kódu Hlavní. Obsah funkce nahraďte následující kód:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoCallback() ;
    }
    					
  3. Stiskněte kombinaci kláves CTRL + F5 spuštění aplikace.

Vlastnosti

ID článku: 315582 - Poslední aktualizace: 18. května 2011 - Revize: 6.0
Informace v tomto článku jsou určeny pro produkt:
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
Klíčová slova: 
kbhowtomaster kbmt KB315582 KbMtcs
Strojově přeložený článek
Důležité: Tento článek byl přeložen pomocí software společnosti Microsoft na strojový překlad, ne profesionálním překladatelem. Společnost Microsoft nabízí jak články přeložené překladatelem, tak články přeložené pomocí software na strojový překlad, takže všechny články ve Znalostní databázi (Knowledge Base) jsou dostupné v češtině. Překlad pomocí software na strojový překlad ale není bohužel vždy dokonalý. Obsahuje chyby ve skloňování slov, skladbě vět, nebo gramatice, podobně jako když cizinci dělají chyby při mluvení v češtině. Společnost Microsoft není právně zodpovědná za nepřesnosti, chyby nebo škody vzniklé chybami v překladu, nebo při použití nepřesně přeložených instrukcí v článku zákazníkem. Společnost Microsoft aktualizuje software na strojový překlad, aby byl počet chyb omezen na minimum.
Projděte si také anglickou verzi článku:315582

Dejte nám zpětnou vazbu

 

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