Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

EventWaitHandle (Clase)

Representa un evento de sincronización de subprocesos.

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

[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class EventWaitHandle : WaitHandle

El tipo EventWaitHandle expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEventWaitHandle(Boolean, EventResetMode)Inicializa una nueva instancia de la clase EventWaitHandle, especificando si el identificador de espera se señala inicialmente y si se restablece automática o manualmente.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEventWaitHandle(Boolean, EventResetMode, String)Inicializa una nueva instancia de la clase EventWaitHandle, especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente y el nombre de un evento de sincronización del sistema.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEventWaitHandle(Boolean, EventResetMode, String, Boolean)Inicializa una nueva instancia de la clase EventWaitHandle, especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente, el nombre de un evento de sincronización del sistema y una variable booleana cuyo valor después de la llamada indica si se ha creado el evento del sistema con nombre.
Método públicoEventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)Inicializa una nueva instancia de la clase EventWaitHandle, especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente, el nombre de un evento de sincronización del sistema, una variable booleana cuyo valor después de la llamada indica si se ha creado el evento del sistema con nombre y la seguridad de control de acceso que se va a aplicar al evento con nombre en el caso de que se haya creado.
Arriba

  NombreDescripción
Propiedad públicaCompatible con XNA FrameworkHandle Obsoleto. Obtiene o establece el identificador del sistema operativo nativo. (Se hereda de WaitHandle).
Propiedad públicaSafeWaitHandleObtiene o establece el identificador del sistema operativo nativo. (Se hereda de WaitHandle).
Arriba

  NombreDescripción
Método públicoCompatible con XNA FrameworkClose Cuando se sobrescribe en una clase derivada, libera todos los recursos mantenidos por el WaitHandle actual. (Se hereda de WaitHandle).

In XNA Framework, este miembro está invalidado por Close().
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsDispose()Libera todos los recursos usados por la instancia actual de la clase WaitHandle. (Se hereda de WaitHandle).
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsDispose(Boolean)Cuando se reemplaza en una clase derivada, libera los recursos no administrados utilizados por WaitHandle y, de forma opcional, libera los recursos administrados. (Se hereda de WaitHandle).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método protegidoCompatible con XNA FrameworkFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).

In XNA Framework, este miembro está invalidado por Finalize().
Método públicoGetAccessControlObtiene un objeto EventWaitHandleSecurity que representa la seguridad de control de acceso para el evento del sistema con nombre representado por el objeto EventWaitHandle actual.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsMemberwiseClone() Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoMemberwiseClone(Boolean)Crea una copia superficial del objeto MarshalByRefObject actual. (Se hereda de MarshalByRefObject).
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsOpenExisting(String)Abre el evento de sincronización con nombre especificado, si ya existe.
Método públicoMiembro estáticoOpenExisting(String, EventWaitHandleRights)Abre el evento de sincronización con nombre especificado, si ya existe, con el acceso de seguridad deseado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsResetEstablece el estado del evento en no señalado, haciendo que los subprocesos se bloqueen.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSetEstablece el estado del evento en señalado, permitiendo que uno o varios subprocesos en espera continúen.
Método públicoSetAccessControlEstablece la seguridad de control de acceso para un evento del sistema con nombre.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con .NET para aplicaciones de la Tienda WindowsTryOpenExisting(String, EventWaitHandle)Abre el evento de sincronización con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente.
Método públicoMiembro estáticoTryOpenExisting(String, EventWaitHandleRights, EventWaitHandle)Abre el evento de sincronización con nombre especificado, si ya existe, con el acceso de seguridad deseado, y devuelve un valor que indica si la operación se realizó correctamente.
Método públicoCompatible con XNA FrameworkWaitOne()Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal. (Se hereda de WaitHandle).

In XNA Framework, este miembro está invalidado por WaitOne().
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWaitOne(Int32)Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo. (Se hereda de WaitHandle).
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWaitOne(TimeSpan)Bloquea el subproceso actual hasta que la instancia actual recibe una señal, utilizando TimeSpan para especificar el intervalo de tiempo. (Se hereda de WaitHandle).
Método públicoCompatible con XNA FrameworkWaitOne(Int32, Boolean)Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo y especificando si hay que salir del dominio de sincronización antes de la espera. (Se hereda de WaitHandle).

In XNA Framework, este miembro está invalidado por WaitOne(Int32, Boolean).
Método públicoWaitOne(TimeSpan, Boolean)Bloquea el subproceso actual hasta que la instancia actual recibe una señal, utilizando TimeSpan para especificar el intervalo de tiempo y especificando si hay que abandonar el dominio de sincronización antes de la espera. (Se hereda de WaitHandle).
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIDisposable.DisposeInfraestructura. Libera todos los recursos utilizados por WaitHandle. (Se hereda de WaitHandle).
Arriba

La clase EventWaitHandle permite que los subprocesos se comuniquen entre sí mediante señales. Normalmente, uno o varios subprocesos se bloquean en una clase EventWaitHandle hasta que un subproceso desbloqueado llama al método Set, liberando uno de los subprocesos bloqueados o varios. Un subproceso puede señalar EventWaitHandle y, a continuación, bloquease en él, llamando al método WaitHandle.SignalAndWaitstaticShared (en Visual Basic).

NotaNota

La clase EventWaitHandle proporciona acceso a los eventos de sincronización del sistema con nombre.

El comportamiento de una clase EventWaitHandle que se haya señalado depende de su modo de restablecimiento. Las cases EventWaitHandle creadas con el marcador EventResetMode.AutoReset se restablecen automáticamente cuando se señalan, después de liberar un único subproceso en espera. Las clases EventWaitHandle creadas con el marcador EventResetMode.ManualReset permanece señaladas hasta que se llama a su método Reset.

Los eventos de restablecimiento automático proporcionan el acceso exclusivo a un recurso. Si un evento de restablecimiento automático se señaliza cuando no hay ningún subproceso en espera, permanecerá señalizado hasta que algún subproceso intente esperar en él. El evento liberará el subproceso e, inmediatamente después, se restablecerá, de modo que bloqueará los subprocesos posteriores.

Los eventos de restablecimiento manual son como puertas. Cuando no se señala el evento, los subprocesos que esperan en el mismo se bloquean. Cuando se señala el evento, se liberan todos los subprocesos en espera y el evento permanece señalado (es decir, las esperas subsiguientes no se bloquean) hasta que se llama a su método Reset. Los eventos de restablecimiento manual son útiles cuando un subproceso debe finalizar una actividad antes de que otros subprocesos puedan continuar.

Los objetos EventWaitHandle se pueden utilizar con los métodos static (Shared en Visual Basic) WaitHandle.WaitAll y WaitHandle.WaitAny.

Para obtener más información sobre los mecanismos de sincronización de subprocesos, vea EventWaitHandle, AutoResetEvent, CountdownEvent, ManualResetEvent.

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el valor de propiedad Resources siguiente: Synchronization | ExternalThreading. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

En el siguiente ejemplo de código se utiliza la sobrecarga del método SignalAndWait(WaitHandle, WaitHandle) para que permitir que el subproceso principal señale un subproceso bloqueado y, después, se espera a que el subproceso finalice una tarea.

En el ejemplo se inician cinco subprocesos y se permite que estos subprocesos se bloqueen en un objeto EventWaitHandle creado con el marcador EventResetMode.AutoReset; después, se libera un subproceso cada vez que el usuario presiona la tecla ENTRAR. A continuación, se ponen otros cinco subprocesos en cola y se liberan todos ellos utilizando un objeto EventWaitHandle creado con el marcador EventResetMode.ManualReset.


using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();

    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

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

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft