IAsyncResult.AsyncWaitHandle Tulajdonság

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

IAsyncResult.cs

WaitHandle Lekéri az aszinkron művelet befejezésére váró parancsot.

public:
 property System::Threading::WaitHandle ^ AsyncWaitHandle { System::Threading::WaitHandle ^ get(); };

public System.Threading.WaitHandle AsyncWaitHandle { get; }

member this.AsyncWaitHandle : System.Threading.WaitHandle

Public ReadOnly Property AsyncWaitHandle As WaitHandle

Tulajdonság értéke

WaitHandle

Egy WaitHandle aszinkron művelet befejezésére váró művelet.

Példák

Az alábbi példa bemutatja, hogyan használhatja a tulajdonságot a AsyncWaitHandle lekéréshez WaitHandle, és hogyan várhatja meg a meghatalmazott aszinkron hívásá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.

A példa két osztályból áll: az aszinkron metódust tartalmazó osztályból és a hívást kezdeményező metódust tartalmazó Main osztályból.

További információkért és a meghatalmazottak használatával aszinkron hívási módszerekre vonatkozó további példákért lásd: Szinkron metódusok aszinkron hívása.

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

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 asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000,
                out threadId, null, null);

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

            // 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.".

Megjegyzések

A visszatérési érték lehetővé teszi, hogy az ügyfél megvárja az aszinkron művelet befejezését a lekérdezés IsCompleted helyett, amíg a művelet befejeződik. A visszatérési érték egy , WaitOnevagy WaitAny művelet végrehajtására WaitAllhasználható.

A közös nyelvi futtatókörnyezet számos várható objektumot biztosít, például ManualResetEvent, AutoResetEventés Mutexamelyek mindegyike a Win32-szinkronizálási primitíveket tükrözi.

Megjegyzések az implementálókhoz

A megvalósító IAsyncResult objektumnak nem kell létrehoznia a WaitHandle tulajdonság beolvasásáig AsyncWaitHandle . Ez a végrehajtó választása IAsyncResult . Ha azonban a megvalósító létrejön AsyncWaitHandle, a végrehajtó felelőssége, hogy jelezhesse, WaitHandle hogy a megfelelő időpontban leállítja a várakozást. Például AsyncResult leállítja a várakozást a hívó nevében, amikor egy aszinkron módon meghívott metódus ad vissza. A létrehozás után életben kell tartani, AsyncWaitHandle amíg a felhasználó meg nem hívja az aszinkron műveletet lezáró metódust. Ekkor a mögöttes AsyncWaitHandle objektum elvethető.

Megjegyzések a hívókhoz

Azok az ügyfelek, amelyek a művelet befejezésére várnak (szemben a lekérdezéssel), ezzel a tulajdonságmal szereznek be egy szinkronizálási objektumot, amely tovább vár.

Megjegyzés: Ha egy BeginInvoke meghatalmazott metódusával aszinkron módon hívja meg a metódust, és az eredményből IAsyncResultkap egy várakozási fogópontot, javasoljuk, hogy a metódus meghívásával zárja be a várakozási fogópontot, amint befejezte a Close() használatát. Ha egyszerűen csak kiadja a várakozási leíróra mutató összes hivatkozást, a rendszer erőforrásai felszabadulnak, amikor a szemétgyűjtés visszavesz a várakozási fogópontból, de a szemétgyűjtés hatékonyabban működik, ha az eldobható objektumok kifejezetten bezáródnak vagy el vannak dobva. További információért lásd a AsyncWaitHandle tulajdonságot.