IAsyncResult.AsyncWaitHandle Propriedade

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

Valor de Propriedade

A WaitHandle que é usado para esperar que uma operação assíncrona seja concluída.

Exemplos

O exemplo seguinte demonstra como usar a AsyncWaitHandle propriedade para obter um WaitHandle, e como esperar por uma chamada assíncrona num delegado. O WaitHandle é sinalizado quando a chamada assíncrona é concluída, e você pode aguardar por ele chamando o WaitOne método.

O exemplo consiste em duas classes: a classe que contém o método chamado assíncrono, e a classe que contém o Main método que faz a chamada.

Para mais informações e mais exemplos de chamar métodos assíncronos usando delegados, veja Chamar Métodos Síncronos Assíncronos.

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

Observações

O valor de retorno permite ao cliente esperar que uma operação assíncrona seja concluída, em vez de fazer polling IsCompleted até à conclusão da operação. O valor de retorno pode ser usado para realizar uma WaitOne, WaitAny, ou WaitAll uma operação.

O runtime da linguagem comum fornece vários objetos esperáveis, como ManualResetEvent, AutoResetEvent, e Mutex, todos eles espelhando primitivas de sincronização do Win32.

Notas para Implementadores

O objeto que implementa IAsyncResult não precisa de criar o WaitHandle até que a AsyncWaitHandle propriedade seja lida. É a escolha do IAsyncResult implementador. No entanto, se o implementador criar AsyncWaitHandle, é responsabilidade do implementador sinalizar o WaitHandle que terminará a espera no momento apropriado. Por exemplo, AsyncResult termina a espera em nome do chamador quando um método invocado assíncronamente retorna. Uma vez criado, AsyncWaitHandle deve ser mantido ativo até que o utilizador chame o método que conclui a operação assíncrona. Nesse momento, o objeto atrás AsyncWaitHandle pode ser descartado.

Notas para Chamadores

Os clientes que aguardam que a operação seja concluída (em vez de sondar) usam esta propriedade para obter um objeto de sincronização para esperar.

Nota: Quando utiliza o BeginInvoke método de um delegado para chamar um método de forma assíncrona e obter um handle de espera a partir do resultado IAsyncResult, recomendamos que feche o handle de espera assim que terminar de o usar, chamando o Close() método. Se simplesmente libertar todas as referências à alça de espera, os recursos do sistema são libertados quando a recolha de lixo recupera a alavanca de espera, mas a recolha de lixo funciona de forma mais eficiente quando objetos descartáveis estão explicitamente fechados ou descartados. Para obter mais informações, consulte a propriedade AsyncWaitHandle.