Szinkron metódusok aszinkron meghívása

A .NET lehetővé teszi bármely metódus aszinkron meghívását. Ehhez definiálnia kell egy delegáltat, amely ugyanazzal a szignatúrával rendelkezik, mint a meghívni kívánt metódus. A közös nyelvi futtatókörnyezet automatikusan definiálja a BeginInvoke és EndInvoke metódusokat a delegált számára, a megfelelő aláírásokkal.

Feljegyzés

A .NET Compact Framework nem támogatja az aszinkron delegált hívásokat, különösen azokat BeginInvoke és EndInvoke a metódusokat.

A BeginInvoke metódus elindítja az aszinkron hívást. Ugyanazokkal a paraméterekkel rendelkezik, mint az aszinkron módon végrehajtani kívánt metódus, valamint két további választható paraméter. Az első paraméter egy AsyncCallback meghatalmazott, amely az aszinkron hívás befejeződésekor meghívandó metódusra hivatkozik. A második paraméter egy felhasználó által definiált objektum, amely adatokat ad át a visszahívási módszernek. BeginInvoke azonnal visszatér, és nem várja meg, amíg az aszinkron hívás befejeződik. BeginInvoke visszaad egy IAsyncResult, amely az aszinkron hívás előrehaladásának figyelésére használható.

A EndInvoke metódus lekéri az aszinkron hívás eredményeit. Bármikor meghívható miután BeginInvoke. Ha az aszinkron hívás nem fejeződött be, EndInvoke blokkolja a hívó szálat, amíg be nem fejeződik. Az EndInvoke paraméterei közé tartoznak az out és ref paraméterek, amelyek az aszinkron módon végrehajtandó metódushoz tartoznak (<Out>ByRef és ByRef a Visual Basic-ben), valamint a IAsyncResult által visszaadott BeginInvoke.

Feljegyzés

A Visual Studio IntelliSense funkciója megjeleníti a BeginInvoke és EndInvoke paramétereit. Ha nem Visual Studiót vagy hasonló eszközt használ, vagy ha a C#-ot használja a Visual Studióval, tekintse meg az Aszinkron programozási modell (APM) című témakört a metódusokhoz definiált paraméterek leírásához.

A jelen témakör kód példái négy gyakori módszert mutatnak be az aszinkron hívások használatára BeginInvoke és EndInvoke indítására. A hívás BeginInvoke után a következőket teheti:

• Végezz el némi munkát, majd hívd meg EndInvoke, hogy blokkoljon, amíg a hívás befejeződik.

• Szerezzen be egy WaitHandle-t a IAsyncResult.AsyncWaitHandle tulajdonság használatával, majd a WaitOne metódusával tiltsa le a végrehajtást, amíg meg nem kapja a WaitHandle jelzést, végül hívja meg a EndInvoke-t.

• Érdeklődjön a IAsyncResult által visszaadott BeginInvoke-nél, hogy megállapítsa, mikor fejeződött be az aszinkron hívás, majd hívja meg EndInvoke-t.

• Adjon át egy meghatalmazottat egy visszahívási módszerhez a következőnek BeginInvoke: . A metódus akkor lesz végrehajtva egy ThreadPool szálon, amikor az aszinkron hívás befejeződik. A visszahívási metódus meghívja a(z) EndInvoke-t.

Fontos

Függetlenül attól, hogy milyen technikát használ, mindig hívja meg a EndInvoke függvényt az aszinkron hívás befejezéséhez.

A tesztelési módszer és az aszinkron delegálás meghatározása

Az alábbi példakódok bemutatják, hogyan hívható meg ugyanaz a hosszú ideig futó metódus, TestMethodaszinkron módon. A TestMethod metódus egy konzolüzenetet jelenít meg, amely jelzi, hogy megkezdte a feldolgozást, néhány másodpercig alvó állapotban van, majd véget ér. TestMethod rendelkezik egy out paraméterrel, amely bemutatja, hogy az ilyen paraméterek hogyan vannak hozzáadva az BeginInvoke és EndInvoke aláírásainak. Hasonlóan kezelheti a ref paramétereket.

Az alábbi példakód bemutatja a TestMethod meghatározását és a AsyncMethodCaller nevű delegáltat, amely az aszinkron TestMethod hívására használható. A példakódok lefordításához meg kell adnia a TestMethod és a AsyncMethodCaller delegált definícióit.

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncDemo
    {
        // The method to be executed asynchronously.
        public string TestMethod(int callDuration, out int threadId)
        {
            Console.WriteLine("Test method begins.");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId;
            return String.Format("My call time was {0}.", callDuration.ToString());
        }
    }
    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate string AsyncMethodCaller(int callDuration, out int threadId);
}

