WaitOrTimerCallback Delegado

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Threading.ThreadPool.dll

Representa un método al que se debe llamar cuando un WaitHandle está señalado o se agota su tiempo de espera.

public delegate void WaitOrTimerCallback(System::Object ^ state, bool timedOut);

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)

Parámetros

state

Object

Objeto que contiene la información que va a utilizar el método de devolución de llamadas cada vez que se ejecute.

timedOut

Boolean

true si WaitHandle ha agotado el tiempo de espera; false si estaba señalado.

Ejemplos

En el ejemplo siguiente se muestra cómo usar el WaitOrTimerCallback delegado para representar un método de devolución de llamada que se ejecuta cuando se señala un identificador de espera.

En el ejemplo también se muestra cómo usar el RegisterWaitForSingleObject método para ejecutar un método de devolución de llamada especificado cuando se señala un identificador de espera especificado. En este ejemplo, el método de devolución de llamada es WaitProc y el identificador de espera es .AutoResetEvent

En el ejemplo se define una TaskInfo clase para contener la información que se pasa a la devolución de llamada cuando se ejecuta. En el ejemplo se crea un TaskInfo objeto y se le asignan algunos datos de cadena. El RegisteredWaitHandle que devuelve el RegisterWaitForSingleObject método se asigna al Handle campo del TaskInfo objeto , de modo que el método de devolución de llamada tenga acceso a RegisteredWaitHandle.

Además del TaskInfo objeto , la llamada al RegisterWaitForSingleObject método especifica las AutoResetEvent esperas de la tarea, un WaitOrTimerCallback delegado que representa el WaitProc método de devolución de llamada, un intervalo de tiempo de espera de un segundo y varias devoluciones de llamada.

Cuando el subproceso principal señala mediante AutoResetEvent una llamada a su Set método , se invoca al WaitOrTimerCallback delegado. El WaitProc método comprueba RegisteredWaitHandle si se ha producido un tiempo de espera. Si se invocó la devolución de llamada porque se señalizó el identificador de espera, el método anula el WaitProc registro de , RegisteredWaitHandledeteniendo más devoluciones de llamada. En el caso de un tiempo de espera, la tarea continúa esperando. El WaitProc método termina imprimiendo un mensaje en la consola.

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

Comentarios

WaitOrTimerCallback representa un método de devolución de llamada que desea ejecutar cuando un identificador de espera registrado agota el tiempo de espera o se señala. Cree el delegado pasando el método de devolución de llamada al WaitOrTimerCallback constructor . El método debe tener la firma que se muestra aquí.

Cree el identificador de espera registrado pasando el WaitOrTimerCallback delegado y un WaitHandle a ThreadPool.RegisterWaitForSingleObject. El método de devolución de llamada se ejecuta cada vez que se agota el WaitHandle tiempo de espera o se señala.

Nota:

Los usuarios de Visual Basic pueden omitir el WaitOrTimerCallback constructor y simplemente usar el AddressOf operador al pasar el método de devolución de llamada a RegisterWaitForSingleObject. Visual Basic llama automáticamente al constructor delegado correcto.

Si desea pasar información al método de devolución de llamada, cree un objeto que contenga la información necesaria y páselo al RegisterWaitForSingleObject crear el identificador de espera registrado. Cada vez que se ejecuta el método de devolución de llamada, el state parámetro contiene este objeto.

Para más información sobre el uso de métodos de devolución de llamada para sincronizar subprocesos del grupo de subprocesos, consulte El grupo de subprocesos administrados.

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.

Consulte también

• Subprocesos y subprocesamiento
• Grupo de subprocesos administrado