WaitOrTimerCallback 대리자

정의

WaitHandle이 신호를 받거나 시간 초과될 때 호출될 메서드를 나타냅니다.Represents a method to be called when a WaitHandle is signaled or times out.

public delegate void WaitOrTimerCallback(System::Object ^ state, bool timedOut);
public delegate void WaitOrTimerCallback(object state, bool timedOut);
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void WaitOrTimerCallback(object state, bool timedOut);
type WaitOrTimerCallback = delegate of obj * bool -> unit
[<System.Runtime.InteropServices.ComVisible(true)>]
type WaitOrTimerCallback = delegate of obj * bool -> unit
Public Delegate Sub WaitOrTimerCallback(state As Object, timedOut As Boolean)

매개 변수

state
Object

콜백 메서드가 실행될 때마다 사용할 정보가 포함된 개체입니다.An object containing information to be used by the callback method each time it executes.

timedOut
Boolean

WaitHandle 시간이 초과되면 true이고, 신호를 받으면 false입니다.true if the WaitHandle timed out; false if it was signaled.

상속
WaitOrTimerCallback
특성

예제

다음 예제에서는 대리자를 사용 하 여 WaitOrTimerCallback 대기 핸들의 신호를 받을 때 실행 되는 콜백 메서드를 나타내는 방법을 보여 줍니다.The following example shows how to use the WaitOrTimerCallback delegate to represent a callback method that is executed when a wait handle is signaled.

또한이 예제에서는 RegisterWaitForSingleObject 지정 된 대기 핸들에 신호를 보낼 때 메서드를 사용 하 여 지정 된 콜백 메서드를 실행 하는 방법을 보여 줍니다.The example also shows how to use the RegisterWaitForSingleObject method to execute a specified callback method when a specified wait handle is signaled. 이 예제에서 콜백 메서드는이 WaitProc 고 대기 핸들은 AutoResetEvent 입니다.In this example, the callback method is WaitProc and the wait handle is an AutoResetEvent.

예제에서는 TaskInfo 실행 시 콜백에 전달 되는 정보를 포함 하는 클래스를 정의 합니다.The example defines a TaskInfo class to hold the information that is passed to the callback when it executes. 이 예에서는 개체를 만들고 TaskInfo 일부 문자열 데이터를 할당 합니다.The example creates a TaskInfo object and assigns it some string data. RegisteredWaitHandle메서드에 의해 반환 되는는 RegisterWaitForSingleObject Handle 개체의 필드에 할당 TaskInfo 되므로 콜백 메서드가에 액세스할 수 있습니다 RegisteredWaitHandle .The RegisteredWaitHandle that is returned by the RegisterWaitForSingleObject method is assigned to the Handle field of the TaskInfo object, so that the callback method has access to the RegisteredWaitHandle.

개체 외에도 TaskInfo 메서드 호출은 태스크가 대기 하는 RegisterWaitForSingleObject AutoResetEvent , WaitOrTimerCallback 콜백 메서드를 나타내는 대리자 WaitProc , 1 초 시간 제한 간격 및 여러 콜백을 지정 합니다.In addition to the TaskInfo object, the call to the RegisterWaitForSingleObject method specifies the AutoResetEvent the task waits on, a WaitOrTimerCallback delegate that represents the WaitProc callback method, a one-second timeout interval, and multiple callbacks.

주 스레드가 AutoResetEvent 메서드를 호출 하 여에 신호 Set 를 전달 하면 WaitOrTimerCallback 대리자가 호출 됩니다.When the main thread signals the AutoResetEvent by calling its Set method, the WaitOrTimerCallback delegate is invoked. WaitProc메서드는 RegisteredWaitHandle 시간 제한이 발생 했는지 여부를 테스트 합니다.The WaitProc method tests RegisteredWaitHandle to determine whether a timeout occurred. 대기 핸들이 신호를 받은 후 콜백이 호출 된 경우 WaitProc 메서드는의 등록을 취소 RegisteredWaitHandle 하 고 추가 콜백을 중지 합니다.If the callback was invoked because the wait handle was signaled, the WaitProc method unregisters the RegisteredWaitHandle, stopping further callbacks. 시간 초과가 발생 하는 경우 작업은 대기를 계속 합니다.In the case of a timeout, the task continues waiting. WaitProc메서드는 콘솔에 메시지를 출력 하 여 종료 됩니다.The WaitProc method ends by printing a message to the console.

using namespace System;
using namespace System::Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public ref class TaskInfo
{
public:
   TaskInfo()
   {
      Handle = nullptr;
      OtherInfo = "default";
   }

   RegisteredWaitHandle^ Handle;
   String^ OtherInfo;
};

ref class Example
{
public:

   // The callback method executes when the registered wait times out,
   // or when the WaitHandle (in this case AutoResetEvent) is signaled.
   // WaitProc unregisters the WaitHandle the first time the event is 
   // signaled.
   static void WaitProc( Object^ state, bool timedOut )
   {
      
      // The state Object must be cast to the correct type, because the
      // signature of the WaitOrTimerCallback delegate specifies type
      // Object.
      TaskInfo^ ti = static_cast<TaskInfo^>(state);
      String^ cause = "TIMED OUT";
      if (  !timedOut )
      {
         cause = "SIGNALED";
         
         // If the callback method executes because the WaitHandle is
         // signaled, stop future execution of the callback method
         // by unregistering the WaitHandle.
         if ( ti->Handle != nullptr )
                  ti->Handle->Unregister( nullptr );
      }

      Console::WriteLine( "WaitProc( {0}) executes on thread {1}; cause = {2}.", ti->OtherInfo, Thread::CurrentThread->GetHashCode(), cause );
   }

};

int main()
{
   
   // The main thread uses AutoResetEvent to signal the
   // registered wait handle, which executes the callback
   // method.
   AutoResetEvent^ ev = gcnew AutoResetEvent( false );
   TaskInfo^ ti = gcnew TaskInfo;
   ti->OtherInfo = "First task";
   
   // The TaskInfo for the task includes the registered wait
   // handle returned by RegisterWaitForSingleObject.  This
   // allows the wait to be terminated when the object has
   // been signaled once (see WaitProc).
   ti->Handle = ThreadPool::RegisterWaitForSingleObject( ev, gcnew WaitOrTimerCallback( Example::WaitProc ), ti, 1000, false );
   
   // The main thread waits three seconds, to demonstrate the
   // time-outs on the queued thread, and then signals.
   Thread::Sleep( 3100 );
   Console::WriteLine( "Main thread signals." );
   ev->Set();
   
   // The main thread sleeps, which should give the callback
   // method time to execute.  If you comment out this line, the
   // program usually ends before the ThreadPool thread can execute.
   Thread::Sleep( 1000 );
   
   // If you start a thread yourself, you can wait for it to end
   // by calling Thread::Join.  This option is not available with 
   // thread pool threads.
   return 0;
}

using System;
using System.Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public class TaskInfo {
    public RegisteredWaitHandle Handle = null;
    public string OtherInfo = "default";
}

public class Example {
    public static void Main(string[] args) {
        // The main thread uses AutoResetEvent to signal the
        // registered wait handle, which executes the callback
        // method.
        AutoResetEvent ev = new AutoResetEvent(false);

        TaskInfo ti = new TaskInfo();
        ti.OtherInfo = "First task";
        // The TaskInfo for the task includes the registered wait
        // handle returned by RegisterWaitForSingleObject.  This
        // allows the wait to be terminated when the object has
        // been signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject(
            ev,
            new WaitOrTimerCallback(WaitProc),
            ti,
            1000,
            false
        );

        // The main thread waits three seconds, to demonstrate the
        // time-outs on the queued thread, and then signals.
        Thread.Sleep(3100);
        Console.WriteLine("Main thread signals.");
        ev.Set();

        // The main thread sleeps, which should give the callback
        // method time to execute.  If you comment out this line, the
        // program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000);
        // If you start a thread yourself, you can wait for it to end
        // by calling Thread.Join.  This option is not available with 
        // thread pool threads.
    }
   
    // The callback method executes when the registered wait times out,
    // or when the WaitHandle (in this case AutoResetEvent) is signaled.
    // WaitProc unregisters the WaitHandle the first time the event is 
    // signaled.
    public static void WaitProc(object state, bool timedOut) {
        // The state object must be cast to the correct type, because the
        // signature of the WaitOrTimerCallback delegate specifies type
        // Object.
        TaskInfo ti = (TaskInfo) state;

        string cause = "TIMED OUT";
        if (!timedOut) {
            cause = "SIGNALED";
            // If the callback method executes because the WaitHandle is
            // signaled, stop future execution of the callback method
            // by unregistering the WaitHandle.
            if (ti.Handle != null)
                ti.Handle.Unregister(null);
        } 

        Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.",
            ti.OtherInfo, 
            Thread.CurrentThread.GetHashCode().ToString(), 
            cause
        );
    }
}
Imports System.Threading

' TaskInfo contains data that will be passed to the callback
' method.
Public Class TaskInfo
    public Handle As RegisteredWaitHandle = Nothing
    public OtherInfo As String = "default"
