Teď jste offline a čekáte, až se znova připojí internet.

Jak volání asynchronní metody jazyka Visual C#

DŮLEŽITÉ: Tento článek je přeložen pomocí softwaru na strojový překlad Microsoft. Nepřesný či chybný překlad lze opravit prostřednictvím technologie Community Translation Framework (CTF). Microsoft nabízí strojově přeložené, komunitou dodatečně upravované články, a články přeložené lidmi s cílem zajistit přístup ke všem článkům v naší znalostní bázi ve více jazycích. Strojově přeložené a dodatečně upravované články mohou obsahovat chyby ve slovníku, syntaxi a gramatice. Společnost Microsoft není odpovědná za jakékoliv nepřesnosti, chyby nebo škody způsobené nesprávným překladem obsahu nebo jeho použitím našimi zákazníky. Více o CTF naleznete na http://support.microsoft.com/gp/machine-translation-corrections/cs.

Projděte si také anglickou verzi článku: 315582
Souhrn
Rozhraní.NET Framework k Microsoft usnadňuje volání funkce asynchronně. Asynchronní volání funkcí způsobí, že systém spustit na pozadí v sekundární podprocesu při volání funkce nadále provádět jiné operace. Ve volání funkce typické (synchronní) je funkce spuštěna ve stejném podprocesu, který provedeno volání okamžitě. Volání funkce čeká na dokončení volání a přijímá výsledky volání před pokračováním. Naopak při provádění asynchronního volání načtení výsledků asynchronní volání později. Tento článek ukazuje, jak to provést pomocí jazyka Visual C#.

back to the top

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 rozhraní .NET nebo Visual Studio 2005
Tento článek předpokládá, že jste obeznámeni s následující témata:
  • Volání metody v jazyce Visual C#
  • Jak používat delegáty
back to the top

Jak vytvořit asynchronní volání

Asynchronní volání jsou uskutečněna pomocí delegátů. Delegát je objekt, který obaluje funkce. Delegáti poskytnout synchronní funkci a také poskytuje metody pro volání funkce zabalené asynchronně. Tyto metody jsou BeginInvoke() a EndInvoke(). Seznamy parametrů těchto metod se liší v závislosti na podpis funkce, která obaluje delegáta. Všimněte si, že funkce IntelliSense rozhraní .NET Visual Studio nezobrazí BeginInvoke() a EndInvoke(), tak je při psaní budou zobrazovat v seznamech funkce nezobrazí.

BeginInvoke() se používá k zahájení asynchronního volání. Má stejné parametry jako funkci zalamování plus dva další parametry, které budou popsány dále v tomto článku. BeginInvoke() vrátí hodnotu okamžitě a nečeká dokončení asynchronního volání. BeginInvoke() vrátí objekt IAsyncResult .

Funkce EndInvoke() se používá k načtení výsledků asynchronní volání. Může být volána, kdykoli po BeginInvoke(). Pokud asynchronní volání dosud nebyl dokončen, EndInvoke() blokuje dokud nebude dokončena. Obsahuje parametry funkce EndInvoke()Out a REF parametry, které má funkci zalamování, plus IAsyncResult objekt, který je vrácen vlastností BeginInvoke().

Následuje příklad delegáta a jeho metody BeginInvoke() a 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) ;				
Existují čtyři běžných způsobech použití asynchronní volání BeginInvoke() a EndInvoke() . Po volání BeginInvoke(), můžete:
  • Můžete také provést některé další práce a pak použít EndInvoke().
  • Získat popisovač WaitHandle obstarává objekt IAsyncResult , pomocí jeho WaitOne metoda blokuje, dokud popisovač WaitHandle je signalizováno následným tichem a potom volat EndInvoke().
  • Objekt IAsyncResult dotazování k určení po dokončení asynchronního volání andthen volání EndInvoke().
  • Mají systémové volání funkce zpětného volání, které zadáte. Toto volání funkce zpětného volání EndInvoke() a procesy výsledky asynchronní volání, kdy itcompletes.
Následující ukázky kódu demonstrují těchto vzorků call a oproti 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() simuluje funkci, která spustí v režimu spánku dlouhou dobu. Vrátí čas spánku a ID podprocesu, který spustí jej. Pokud zavoláte ji asynchronně, zjistíte, že ID podprocesu provádění podprocesu je odlišné od volajícího vlákna.

Prvním krokem je definovat delegát, který obtéká funkce:
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í delegáta MethodDelegate . Další vzorky porovnejte to voláním asynchronně.
  1. Spusťte aplikaci Microsoft Visual Studio rozhraní .NET nebo Microsoft Visual Studio 2005.
  2. Vytvořte nový namedAsyncDemo projekt aplikace Visual C# konzoly.
  3. Přidáte třídu s názvem AsyncDemo, který je definován takto do projektu nový soubor .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 metodu DemoSyncCall() , která ukazuje, jak volat delegatesynchronously.
  4. V těle funkce Main , který sada Visual Studio automaticky vytvoří v yourproject přidejte následující kód:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoSyncCall() ;}					
  5. Stisknutím kláves CTRL + F5 spusťte aplikaci.
back to the top

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

