Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase WaitHandle

 

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)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.EventWaitHandle
      System.Threading.Mutex
      System.Threading.Semaphore

[ComVisibleAttribute(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable

NombreDescripción
System_CAPS_protmethodWaitHandle()

Inicializa una nueva instancia de la clase WaitHandle.

NombreDescripción
System_CAPS_pubpropertyHandle

Obsoleto.Obtiene o establece el identificador del sistema operativo nativo.

System_CAPS_pubpropertySafeWaitHandle

Obtiene o establece el identificador del sistema operativo nativo.

NombreDescripción
System_CAPS_pubmethodClose()

Libera todos los recursos mantenidos por el objeto WaitHandle actual.

System_CAPS_pubmethodCreateObjRef(Type)

Crea un objeto que contiene toda la información pertinente necesaria para generar a un proxy utilizado para comunicarse con un objeto remoto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodDispose()

Libera todos los recursos usados por la instancia actual de la clase WaitHandle.

System_CAPS_protmethodDispose(Boolean)

Cuando se reemplaza en una clase derivada, libera los recursos no administrados que usa WaitHandle y, de forma opcional, libera los recursos administrados.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodInitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone(Boolean)

Crea una copia superficial del actual MarshalByRefObject objeto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodSystem_CAPS_staticSignalAndWait(WaitHandle, WaitHandle)

Señala un WaitHandle y espera en otro.

System_CAPS_pubmethodSystem_CAPS_staticSignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Señala un WaitHandle y espera en otro, para lo que determina un intervalo de tiempo de espera como entero con signo de 32 bits y especifica si se sale del dominio de sincronización para el contexto antes de entrar en la espera.

System_CAPS_pubmethodSystem_CAPS_staticSignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Señala un WaitHandle y espera en otro, para lo que determina el intervalo de tiempo de espera como TimeSpan y especifica si se sale del dominio de sincronización para el contexto antes de entrar en la espera.

System_CAPS_pubmethodToString()

Retorna una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(WaitHandle[])

Espera a que todos los elementos de la matriz especificada reciban una señal.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(WaitHandle[], Int32)

Espera a que todos los elementos de la matriz especificada reciban una señal mediante un valor Int32 para especificar el intervalo de tiempo.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(WaitHandle[], Int32, Boolean)

Espera a que todos los elementos de la matriz especificada reciban una señal; usa un valor Int32 para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de finalizar la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(WaitHandle[], TimeSpan)

Espera a que todos los elementos de la matriz especificada reciban una señal, usando un valor TimeSpan para especificar el intervalo de tiempo.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(WaitHandle[], TimeSpan, Boolean)

Espera a que todos los elementos de la matriz especificada reciban una señal; usa un valor TimeSpan para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de finalizar la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(WaitHandle[])

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(WaitHandle[], Int32)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(WaitHandle[], Int32, Boolean)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; utiliza un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(WaitHandle[], TimeSpan)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, usando un TimeSpan para especificar el intervalo de tiempo.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(WaitHandle[], TimeSpan, Boolean)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; usa un TimeSpan para especificar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.

System_CAPS_pubmethodWaitOne()

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.

System_CAPS_pubmethodWaitOne(Int32)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usando un entero de 32 bits con signo para especificar el intervalo de tiempo en milisegundos.

System_CAPS_pubmethodWaitOne(Int32, Boolean)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usa un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si hay que salir del dominio de sincronización antes de la espera.

System_CAPS_pubmethodWaitOne(TimeSpan)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.

System_CAPS_pubmethodWaitOne(TimeSpan, Boolean)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal; usa TimeSpan para determinar el intervalo de tiempo y especifica si hay que abandonar el dominio de sincronización antes de la espera.

NombreDescripción
System_CAPS_protfieldSystem_CAPS_staticInvalidHandle

Representa un identificador del sistema operativo nativo no válido. Este campo es de solo lectura.

System_CAPS_pubfieldSystem_CAPS_staticWaitTimeout

Indica que una operación WaitAny ha superado el tiempo de espera antes de que se señalara un identificador de espera. Este campo es constante.

NombreDescripción
System_CAPS_pubmethodGetSafeWaitHandle()

Obtiene el identificador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Establece un controlador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

La WaitHandle clase encapsula identificadores de sincronización de Win32 y se utiliza para representar todos los objetos de sincronización en el tiempo de ejecución que permiten varias operaciones de espera. Para obtener una comparación de identificadores de espera con otros objetos de sincronización, consulte Overview of Synchronization Primitives.

El WaitHandle propia clase es abstracta. Las clases derivadas de WaitHandle definir un mecanismo de señalización para indicar que están tomando o liberando un acceso a un recurso compartido, pero utilizan heredadas WaitHandle métodos mientras espera para tener acceso a recursos comparten. Las clases derivadas de WaitHandle incluyen:

Los subprocesos pueden bloquear en un identificador de espera individual llamando al método de instancia WaitOne, que es heredado por las clases derivadas de WaitHandle.

Las clases derivadas de WaitHandle difieren en su afinidad de subprocesos. Identificadores de espera de evento (EventWaitHandle, AutoResetEvent, y ManualResetEvent) y los semáforos no tienen afinidad de subprocesos; cualquier subproceso puede señalar un identificador de espera de evento o un semáforo. Las exclusiones mutuas, por otro lado, tienen afinidad de subprocesos; el subproceso que posee una exclusión mutua debe liberarlo y se produce una excepción si un subproceso llama a la ReleaseMutex método en una exclusión mutua que no le pertenece.

Dado que la WaitHandle clase se deriva de MarshalByRefObject, estas clases se pueden utilizar para sincronizar las actividades de subprocesos en los límites del dominio de aplicación.

Además de sus clases derivadas, la WaitHandle clase tiene un número de métodos estáticos que bloquear un subproceso hasta que uno o más objetos de sincronización reciban una señal... Se incluyen los siguientes:

  • SignalAndWait, que permite que un subproceso señalar un identificador de espera y espere inmediatamente a otro.

  • WaitAll, que permite que un subproceso espere hasta que todos los identificadores de espera de una matriz reciban una señal.

  • WaitAny, que permite que un subproceso espere hasta que se haya señalado cualquiera de un conjunto de identificadores de espera especificado.

Las sobrecargas de estos métodos proporcionan intervalos de tiempo de espera para abandonar la espera y la oportunidad de salir de un contexto de sincronización antes de entrar en la espera, permitiendo que otros subprocesos utilicen el contexto de sincronización.

System_CAPS_importantImportante

Este tipo implementa la IDisposable interfaz. Cuando haya terminado de utilizar el tipo o un tipo derivado de éste, debería eliminar, directa o indirectamente. Para deshacerse del tipo directamente, llame a su Close método en un try/catch bloque. Para deshacerse de él indirectamente, usar una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, consulte la sección "Uso de un objeto que implementa IDisposable" en el IDisposable tema de la interfaz.

WaitHandle implementa el Dispose patrón. Consulta Patrón de Dispose. Al derivar de WaitHandle, utilice el SafeWaitHandle propiedad para almacenar el identificador del sistema operativo de identificador nativo. No es necesario reemplazar el protegido Dispose método a menos que utilice recursos no administrados adicionales.

El siguiente ejemplo de código muestra cómo dos subprocesos pueden hacen tareas en segundo plano mientras el principal subproceso espera a que las tareas se completen con estático WaitAny y WaitAll métodos de la WaitHandle clase.

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).

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

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

Volver al principio
Mostrar: