RegisteredWaitHandle.Unregister(WaitHandle) Método

Definição

Cancela uma operação de espera registrada emitida pelo método RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean).Cancels a registered wait operation issued by the RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean) method.

public:
 bool Unregister(System::Threading::WaitHandle ^ waitObject);
public bool Unregister (System.Threading.WaitHandle? waitObject);
public bool Unregister (System.Threading.WaitHandle waitObject);
[System.Runtime.InteropServices.ComVisible(true)]
public bool Unregister (System.Threading.WaitHandle waitObject);
member this.Unregister : System.Threading.WaitHandle -> bool
[<System.Runtime.InteropServices.ComVisible(true)>]
member this.Unregister : System.Threading.WaitHandle -> bool
Public Function Unregister (waitObject As WaitHandle) As Boolean

Parâmetros

waitObject
WaitHandle

O WaitHandle a ser sinalizado.The WaitHandle to be signaled.

Retornos

Boolean

true se a função for bem-sucedida; caso contrário, false.true if the function succeeds; otherwise, false.

Atributos

Exemplos

O exemplo a seguir mostra como usar o Unregister método para cancelar o registro de uma tarefa se um retorno de chamada ocorreu porque o identificador de espera foi sinalizado.The following example shows how to use the Unregister method to unregister a task if a callback occurred because the wait handle was signaled.

O exemplo também mostra como usar o RegisterWaitForSingleObject método para executar um método de retorno de chamada especificado quando um identificador de espera especificado é sinalizado.The example also shows how to use the RegisterWaitForSingleObject method to execute a specified callback method when a specified wait handle is signaled. Neste exemplo, o método de retorno de chamada é WaitProc , e o identificador de espera é um AutoResetEvent .In this example, the callback method is WaitProc, and the wait handle is an AutoResetEvent.

O exemplo define uma TaskInfo classe para manter as informações passadas para o retorno de chamada quando ele é executado.The example defines a TaskInfo class to hold the information that is passed to the callback when it executes. O exemplo cria um TaskInfo objeto e atribui a ele alguns dados de cadeia de caracteres.The example creates a TaskInfo object and assigns it some string data. O RegisteredWaitHandle que é retornado pelo RegisterWaitForSingleObject método é atribuído ao Handle campo do TaskInfo objeto para que o método de retorno de chamada tenha acesso ao 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.

Além de especificar TaskInfo como o objeto para passar para o método de retorno de chamada, a chamada para o RegisterWaitForSingleObject método especifica o AutoResetEvent que a tarefa aguardará, um WaitOrTimerCallback delegado que representa o WaitProc método de retorno de chamada, um intervalo de tempo limite de um segundo e vários retornos de chamada.In addition to specifying TaskInfo as the object to pass to the callback method, the call to the RegisterWaitForSingleObject method specifies the AutoResetEvent that the task will wait for, a WaitOrTimerCallback delegate that represents the WaitProc callback method, a one second time-out interval, and multiple callbacks.

Quando o thread principal sinaliza o AutoResetEvent chamando seu Set método, o WaitOrTimerCallback delegado é invocado.When the main thread signals the AutoResetEvent by calling its Set method, the WaitOrTimerCallback delegate is invoked. O WaitProc método testa RegisteredWaitHandle para determinar se um tempo limite ocorreu.The WaitProc method tests RegisteredWaitHandle to determine whether a time-out occurred. Se o retorno de chamada for invocado porque o identificador de espera foi sinalizado, o WaitProc método cancelará o registro do RegisteredWaitHandle , interrompendo retornos de chamada adicionais.If the callback was invoked because the wait handle was signaled, the WaitProc method unregisters the RegisteredWaitHandle, stopping additional callbacks. No caso de um tempo limite, a tarefa continua aguardando.In the case of a time-out, the task continues to wait. O WaitProc método termina imprimindo uma mensagem no console.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.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

Comentários

Se waitObject for especificado, ele será sinalizado somente se o RegisteredWaitHandle tiver sido cancelado com êxito.If waitObject is specified, it is signaled only if the RegisteredWaitHandle is successfully unregistered. Se um método de retorno de chamada estiver em andamento quando Unregister executado, waitObject o não será sinalizado até que o método de retorno de chamada seja concluído.If a callback method is in progress when Unregister executes, waitObject is not signaled until the callback method completes. Em particular, se um método de retorno de chamada Unregister for executado, o waitObject não será sinalizado até que esse método de retorno de chamada seja concluído.In particular, if a callback method executes Unregister, waitObject is not signaled until that callback method completes.

Aplica-se a