V této části vzorku vyvolá stejnou metodu asynchronně. Je volání vzorku, který je použit pro volání BeginInvoke, některé práce na hlavní podproces a potom volat EndInvoke(). Všimněte si, že EndInvoke() nevrací až do dokončení asynchronního volání. Tento způsob volání je užitečné, pokud chcete mít volající vlákno pracovat současně probíhá asynchronní volání. Práce dojít současně s můžete zlepšit výkon mnoho aplikací. Běžné úlohy spustit asynchronně tímto způsobem jsou soubor nebo síťový provoz.
  1. Přidejte metodu AsyncDemo třídy s názvem DemoEndInvoke() . Funkce DemoEndInvoke 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. Upravte zdrojový kód pro hlavní tak, aby obsahoval následující kód:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoEndInvoke() ;}					
  3. Stisknutím kláves CTRL + F5 spusťte aplikaci.
back to the top

Ukázka 3: Volání metody asynchronně a pomocí popisovač WaitHandle wait pro volání k dokončení


V této části vzorku volá metodu asynchronně a vyčká popisovač WaitHandle volá EndInvoke(). IAsyncResult , který je vrácen vlastností BeginInvoke()AsyncWaitHandle vlastnost. Tato vlastnost vrátí popisovač WaitHandle je signalizováno následným tichem po dokončení asynchronního volání. Čekání na popisovač WaitHandle je běžnou technikou synchronizace podprocesu. Volající vlákno čeká na popisovač WaitHandle metodou WaitOne()popisovač WaitHandle. WaitOne() blokuje dokud popisovač WaitHandle je signalizováno následným tichem. Při WaitOne() vrátí, můžete provést některé další práce před voláním EndInvoke(). Stejně jako předchozí ukázka Tato technika je užitečná při provádění operace souboru nebo v síti, které by jinak blokuje volající vlákno hlavní.
  1. Přidáte funkci s názvem DemoWaitHandle() do třídy AsyncDemo . Funkce DemoWaitHandle() 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. Upravte zdrojový kód pro hlavní tak, aby obsahoval následující kód:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoWaitHandle () ;}					
  3. Stisknutím kláves CTRL + F5 spusťte aplikaci.
back to the top

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

V této části vzorku dotazuje objekt IAsyncResult zjistit po dokončení asynchronního volání. IAsyncResult objekt, který je vrácen vlastností BeginInvoke()IsCompleted vlastnost, která vrací hodnotu True , po dokončení asynchronního volání. Volejte na EndInvoke(). Tento způsob volání je užitečné, pokud aplikace provádí průběžné, nechcete blokováno voláním funkce dlouhotrvající. Aplikace systému Windows je příkladem. Hlavní vlákno aplikace systému Windows mohou nadále během asynchronní volání provede zpracování vstupu uživatele. IsCompleted zobrazíte, pokud byla dokončena volání může pravidelně zkontrolovat. Pokud IsCompleted vrátí hodnotu Truevolá funkci EndInvoke . Protože EndInvoke() blokuje až do dokončení asynchronní operace, aplikace nevyvolá ji nezná, že na dokončení operace.
  1. Přidáte funkci s názvem DemoPolling() do třídy AsyncDemo . Funkce DemoPolling() ukazuje, jak volat delegát asynchronně anduse dotazování zobrazíte, 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. Upravte zdrojový kód pro hlavní. Obsah funkce nahraďte následující kód:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoPolling () ;}					
  3. Stisknutím kláves CTRL + F5 spusťte aplikaci.
back to the top

Ukázka 5: Provedení zpětného volání při dokončení asynchronní metody

V této části vzorku poskytuje delegáta zpětného volání funkce BeginInvoke() , která spustí systém po dokončení asynchronního volání. Zpětné volání EndInvoke() a zpracovává výsledky asynchronní volání. Tento způsob volání je užitečné v případě, že není nutné zpracovat výsledky volání podprocesu, který iniciuje asynchronní volání. Systém vyvolá zpětné volání v podprocesu, než původní podproces dokončení asynchronního volání.

Chcete-li použít tento způsob volání, musí uplynout typu AsyncCallback delegáta jako druhé poslední parametr BeginInvoke() funkce. BeginInvoke() má také poslední parametr typu objektu , do kterého můžete předat libovolný objekt. Tento objekt je k dispozici funkce zpětného volání při vyvolání. Jedno důležité použití tohoto parametru je předat delegáta, který slouží k zahájení volání. Funkci zpětného volání můžete poté použít funkci EndInvoke() tohoto delegáta k dokončení volání. Tento způsob volání je ukázáno níže.
  1. Přidáte dvě metody s názvem DemoCallback() a MyAsyncCallback() třídy AsyncDemo . DemoCallback() metoda ukazuje, jak volat delegát asynchronně. Ituses delegát zalomení MyAsyncCallback() metodu, která volá systém, kdy asynchronní operationcompletes. 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. Upravte zdrojový kód pro hlavní. Obsah funkce nahraďte následující kód:
    static void Main(string[] args){	AsyncDemo ad = new AsyncDemo () ;	ad.DemoCallback() ;}					
  3. Stisknutím kláves CTRL + F5 spusťte aplikaci.
back to the top

Upozornění: Tento článek je přeložený automaticky

Vlastnosti

ID článku: 315582 - Poslední kontrola: 11/14/2015 02:36:00 - Revize: 7.0

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

  • kbhowtomaster kbmt KB315582 KbMtcs
Váš názor
head")[0].appendChild(m); -scope"> Paraguay - Español
Venezuela - Español
1.microsoft.com/c.gif?DI=4050&did=1&t=">id=1&t=">pt" async=""> var varAutoFirePV = 1; var varClickTracking = 1; var varCustomerTracking = 1; var Route = "76500"; var Ctrl = ""; document.write(" >>ow.location.protocol) + "//c.microsoft.com/ms.js'><\/script>"); >