Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

ThreadPool.RegisterWaitForSingleObject Method

Registers a delegate that is waiting for a WaitHandle.

Overload List

Registers a delegate that is waiting for a WaitHandle, using a 32-bit signed integer for the time-out in milliseconds.

[Visual Basic] Overloads Public Shared Function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Integer, Boolean) As RegisteredWaitHandle
[C#] public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, object, int, bool);
[C++] public: static RegisteredWaitHandle* RegisterWaitForSingleObject(WaitHandle*, WaitOrTimerCallback*, Object*, int, bool);
[JScript] public static function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, int, Boolean) : RegisteredWaitHandle;

Registers a delegate that is waiting for a WaitHandle, using a 64-bit signed integer for the time-out in milliseconds.

[Visual Basic] Overloads Public Shared Function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, Long, Boolean) As RegisteredWaitHandle
[C#] public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, object, long, bool);
[C++] public: static RegisteredWaitHandle* RegisterWaitForSingleObject(WaitHandle*, WaitOrTimerCallback*, Object*, __int64, bool);
[JScript] public static function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, long, Boolean) : RegisteredWaitHandle;

Registers a delegate that is waiting for a WaitHandle, using a TimeSpan value for the time-out.

[Visual Basic] Overloads Public Shared Function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean) As RegisteredWaitHandle
[C#] public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, object, TimeSpan, bool);
[C++] public: static RegisteredWaitHandle* RegisterWaitForSingleObject(WaitHandle*, WaitOrTimerCallback*, Object*, TimeSpan, bool);
[JScript] public static function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, TimeSpan, Boolean) : RegisteredWaitHandle;

Registers a delegate that is waiting for a WaitHandle, using a 32-bit unsigned integer for the time-out in milliseconds. This method is not CLS-compliant.

[Visual Basic] Overloads Public Shared Function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean) As RegisteredWaitHandle
[C#] public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, object, uint, bool);
[C++] public: static RegisteredWaitHandle* RegisterWaitForSingleObject(WaitHandle*, WaitOrTimerCallback*, Object*, unsigned int, bool);
[JScript] public static function RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean) : RegisteredWaitHandle;

Example

[Visual Basic, C#, C++] Note   This example shows how to use one of the overloaded versions of RegisterWaitForSingleObject. For other examples that might be available, see the individual overload topics.
[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
    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

[C#] 
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 <mscorlib.dll>

using namespace System;
using namespace System::Threading;

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

    RegisteredWaitHandle* Handle;;
    String* OtherInfo;
};


__gc class Example
{
    // 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 = static_cast<TaskInfo*>(state);

        String* cause = S"TIMED OUT";
        if (!timedOut) {
            cause = S"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 != 0)
                ti->Handle->Unregister(0);
        } 

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

int main() 
{
    // 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 = S"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(0, 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(S"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;
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

See Also

ThreadPool Class | ThreadPool Members | System.Threading Namespace

Show:
© 2014 Microsoft