AsyncResult.AsyncWaitHandle 속성

정의

네임스페이스:

System.Runtime.Remoting.Messaging

어셈블리:

mscorlib.dll

Win32 동기화 핸들을 캡슐화하고 다양한 동기화 체계를 구현할 수 있는 WaitHandle을 가져옵니다.

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

public virtual System.Threading.WaitHandle AsyncWaitHandle { get; }

member this.AsyncWaitHandle : System.Threading.WaitHandle

Public Overridable ReadOnly Property AsyncWaitHandle As WaitHandle

속성 값

WaitHandle

Win32 동기화 핸들을 캡슐화하고 다양한 동기화 체계를 구현할 수 있는 WaitHandle입니다.

구현

AsyncWaitHandle

예제

다음 예제에서는 사용 하는 방법에 설명 합니다 AsyncWaitHandle 가져올 속성은 WaitHandle, 및 대리자에 대 한 비동기 호출 대기 하는 방법. 비동기 호출이 완료되면 WaitHandle 은 신호를 받으며 WaitOne 메서드를 호출하여 대기할 수 있습니다.

이 예제에서는 두 개의 클래스를 비동기적으로 호출 되는 메서드를 포함 하는 클래스의 구성 및 포함 된 클래스는 Main 메서드 호출을 수행 하 합니다.

자세한 내용 및 대리자를 사용 하 여 메서드를 비동기적으로 호출 하는 더 많은 예제를 참조 하세요 Calling Synchronous Methods Asynchronously합니다.

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

설명

WaitHandle 이 반환한 메서드는 비동기 작업이 완료 되 면 자동으로 신호를 합니다.

대기 핸들이 닫혀 있지 않으면 자동으로 호출 하는 경우 EndInvoke 는 비동기 메서드 호출을 수행 하는 데 사용 된 대리자에서. 대기 핸들에 대한 모든 참조를 해제하면 가비지 수집에서 대기 핸들을 회수할 때 시스템 리소스가 확보됩니다. 시스템 리소스를 대기 핸들 사용을 마친 후 즉시 확보 하기 위해 호출 된 WaitHandle.Close 메서드. 삭제 가능한 개체는 명시적으로 닫히거나 삭제 하는 경우 가비지 수집 보다 효율적으로 작동 합니다.

주의

WaitHandle 에 포함 된 AsyncWaitHandle 비동기 호출이 완료 될 때까지 현재 스레드를 차단 하려면 속성을 사용할 수 있습니다. 하지만 WaitHandle 무시 됩니다 합니다 AsyncCallback하는 동안 지정 된 경우는 BeginInvoke 호출 합니다. 따라서 상황 여기서 애플리케이션 종료 하기 전에 발생할 수 있습니다는 AsyncCallback 실행이 완료 되어 경우에는 WaitHandle 는 비동기 호출이 완료 될 때까지 블록. 이러한 상황의 예에 대 한 예제를 참조 하세요. 합니다 AsyncResult 클래스를 제거 합니다 Thread.Sleep 문.

추가 정보

• WaitHandle