IAsyncResult.AsyncWaitHandle Propriedade
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Obtém um WaitHandle que é usado para aguardar a conclusão de uma operação assíncrona.
public:
property System::Threading::WaitHandle ^ AsyncWaitHandle { System::Threading::WaitHandle ^ get(); };public System.Threading.WaitHandle AsyncWaitHandle { get; }member this.AsyncWaitHandle : System.Threading.WaitHandlePublic ReadOnly Property AsyncWaitHandle As WaitHandleValor da propriedade
Um WaitHandle que é usado para aguardar a conclusão de uma operação assíncrona.
Exemplos
O exemplo a seguir demonstra como usar a AsyncWaitHandle propriedade para obter uma WaitHandlee como aguardar uma chamada assíncrona em um delegado. O WaitHandle é sinalizado quando a chamada assíncrona é concluída, e você pode esperar por ele chamando o método WaitOne.
O exemplo consiste em duas classes: a classe que contém o método que é chamado de forma assíncrona e a classe que contém o método Main que faz a chamada.
Para obter mais informações e mais exemplos de métodos de chamada de forma assíncrona usando delegados, consulte Chamando métodos síncronos de forma assíncrona.
using namespace System;
using namespace System::Threading;
using namespace System::Runtime::InteropServices;
namespace Examples {
namespace AdvancedProgramming {
namespace AsynchronousOperations
{
public ref class AsyncDemo
{
public:
// The method to be executed asynchronously.
String^ TestMethod(int callDuration, [OutAttribute] int% threadId)
{
Console::WriteLine("Test method begins.");
Thread::Sleep(callDuration);
threadId = Thread::CurrentThread->ManagedThreadId;
return String::Format("My call time was {0}.", callDuration);
}
};
// The delegate must have the same signature as the method
// it will call asynchronously.
public delegate String^ AsyncMethodCaller(int callDuration, [OutAttribute] int% threadId);
}}}
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 <TestMethod.dll>
using namespace System;
using namespace System::Threading;
using namespace Examples::AdvancedProgramming::AsynchronousOperations;
void main()
{
// The asynchronous method puts the thread id here.
int threadId;
// Create an instance of the test class.
AsyncDemo^ ad = gcnew AsyncDemo();
// Create the delegate.
AsyncMethodCaller^ caller = gcnew AsyncMethodCaller(ad, &AsyncDemo::TestMethod);
// Initiate the asychronous call.
IAsyncResult^ result = caller->BeginInvoke(3000,
threadId, nullptr, nullptr);
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(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.".
*/
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.".
Comentários
O valor retornado permite que o cliente aguarde a conclusão de uma operação assíncrona em vez de sondagem IsCompleted até que a operação seja concluída. O valor retornado pode ser usado para executar uma operação ou WaitAll uma WaitOneoperaçãoWaitAny.
O common language runtime fornece vários objetos que podem ser esperados, como ManualResetEvent, AutoResetEvente Mutex, todos os quais espelham primitivos de sincronização win32.
Notas aos Implementadores
O objeto que implementa IAsyncResult não precisa criar até WaitHandle que a AsyncWaitHandle propriedade seja lida. É a escolha do IAsyncResult implementador. No entanto, se o implementador for criado AsyncWaitHandle, será responsabilidade do implementador sinalizar o WaitHandle que encerrará a espera no momento apropriado. Por exemplo, AsyncResult encerra a espera em nome do chamador quando um método invocado de forma assíncrona retorna. Depois de criado, AsyncWaitHandle deve ser mantido vivo até que o usuário chame o método que conclui a operação assíncrona. Nesse momento, o objeto atrás AsyncWaitHandle pode ser descartado.
Notas aos Chamadores
Os clientes que aguardam a conclusão da operação (em vez de sondagem) usam essa propriedade para obter um objeto de sincronização para aguardar.
Observação: ao usar o BeginInvoke método de um delegado para chamar um método de forma assíncrona e obter um identificador de espera do resultado IAsyncResult, recomendamos que você feche o identificador de espera assim que terminar de usá-lo, chamando o Close() método. Se você simplesmente liberar todas as referências ao identificador de espera, os recursos do sistema serão liberados quando a coleta de lixo recuperar o identificador de espera, mas a coleta de lixo funcionar com mais eficiência quando objetos descartáveis forem explicitamente fechados ou descartados. Para obter mais informações, consulte a propriedade AsyncWaitHandle.