Imports System.Threading
Imports System.Runtime.InteropServices

Namespace Examples.AdvancedProgramming.AsynchronousOperations
    Public Class AsyncDemo
        ' The method to be executed asynchronously.
        Public Function TestMethod(ByVal callDuration As Integer, _
                <Out> ByRef threadId As Integer) As String
            Console.WriteLine("Test method begins.")
            Thread.Sleep(callDuration)
            threadId = Thread.CurrentThread.ManagedThreadId()
            return String.Format("My call time was {0}.", callDuration.ToString())
        End Function
    End Class

    ' The delegate must have the same signature as the method
    ' it will call asynchronously.
    Public Delegate Function AsyncMethodCaller(ByVal callDuration As Integer, _
        <Out> ByRef threadId As Integer) As String
End Namespace

Várakozás aszinkron hívásra az EndInvoke használatával

A metódus aszinkron végrehajtásának legegyszerűbb módja, ha elindítja a metódus végrehajtását a meghatalmazott metódusának BeginInvoke meghívásával, a fő szálon végzett munka elvégzésével, majd a meghatalmazott metódusának meghívásával EndInvoke . EndInvoke blokkolhatja a hívó szálat, mert addig nem tér vissza, amíg az aszinkron hívás be nem fejeződik. Ez egy jó módszer fájl- vagy hálózati műveletekhez.

Fontos

Mivel EndInvoke blokkolhatja, soha ne hívja meg a felhasználói felületet kiszolgáló szálakból.

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain3
    {
        public static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asynchronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId} does some work.");

            // Call EndInvoke to wait for the asynchronous call to complete,
            // and to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

Imports System.Threading
Imports System.Runtime.InteropServices

Namespace Examples.AdvancedProgramming.AsynchronousOperations
    Public Class AsyncMain
        Shared Sub Main()
            ' The asynchronous method puts the thread id here.
            Dim threadId As Integer

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)

            ' Initiate the asynchronous call.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                threadId, Nothing, Nothing)

            Thread.Sleep(0)
            Console.WriteLine("Main thread {0} does some work.", _
                 Thread.CurrentThread.ManagedThreadId)

            ' Call EndInvoke to Wait for the asynchronous call to complete,
            ' and to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, result)

            Console.WriteLine("The call executed on thread {0}, with return value ""{1}"".", _
                threadId, returnValue)
        End Sub
    End Class

End Namespace

'This example produces output similar to the following:
'
'Main thread 1 does some work.
'Test method begins.
'The call executed on thread 3, with return value "My call time was 3000.".

Várakozás aszinkron hívásra a WaitHandle használatával

A WaitHandle kapható a AsyncWaitHandle tulajdonság használatával, amelyet a(z) IAsyncResult által visszaadott BeginInvoke biztosít. Az WaitHandle jelezve lesz, amikor az aszinkron hívás befejeződik, és az WaitOne metódus meghívásával meg lehet várni.

Ha aszinkron hívást használ WaitHandle, további feldolgozást végezhet az aszinkron hívás befejezése előtt vagy után, de a hívás EndInvoke előtt az eredmények lekéréséhez.

Feljegyzés

Híváskor EndInvokea várakozási fogópont nem lesz automatikusan bezárva. Ha felszabadítja a várakozási objektummal kapcsolatos összes hivatkozást, a rendszer erőforrásai felszabadulnak, amikor a szemétgyűjtés visszaigényli a várakozási objektumot. A rendszererőforrások felszabadításához, miután befejezte a várakozási fogópont használatát, hívja meg a WaitHandle.Close metódust annak eldobására. A szemétgyűjtés hatékonyabban működik, ha az eldobható tárgyakat kifejezetten megsemmisítik.

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain2
    {
        static void Main()
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asynchronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId} does some work.");

            // Wait for the WaitHandle to become signaled.
            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.
            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

Imports System.Threading
Imports System.Runtime.InteropServices

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class AsyncMain
        Shared Sub Main()
            ' The asynchronous method puts the thread id here.
            Dim threadId As Integer

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)

            ' Initiate the asynchronous call.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                threadId, Nothing, Nothing)

            Thread.Sleep(0)
            Console.WriteLine("Main thread {0} does some work.", _
                Thread.CurrentThread.ManagedThreadId)
            ' Perform additional processing here and then
            ' wait for the WaitHandle to be signaled.
            result.AsyncWaitHandle.WaitOne()

            ' Call EndInvoke to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, result)

            ' Close the wait handle.
            result.AsyncWaitHandle.Close()

            Console.WriteLine("The call executed on thread {0}, with return value ""{1}"".", _
                threadId, returnValue)
        End Sub
    End Class
