Exportar (0) Imprimir
Expandir todo

WaitHandle (Clase)

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
ComVisibleAttribute(true) 
public abstract class WaitHandle extends MarshalByRefObject implements IDisposable
No aplicable.

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 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, 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

.NET Compact Framework

Compatible con: 2.0, 1.0

XNA Framework

Compatible con: 1.0
Mostrar:
© 2014 Microsoft