WaitOrTimerCallback 대리자

참조

정의

네임스페이스:: System.Threading

어셈블리:: System.Threading.ThreadPool.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

WaitHandle이 신호를 받거나 시간 초과될 때 호출될 메서드를 나타냅니다.

public delegate void WaitOrTimerCallback(System::Object ^ state, bool timedOut);

public delegate void WaitOrTimerCallback(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

콜백 메서드가 실행될 때마다 사용할 정보가 포함된 개체입니다.

timedOut: Boolean

WaitHandle 시간이 초과되면 true이고, 신호를 받으면 false입니다.

특성: ComVisibleAttribute

예제

다음 예제에서는 대리자를 사용하여 대기 핸들이 WaitOrTimerCallback 신호를 보낼 때 실행되는 콜백 메서드를 나타내는 방법을 보여 있습니다.

또한 이 예제에서는 지정된 대기 핸들이 RegisterWaitForSingleObject 신호를 수신할 때 메서드를 사용하여 지정된 콜백 메서드를 실행하는 방법을 보여줍니다. 이 예제에서 콜백 메서드는 WaitProc 대기 핸들이고 대기 핸들은 .AutoResetEvent

이 예제에서는 콜백이 TaskInfo 실행될 때 콜백에 전달되는 정보를 보관할 클래스를 정의합니다. 이 예제에서는 개체를 TaskInfo 만들고 일부 문자열 데이터를 할당합니다. 메서드에서 반환되는 값 RegisteredWaitHandle 은 콜백 메서드가 액세스할 수 RegisteredWaitHandle있도록 개체의 TaskInfo 필드에 할당됩니다Handle.RegisterWaitForSingleObject

개체 외에도 TaskInfo 메서드 호출 RegisterWaitForSingleObject 은 태스크가 대기하는 작업, 콜백 메서드를 WaitOrTimerCallback 나타내는 WaitProc 대리자, 1초 시간 제한 간격 및 여러 콜백을 지정 AutoResetEvent 합니다.

주 스레드가 메서드 Set 를 AutoResetEvent 호출하여 신호를 받으면 대리자가 WaitOrTimerCallback 호출됩니다. 이 메서드는 WaitProc 시간 초과가 발생했는지 여부를 확인하기 위해 테스트 RegisteredWaitHandle 합니다. 대기 핸들이 신호를 받았기 때문에 콜백이 호출된 경우 메서드는 WaitProc 추가 콜백을 중지하여 등록을 취소 RegisteredWaitHandle합니다. 시간 초과의 경우 작업은 계속 대기합니다. 메서드는 WaitProc 콘솔에 메시지를 인쇄하여 끝납니다.

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 를 생성자에 전달하여 대리자를 만듭니다. 메서드에 여기에 표시된 서명이 있어야 합니다.

대리자와 를 전달 WaitOrTimerCallback 하여 등록된 대기 핸들을 WaitHandle ThreadPool.RegisterWaitForSingleObject만듭니다. 콜백 메서드는 시간이 초과되거나 신호를 보낼 때마다 WaitHandle 실행됩니다.

참고

Visual Basic 사용자는 생성자를 생략 WaitOrTimerCallback 하고 콜백 메서드RegisterWaitForSingleObject를 AddressOf 전달할 때 연산자를 사용합니다. Visual Basic 올바른 대리자 생성자를 자동으로 호출합니다.

콜백 메서드에 정보를 전달하려면 필요한 정보가 포함된 개체를 만들고 등록된 대기 핸들을 RegisterWaitForSingleObject 만들 때 전달합니다. 콜백 메서드가 실행 될 때마다 매개 변수는 state 이 개체를 포함 합니다.

콜백 메서드를 사용하여 스레드 풀 스레드를 동기화하는 방법에 대한 자세한 내용은 관리되는 스레드 풀을 참조하세요.

확장 메서드

GetMethodInfo(Delegate)

지정된 대리자가 나타내는 메서드를 나타내는 개체를 가져옵니다.

적용 대상

다음을 통해 공유

WaitOrTimerCallback 대리자

정의

매개 변수

예제

설명

확장 메서드

적용 대상

추가 정보

추가 리소스