WaitOrTimerCallback WaitOrTimerCallback WaitOrTimerCallback WaitOrTimerCallback Delegate

定義

WaitHandle がシグナル通知されたとき、またはタイムアウトしたときに呼び出されるメソッドを表します。Represents a method to be called when a WaitHandle is signaled or times out.

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

パラメーター

state
Object Object Object Object

コールバック メソッドが実行されるたびに使用する情報を格納したオブジェクト。An object containing information to be used by the callback method each time it executes.

timedOut
Boolean Boolean Boolean Boolean

WaitHandle がタイムアウトした場合は true。シグナル通知された場合は falsetrue if the WaitHandle timed out; false if it was signaled.

継承
WaitOrTimerCallbackWaitOrTimerCallbackWaitOrTimerCallbackWaitOrTimerCallback
属性

次の例は、使用する方法を示します、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
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デリゲートとWaitHandleThreadPool.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) GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate)

指定したデリゲートによって表されるメソッドを表すオブジェクトを取得します。Gets an object that represents the method represented by the specified delegate.

適用対象

こちらもご覧ください