End Class

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The main thread uses AutoResetEvent to signal the
        ' registered wait handle, which executes the callback
        ' method.
        Dim ev As New AutoResetEvent(false)

        Dim ti As New TaskInfo()
        ti.OtherInfo = "First task"
        ' The TaskInfo for the task includes the registered wait
        ' handle returned by RegisterWaitForSingleObject.  This
        ' allows the wait to be terminated when the object has
        ' been signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject( _
            ev, _
            New WaitOrTimerCallback(AddressOf WaitProc), _
            ti, _
            1000, _
            false _
        )

        ' The main thread waits about three seconds, to demonstrate 
        ' the time-outs on the queued task, and then signals.
        Thread.Sleep(3100)
        Console.WriteLine("Main thread signals.")
        ev.Set()

        ' The main thread sleeps, which should give the callback
        ' method time to execute.  If you comment out this line, the
        ' program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000)
        ' If you start a thread yourself, you can wait for it to end
        ' by calling Thread.Join.  This option is not available with 
        ' thread pool threads.
    End Sub
   
    ' The callback method executes when the registered wait times out,
    ' or when the WaitHandle (in this case AutoResetEvent) is signaled.
    ' WaitProc unregisters the WaitHandle the first time the event is 
    ' signaled.
    Public Shared Sub WaitProc(state As Object, timedOut As Boolean)
        ' The state object must be cast to the correct type, because the
        ' signature of the WaitOrTimerCallback delegate specifies type
        ' Object.
        Dim ti As TaskInfo = CType(state, TaskInfo)

        Dim cause As String = "TIMED OUT"
        If Not timedOut Then
            cause = "SIGNALED"
            ' If the callback method executes because the WaitHandle is
            ' signaled, stop future execution of the callback method
            ' by unregistering the WaitHandle.
            If Not ti.Handle Is Nothing Then
                ti.Handle.Unregister(Nothing)
            End If
        End If 

        Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.", _
            ti.OtherInfo, _
            Thread.CurrentThread.GetHashCode().ToString(), _
            cause _
        )
    End Sub
End Class

설명

WaitOrTimerCallback 등록 된 대기 핸들의 시간이 초과 되거나 신호를 받을 때 실행 하려는 콜백 메서드를 나타냅니다.WaitOrTimerCallback represents a callback method that you want to execute when a registered wait handle times out or is signaled. 콜백 메서드를 생성자에 전달 하 여 대리자를 만듭니다 WaitOrTimerCallback .Create the delegate by passing your callback method to the WaitOrTimerCallback constructor. 메서드에는 여기에 표시 된 서명이 있어야 합니다.Your method must have the signature shown here.

대리자 및를에 전달 하 여 등록 된 대기 핸들을 만듭니다 WaitOrTimerCallback WaitHandle ThreadPool.RegisterWaitForSingleObject .Create the registered wait handle by passing the WaitOrTimerCallback delegate and a WaitHandle to ThreadPool.RegisterWaitForSingleObject. 콜백 메서드는 시간이 WaitHandle 초과 되거나 신호를 받을 때마다 실행 됩니다.Your callback method executes each time the WaitHandle times out or is signaled.

참고

사용자 Visual Basic WaitOrTimerCallback 생성자를 생략할 수 있으며, AddressOf 콜백 메서드를에 전달 하는 경우에만 연산자를 사용 RegisterWaitForSingleObject 합니다.Visual Basic users can omit the WaitOrTimerCallback constructor, and simply use the AddressOf operator when passing the callback method to RegisterWaitForSingleObject. Visual Basic은 올바른 대리자 생성자를 자동으로 호출 합니다.Visual Basic automatically calls the correct delegate constructor.

콜백 메서드에 정보를 전달 하려는 경우 필요한 정보를 포함 하는 개체를 만들고 RegisterWaitForSingleObject 등록 된 대기 핸들을 만들 때에 전달 합니다.If you want to pass information to your callback method, create an object that contains the necessary information and pass it to RegisterWaitForSingleObject when you create the registered wait handle. 콜백 메서드가 실행 될 때마다 state 매개 변수는이 개체를 포함 합니다.Each time your callback method executes, the state parameter contains this object.

콜백 메서드를 사용 하 여 스레드 풀 스레드를 동기화 하는 방법에 대 한 자세한 내용은 관리 되는 스레드 풀을 참조 하세요.For more information about using callback methods to synchronize thread pool threads, see The managed thread pool.

확장 메서드

GetMethodInfo(Delegate)

지정된 대리자가 나타내는 메서드를 나타내는 개체를 가져옵니다.Gets an object that represents the method represented by the specified delegate.

적용 대상

추가 정보