WaitOrTimerCallback デリゲートとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

WaitOrTimerCallback デリゲート

WaitHandle がシグナル通知されたとき、またはタイムアウトしたときに呼び出されるメソッドを表します。

名前空間: System.Threading
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

<ComVisibleAttribute(True)> _
Public Delegate Sub WaitOrTimerCallback
 ( _
    state As Object, _
    timedOut As Boolean _
)

Visual Basic (使用法)

Dim instance As New WaitOrTimerCallback(AddressOf
 HandlerMethod)

[ComVisibleAttribute(true)] 
public delegate void WaitOrTimerCallback (
    Object state,
    bool timedOut
)

C++

[ComVisibleAttribute(true)] 
public delegate void WaitOrTimerCallback (
    Object^ state, 
    bool timedOut
)

/** @delegate */
/** @attribute ComVisibleAttribute(true) */ 
public delegate void WaitOrTimerCallback (
    Object state, 
    boolean timedOut
)

JScript

JScript では、デリゲートは使用できますが、新規に宣言することはできません。

パラメータ

state: コールバックメソッドが実行されるたびに使用する情報を格納したオブジェクト。

timedOut: WaitHandle がタイムアウトした場合は true。シグナル通知された場合は false。

解説

WaitOrTimerCallback は、登録済み待機ハンドルがタイムアウトしたかシグナル通知されたときに実行するコールバックメソッドを表します。デリゲートを作成するには、WaitOrTimerCallback コンストラクタにコールバックメソッドを渡します。メソッドには、ここに示すシグネチャを付ける必要があります。

登録済み待機ハンドルを作成するには、WaitOrTimerCallback デリゲートと WaitHandle を ThreadPool.RegisterWaitForSingleObject に渡します。コールバックメソッドは、WaitHandle がタイムアウトするか、シグナル通知されるたびに実行されます。

メモ
Visual Basic のユーザーは WaitOrTimerCallback コンストラクタを省略できます。コールバックメソッドを RegisterWaitForSingleObject に渡すときは単純に AddressOf 演算子を使用できます。Visual Basic は正しいデリゲートコンストラクタを自動的に呼び出します。

コールバックメソッドに情報を渡す場合は、必要な情報を格納したオブジェクトを作成し、登録済み待機ハンドルを作成するときにこのオブジェクトを RegisterWaitForSingleObject に渡します。コールバックメソッドが実行されるたびに、state パラメータはこのオブジェクトを保持します。

コールバックメソッドを使用してスレッドプールスレッドを同期する方法の詳細については、「マネージスレッドプール」を参照してください。

使用例

Visual Basic

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

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
        );
    }
}

C++

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;
}

import System.*;
import System.Threading.*;
import System.Threading.Thread;

// TaskInfo contains data that will be passed to the callback
// method.
public class TaskInfo
{
    public RegisteredWaitHandle handle = null;
    public String otherInfo = "default";
} //TaskInfo

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.
    } //main

    // 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, boolean 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, 
            String.valueOf(Thread.get_CurrentThread().GetHashCode()),cause);
    } //WaitProc
} //Example