¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Set (Mé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.Set (Método)

Establece el estado del evento en señalado, permitiendo que uno o varios subprocesos en espera continúen.

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

public bool Set()

Valor devuelto

Tipo: System.Boolean
true si la operación se realiza correctamente; en caso contrario, false.

ExcepciónCondición
ObjectDisposedException

No se ha llamado previamente al método Close en este System.Threading.EventWaitHandle.

Para un objeto EventWaitHandle con EventResetMode.AutoReset (incluido AutoResetEvent), el método Set libera sólo un subproceso. Si no hay ningún subproceso en espera, el identificador de espera permanece señalado hasta que un subproceso intenta esperar en él o hasta que se llama a su método Reset.

Nota importanteImportante

No se garantiza que cada llamada al método Set liberará un subproceso de EventWaitHandle cuyo modo de restablecimiento es EventResetMode.AutoReset. Si dos llamadas están muy seguidas, de modo que la segunda llamada se produce antes de que se haya liberado un subproceso, sólo se liberará un subproceso. Es como si la segunda llamada no hubiera ocurrido. Además, si se llama a Set cuando no hay subprocesos en espera y ya se ha marcado EventWaitHandle, la llamada no tendrá ningún efecto.

Para un objeto EventWaitHandle con EventResetMode.ManualReset (incluido ManualResetEvent), la llamada al método Set deja al marcador de espera en estado de señalado hasta que se produce una llama a su método Reset.

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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft