Exportar (0) Imprimir
Expandir todo

ThreadPool.RegisterWaitForSingleObject (Método) (WaitHandle, WaitOrTimerCallback, Object, UInt32, Boolean)

Registra un delegado que va a esperar a una clase WaitHandle, especificando un entero de 32 bits sin signo para representar el tiempo de espera en milisegundos.

Este método no es compatible con CLS.  

Espacio de nombres: System.Threading
Ensamblado: mscorlib (en mscorlib.dll)

[CLSCompliantAttribute(false)] 
public static RegisteredWaitHandle RegisterWaitForSingleObject (
	WaitHandle waitObject,
	WaitOrTimerCallback callBack,
	Object state,
	uint millisecondsTimeOutInterval,
	bool executeOnlyOnce
)
/** @attribute CLSCompliantAttribute(false) */ 
public static RegisteredWaitHandle RegisterWaitForSingleObject (
	WaitHandle waitObject, 
	WaitOrTimerCallback callBack, 
	Object state, 
	UInt32 millisecondsTimeOutInterval, 
	boolean executeOnlyOnce
)
CLSCompliantAttribute(false) 
public static function RegisterWaitForSingleObject (
	waitObject : WaitHandle, 
	callBack : WaitOrTimerCallback, 
	state : Object, 
	millisecondsTimeOutInterval : uint, 
	executeOnlyOnce : boolean
) : RegisteredWaitHandle
No aplicable.

Parámetros

waitObject

WaitHandle que se va a registrar. Utilice un WaitHandle diferente de Mutex.

callBack

Delegado de WaitOrTimerCallback al que se va a llamar cuando el parámetro waitObject esté señalado.

state

Objeto que se ha pasado al delegado.

millisecondsTimeOutInterval

Tiempo de espera en milisegundos. Si el parámetro millisecondsTimeOutInterval es cero (0), la función comprueba el estado del objeto y se devuelve inmediatamente. Si millisecondsTimeOutInterval es -1, el intervalo de tiempo de espera de la función nunca transcurre.

executeOnlyOnce

true para indicar que el subproceso no va a esperar más en el parámetro waitObject después de haber llamado al delegado; false para indicar que el temporizador se restablece cada vez que se completa la operación de espera, hasta que se anula el registro de la espera.

Valor devuelto

RegisteredWaitHandle que puede utilizarse para cancelar la operación de espera registrada.

Tipo de excepciónCondición

ArgumentOutOfRangeException

El parámetro millisecondsTimeOutInterval es menor que -1.

El método RegisterWaitForSingleObject coloca el delegado especificado en cola del grupo de subprocesos. Un proceso de trabajo ejecutará el delegado si se produce una de las siguientes situaciones:

  • El objeto especificado se encuentra en estado señalado.

  • El intervalo de tiempo de espera ha transcurrido.

El método RegisterWaitForSingleObject comprueba el estado actual del WaitHandledel objeto especificado. Si el estado del objeto no está señalado, el método registra una operación de espera. El encargado de llevar a cabo la operación de espera es un subproceso del grupo de subprocesos. Un subproceso de trabajo ejecuta el delegado cuando el estado del objeto pasa a ser señalado o cuando transcurre el intervalo de tiempo de espera. Si el parámetro timeOutInterval no es cero (0) y el parámetro executeOnlyOnce es false, el temporizador se restablece cada vez que el evento se encuentra en estado señalado o transcurre el intervalo de tiempo de espera.

NotaImportante:

El uso de Mutex para waitObject no proporciona la exclusión mutua de devoluciones de llamada porque la API de Win32 subyacente utiliza el indicador WT_EXECUTEDEFAULT predeterminado, por lo que cada devolución de llamada se envía en un subproceso del grupo de subprocesos independiente. En lugar de un objeto Mutex, utilice un objeto Semaphore cuyo recuento máximo sea 1.

Para cancelar la operación de espera, hay que llamar al método RegisteredWaitHandle.Unregister.

El subproceso de espera utiliza la función WaitForMultipleObjects de Win32 para supervisar las operaciones de espera registradas. Por lo tanto, si tiene que utilizar el mismo identificador del sistema operativo nativo en varias llamadas a RegisterWaitForSingleObject, deberá duplicar el identificador utilizando la función DuplicateHandle de Win32. Tenga en cuanta que no debe marcar un objeto de evento que se haya pasado a RegisterWaitForSingleObject, porque el subproceso de espera podría no detectar que el evento está señalado antes de restablecerse.

La función modifica el estado de algunos tipos de objetos de sincronización antes de devolverse. La modificación se lleva a cabo únicamente en el objeto cuyo estado señalado satisfizo la condición de espera. Por ejemplo, el recuento de un semáforo disminuye en una unidad.

Información de versión

En la versión 2.0 de .NET Framework, el valor de la propiedad Thread.CurrentPrincipal se difunde a los subprocesos de trabajo almacenados en la cola utilizando el método RegisterWaitForSingleObject. En las versiones anteriores, la información principal no se difunde.

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

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

Windows 98, Windows 2000 Service Pack 4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0, 1.1, 1.0
Mostrar:
© 2014 Microsoft