RegisteredWaitHandle.Unregister Method

Parameters

• waitObject
  Type: System.Threading.WaitHandle
  The WaitHandle to be signaled.

Return Value

Type: System.Boolean
true if the function succeeds; otherwise, false.

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 OutputBlock As System.Windows.Controls.TextBlock = Nothing
End Class 

Public Class Example

    ' The Demo method runs the example. It sets up an event handler to 
    ' signal the wait handle, saves the TextBlock that is  used for 
    ' output, and finally registers the wait handle.
    Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock) 

        outputBlock.Text = "Click here signal the wait handle." + vbCrLf

        ' Create the wait handle that the example waits on.
        Dim ev As New AutoResetEvent(False)

        ' Set up an event handler to signal the wait handle when the 
        ' TextBlock is clicked.
        AddHandler outputBlock.MouseLeftButtonUp, Function (sender As Object, _
             e As System.Windows.Input.MouseButtonEventArgs) ev.Set()

        ' Create a TaskInfo and save the TextBlock that the example uses
        ' for output.
        Dim ti As New TaskInfo()
        ti.OutputBlock = outputBlock

        ' Set the Handle property of the TaskInfo to the registered wait
        ' handle that is returned by RegisterWaitForSingleObject. This 
        ' enables the wait to be terminated when the handle has been 
        ' signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject( _
            ev, _
            New WaitOrTimerCallback(AddressOf WaitProc), _
            ti, _
            1000, _
            False)

    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(ByVal state As Object, ByVal timedOut As Boolean) 
        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.
            ti.Handle.Unregister(Nothing)
        End If

        ' A UI element can be accessed safely only if the code is run on
        ' the main UI thread, by calling the BeginInvoke method for the 
        ' UI element's Dispatcher. The following code creates a generic
        ' Action delegate (with parameter types TextBlock and String) to
        ' invoke the DisplayOut helper method, and then calls the 
        ' BeginInvoke method, passing the delegate, the TextBlock, and 
        ' the reason the callback was called. 
        Dim display As New Action(Of System.Windows.Controls.TextBlock, String)( _
                AddressOf DisplayOutput)

        ti.OutputBlock.Dispatcher.BeginInvoke(display, ti.OutputBlock, cause)

    End Sub

    ' The Dispatcher.BeginInvoke method runs this helper method on the 
    ' UI thread, so it can safely access the TextBlock that is used to 
    ' display the output.
    Private Shared Sub DisplayOutput(ByVal outputBlock As _
        System.Windows.Controls.TextBlock, ByVal cause As String)

        outputBlock.Text &= _
            String.Format("WaitProc is running; cause = {0}." & vbLf, cause)
    End Sub 
End Class 

' This example produces output similar to the following:
'
'Click here to signal the wait handle.
'WaitProc is running; cause = TIMED OUT.
'WaitProc is running; cause = TIMED OUT.
'WaitProc is running; cause = TIMED OUT.
'WaitProc is running; cause = SIGNALED.

using System;
using System.Threading;

// TaskInfo contains data that will be passed to the callback 
// method.
public class TaskInfo
{
   public RegisteredWaitHandle Handle = null;
   public System.Windows.Controls.TextBlock OutputBlock = null;
}

public class Example
{
    // The Demo method runs the example. It sets up an event handler to 
    // signal the wait handle, saves the TextBlock that is  used for 
    // output, and finally registers the wait handle.
    public static void Demo(System.Windows.Controls.TextBlock outputBlock)
    {
        outputBlock.Text = "Click here signal the wait handle.\r\n";

        // Create the wait handle that the example waits on.
        AutoResetEvent ev = new AutoResetEvent(false);

        // Set up an event handler to signal the wait handle when the 
        // TextBlock is clicked.
        outputBlock.MouseLeftButtonUp += (object sender, 
            System.Windows.Input.MouseButtonEventArgs e) => ev.Set();

        // Create a TaskInfo and save the TextBlock that the example uses
        // for output.
        TaskInfo ti = new TaskInfo();
        ti.OutputBlock = outputBlock;

        // Set the Handle property of the TaskInfo to the registered wait
        // handle that is returned by RegisterWaitForSingleObject. This 
        // enables the wait to be terminated when the handle has been 
        // signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject(
            ev,
            new WaitOrTimerCallback(WaitProc),
            ti,
            1000,
            false
        );
    }

    // 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)
    {
        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.
            ti.Handle.Unregister(null);
        }

        ti.OutputBlock.Dispatcher.BeginInvoke(delegate () {
            ti.OutputBlock.Text += 
                String.Format("WaitProc is running; cause = {0}.\n", cause);
        });
    }
}

/* This example produces output similar to the following:

Click here to signal the wait handle.
WaitProc is running; cause = TIMED OUT.
WaitProc is running; cause = TIMED OUT.
WaitProc is running; cause = TIMED OUT.
WaitProc is running; cause = SIGNALED.
 */