End Namespace

'This example produces output similar to the following:
'
'Main thread 1 does some work.
'Test method begins.
'The call executed on thread 3, with return value "My call time was 3000.".

Lekérdezés aszinkron hívásvégzéshez

Az aszinkron hívás befejezésének megállapításához használhatja a IsCompleted tulajdonságát a IAsyncResult visszaadott BeginInvoke-nek. Ezt akkor teheti meg, ha a felhasználói felületet kiszolgáló szál aszinkron hívását kezdeményezi. A befejezési lekérdezés lehetővé teszi, hogy a hívó szál folytassa a végrehajtást, miközben az aszinkron hívás egy ThreadPool szálon fut.

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain
    {
        static void Main() {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asynchronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

            // Poll while simulating work.
            while(result.IsCompleted == false) {
                Thread.Sleep(250);
                Console.Write(".");
            }

            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Test method begins.
.............
The call executed on thread 3, with return value "My call time was 3000.".
 */

Imports System.Threading
Imports System.Runtime.InteropServices

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class AsyncMain
        Shared Sub Main()
            ' The asynchronous method puts the thread id here.
            Dim threadId As Integer

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)

            ' Initiate the asynchronous call.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                threadId, Nothing, Nothing)

            ' Poll while simulating work.
            While result.IsCompleted = False
                Thread.Sleep(250)
                Console.Write(".")
            End While

            ' Call EndInvoke to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, result)

            Console.WriteLine(vbCrLf & _
                "The call executed on thread {0}, with return value ""{1}"".", _
                threadId, returnValue)
        End Sub
    End Class
End Namespace

' This example produces output similar to the following:
'
'Test method begins.
'.............
'The call executed on thread 3, with return value "My call time was 3000.".

Visszahívási metódus végrehajtása aszinkron hívás befejeződésekor

Ha az aszinkron hívást kezdeményező szálnak nem kell az eredményeket feldolgozó szálnak lennie, a hívás befejezésekor végrehajthat egy visszahívási módszert. A visszahívási metódus egy ThreadPool szálon lesz végrehajtva.

A visszahívási metódus használatához át kell adnia BeginInvoke egy AsyncCallback delegáltat, amely a visszahívási metódust képviseli. Olyan objektumot is átadhat, amely a visszahívási módszer által használandó információkat tartalmazza. A visszahívási metódusban a IAsyncResultvisszahívási metódus egyetlen paraméterét egy AsyncResult objektumra vetheti. Ezután a AsyncResult.AsyncDelegate tulajdonság használatával lekérheti a hívás indításához használt meghatalmazottat, hogy meghívhassa EndInvoke.

Megjegyzések a példához:

• A threadId paramétere TestMethod egy out paraméter ([<Out>ByRef a Visual Basicben), ezért a bemeneti értékét soha nem használja a TestMethod. Egy próbaváltozót ad át a BeginInvoke hívásnak. Ha a threadId paraméter ref lett volna (ByRef a Visual Basicben), akkor a változónak osztályszintű mezőnek kellene lennie, hogy mind a BeginInvoke, mind a EndInvoke-nak átadható legyen.

• Az átadott BeginInvoke állapotinformáció egy formátumsztring, amelyet a visszahívási módszer a kimeneti üzenetek formázására használ. Mivel típusként Object van megadva, az állapotinformációt a megfelelő típusra kell átalakítani, mielőtt felhasználható lenne.

• A visszahívás egy ThreadPool szálon történik. ThreadPool A szálak háttérszálak, amelyek nem futtatják az alkalmazást, ha a főszál véget ér, így a példa főszálának elég hosszú ideig kell aludnia ahhoz, hogy a visszahívás befejeződjön.

using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain4
    {
        static void Main()
        {
            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // The threadId parameter of TestMethod is an out parameter, so
            // its input value is never used by TestMethod. Therefore, a dummy
            // variable can be passed to the BeginInvoke call. If the threadId
            // parameter were a ref parameter, it would have to be a class-
            // level field so that it could be passed to both BeginInvoke and
            // EndInvoke.
            int dummy = 0;

            // Initiate the asynchronous call, passing three seconds (3000 ms)
            // for the callDuration parameter of TestMethod; a dummy variable
            // for the out parameter (threadId); the callback delegate; and
            // state information that can be retrieved by the callback method.
            // In this case, the state information is a string that can be used
            // to format a console message.
            IAsyncResult result = caller.BeginInvoke(3000,
                out dummy,
                new AsyncCallback(CallbackMethod),
                "The call executed on thread {0}, with return value \"{1}\".");

            Console.WriteLine($"The main thread {Thread.CurrentThread.ManagedThreadId} continues to execute...");

            // The callback is made on a ThreadPool thread. ThreadPool threads
            // are background threads, which do not keep the application running
            // if the main thread ends. Comment out the next line to demonstrate
            // this.
            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");
        }

        // The callback method must have the same signature as the
        // AsyncCallback delegate.
        static void CallbackMethod(IAsyncResult ar)
        {
            // Retrieve the delegate.
            AsyncResult result = (AsyncResult) ar;
            AsyncMethodCaller caller = (AsyncMethodCaller) result.AsyncDelegate;

            // Retrieve the format string that was passed as state
            // information.
            string formatString = (string) ar.AsyncState;

            // Define a variable to receive the value of the out parameter.
            // If the parameter were ref rather than out then it would have to
            // be a class-level field so it could also be passed to BeginInvoke.
            int threadId = 0;

            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.
            Console.WriteLine(formatString, threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

The main thread 1 continues to execute...
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
The main thread ends.
 */

Imports System.Threading
Imports System.Runtime.Remoting.Messaging

Namespace Examples.AdvancedProgramming.AsynchronousOperations

    Public Class AsyncMain

        Shared Sub Main()

            ' Create an instance of the test class.
            Dim ad As New AsyncDemo()

            ' Create the delegate.
            Dim caller As New AsyncMethodCaller(AddressOf ad.TestMethod)

            ' The threadId parameter of TestMethod is an <Out> parameter, so
            ' its input value is never used by TestMethod. Therefore, a dummy
            ' variable can be passed to the BeginInvoke call. If the threadId
            ' parameter were a ByRef parameter, it would have to be a class-
            ' level field so that it could be passed to both BeginInvoke and 
            ' EndInvoke.
            Dim dummy As Integer = 0

            ' Initiate the asynchronous call, passing three seconds (3000 ms)
            ' for the callDuration parameter of TestMethod; a dummy variable 
            ' for the <Out> parameter (threadId); the callback delegate; and
            ' state information that can be retrieved by the callback method.
            ' In this case, the state information is a string that can be used
            ' to format a console message.
            Dim result As IAsyncResult = caller.BeginInvoke(3000, _
                dummy, _
                AddressOf CallbackMethod, _
                "The call executed on thread {0}, with return value ""{1}"".")

            Console.WriteLine("The main thread {0} continues to execute...", _
                Thread.CurrentThread.ManagedThreadId)

            ' The callback is made on a ThreadPool thread. ThreadPool threads
            ' are background threads, which do not keep the application running
            ' if the main thread ends. Comment out the next line to demonstrate
            ' this.
            Thread.Sleep(4000)

            Console.WriteLine("The main thread ends.")
        End Sub

        ' The callback method must have the same signature as the
        ' AsyncCallback delegate.
        Shared Sub CallbackMethod(ByVal ar As IAsyncResult)
            ' Retrieve the delegate.
            Dim result As AsyncResult = CType(ar, AsyncResult)
            Dim caller As AsyncMethodCaller = CType(result.AsyncDelegate, AsyncMethodCaller)

            ' Retrieve the format string that was passed as state 
            ' information.
            Dim formatString As String = CType(ar.AsyncState, String)

            ' Define a variable to receive the value of the <Out> parameter.
            ' If the parameter were ByRef rather than <Out> then it would have to
            ' be a class-level field so it could also be passed to BeginInvoke.
            Dim threadId As Integer = 0

            ' Call EndInvoke to retrieve the results.
            Dim returnValue As String = caller.EndInvoke(threadId, ar)

            ' Use the format string to format the output message.
            Console.WriteLine(formatString, threadId, returnValue)
        End Sub
    End Class
End Namespace

' This example produces output similar to the following:
'
'The main thread 1 continues to execute...
'Test method begins.
'The call executed on thread 3, with return value "My call time was 3000.".
'The main thread ends.

Lásd még

• Delegate
• Eseményalapú aszinkron minta (EAP)