Esta documentación está archivada y no tiene mantenimiento.

WaitHandle (Clase)

Actualización: noviembre 2007

Encapsula los objetos específicos del sistema operativo que esperan obtener un acceso exclusivo a los recursos compartidos.

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

[ComVisibleAttribute(true)]
public abstract class WaitHandle : MarshalByRefObject, 
	IDisposable
/** @attribute ComVisibleAttribute(true) */
public abstract class WaitHandle extends MarshalByRefObject implements IDisposable
public abstract class WaitHandle extends MarshalByRefObject implements IDisposable

Esta clase se utiliza normalmente como una clase base para los objetos de sincronización. Las clases que se derivan de WaitHandle definen un mecanismo de señalización para indicar que están tomando o liberando un acceso a un recurso compartido, pero utilizan los métodos WaitHandle heredados para bloquearse mientras esperan el acceso a los recursos compartidos.

Utilice los métodos estáticos de esta clase para bloquear un subproceso hasta que uno o más objetos de sincronización reciban una señal.

WaitHandle implementa el modelo Dispose. Vea Implementar Finalize y Dispose para limpiar recursos no administrados. Si deriva de WaitHandle, utilice la propiedad SafeWaitHandle para almacenar su identificador del sistema operativo nativo. No es necesario reemplazar el método protegido Dispose a menos que utilice recursos no administrados adicionales.

En el ejemplo de código siguiente se muestra cómo dos subprocesos pueden hacer tareas en segundo plano mientras el subproceso principal espera a que finalicen las tareas utilizando los métodos estáticos WaitAny y WaitAll de la clase WaitHandle.

using System;
using System.Threading;

public sealed class App 
{
    // Define an array with two AutoResetEvent WaitHandles.
    static WaitHandle[] waitHandles = new WaitHandle[] 
    {
        new AutoResetEvent(false),
        new AutoResetEvent(false)
    };

    // Define a random number generator for testing.
    static Random r = new Random();

    static void Main() 
    {
        // Queue up two tasks on two different threads; 
        // wait until all tasks are completed.
        DateTime dt = DateTime.Now;
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        WaitHandle.WaitAll(waitHandles);
        // The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})", 
            (DateTime.Now - dt).TotalMilliseconds);

        // Queue up two tasks on two different threads; 
        // wait until any tasks are completed.
        dt = DateTime.Now;
        Console.WriteLine();
        Console.WriteLine("The main thread is waiting for either task to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        int index = WaitHandle.WaitAny(waitHandles);
        // The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).",
            index + 1, (DateTime.Now - dt).TotalMilliseconds);
    }

    static void DoTask(Object state) 
    {
        AutoResetEvent are = (AutoResetEvent) state;
        int time = 1000 * r.Next(2, 10);
        Console.WriteLine("Performing a task for {0} milliseconds.", time);
        Thread.Sleep(time);
        are.Set();
    }
}

// This code produces output similar to the following:
//
//  Main thread is waiting for BOTH tasks to complete.
//  Performing a task for 7000 milliseconds.
//  Performing a task for 4000 milliseconds.
//  Both tasks are completed (time waited=7064.8052)
// 
//  The main thread is waiting for either task to complete.
//  Performing a task for 2000 milliseconds.
//  Performing a task for 2000 milliseconds.
//  Task 1 finished first (time waited=2000.6528).


Este tipo es seguro para la ejecución de subprocesos.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 3.5, 2.0, 1.0

XNA Framework

Compatible con: 2.0, 1.0
Mostrar: