WaitHandle.WaitOne Método

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Runtime.dll

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

Sobrecargas

WaitOne()	Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.
WaitOne(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.
WaitOne(TimeSpan)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.
WaitOne(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.
WaitOne(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.

WaitOne()

Source:

WaitHandle.cs

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

C#

public virtual bool WaitOne ();

Devoluciones

Boolean

Es true si la instancia actual recibe una señal. Si nunca se señala a la instancia actual, WaitOne() nunca devuelve nada.

Excepciones

ObjectDisposedException

Ya se ha eliminado la instancia actual.

AbandonedMutexException

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.

InvalidOperationException

La instancia actual es un proxy transparente para un objeto WaitHandle en otro dominio de aplicación.

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar un identificador de espera para evitar que un proceso finalice mientras espera a que un subproceso en segundo plano termine de ejecutarse.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Comentarios

AbandonedMutexException es nuevo en .NET Framework versión 2.0. En versiones anteriores, el WaitOne método devuelve true cuando se abandona una exclusión mutua. Una exclusión mutua abandonada suele indicar un error de codificación grave. En el caso de una exclusión mutua en todo el sistema, puede indicar que una aplicación se ha terminado abruptamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El autor de la llamada de este método se bloquea indefinidamente hasta que la instancia actual recibe una señal. Use este método para bloquear hasta WaitHandle que un recibe una señal de otro subproceso, como se genera cuando se completa una operación asincrónica. Para obtener más información, consulte la interfaz IAsyncResult.

Llamar a esta sobrecarga de método equivale a llamar a la sobrecarga del WaitOne(Int32, Boolean) método y especificar -1 o Timeout.Infinite para el primer parámetro y false para el segundo parámetro.

Invalide este método para personalizar el comportamiento de las clases derivadas.

WaitOne(Int32)

Source:

WaitHandle.cs

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.

C#

public virtual bool WaitOne (int millisecondsTimeout);

Parámetros

millisecondsTimeout

Int32

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.

Devoluciones

Boolean

true si la instancia actual recibe una señal; en caso contrario, false.

Excepciones

ObjectDisposedException

Ya se ha eliminado la instancia actual.

ArgumentOutOfRangeException

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.

AbandonedMutexException

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.

InvalidOperationException

La instancia actual es un proxy transparente para un objeto WaitHandle en otro dominio de aplicación.

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar un identificador de espera para evitar que un proceso finalice mientras espera a que un subproceso en segundo plano termine de ejecutarse.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Comentarios

Si millisecondsTimeout es cero, el método no se bloquea. Comprueba el estado del identificador de espera y devuelve inmediatamente.

El autor de la llamada de este método se bloquea hasta que la instancia actual recibe una señal o se agota el tiempo de espera. Use este método para bloquear hasta WaitHandle que un recibe una señal de otro subproceso, como se genera cuando se completa una operación asincrónica. Para obtener más información, consulte la interfaz IAsyncResult.

Invalide este método para personalizar el comportamiento de las clases derivadas.

Llamar a esta sobrecarga de método es la misma que llamar a la WaitOne(Int32, Boolean) sobrecarga y especificar false para exitContext.

WaitOne(TimeSpan)

Source:

WaitHandle.cs

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

C#

public virtual bool WaitOne (TimeSpan timeout);

Parámetros

timeout

TimeSpan

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.

Devoluciones

Boolean

true si la instancia actual recibe una señal; en caso contrario, false.

Excepciones

ObjectDisposedException

Ya se ha eliminado la instancia actual.

ArgumentOutOfRangeException

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.

O bien

timeout es mayor que Int32.MaxValue.

AbandonedMutexException

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.

InvalidOperationException

La instancia actual es un proxy transparente para un objeto WaitHandle en otro dominio de aplicación.

Comentarios

Si timeout es cero, el método no se bloquea. Comprueba el estado del identificador de espera y devuelve inmediatamente.

El autor de la llamada de este método se bloquea hasta que la instancia actual recibe una señal o se agota el tiempo de espera. Use este método para bloquear hasta WaitHandle que un recibe una señal de otro subproceso, como se genera cuando se completa una operación asincrónica. Para obtener más información, consulte la interfaz IAsyncResult.

Invalide este método para personalizar el comportamiento de las clases derivadas.

El valor máximo de timeout es Int32.MaxValue.

Llamar a esta sobrecarga de método es la misma que llamar a la WaitOne(TimeSpan, Boolean) sobrecarga y especificar false para exitContext.

WaitOne(Int32, Boolean)

Source:

WaitHandle.cs

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.

C#

public virtual bool WaitOne (int millisecondsTimeout, bool exitContext);

Parámetros

millisecondsTimeout

Int32

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.

exitContext

Boolean

true para salir del dominio de sincronización del contexto antes de la espera (en caso de encontrarse en un contexto sincronizado) y volver a adquirirlo más tarde; de lo contrario, false.

Devoluciones

Boolean

true si la instancia actual recibe una señal; en caso contrario, false.

Excepciones

ObjectDisposedException

Ya se ha eliminado la instancia actual.

ArgumentOutOfRangeException

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.

AbandonedMutexException

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.

InvalidOperationException

La instancia actual es un proxy transparente para un objeto WaitHandle en otro dominio de aplicación.

Ejemplos

En el ejemplo siguiente se muestra cómo se comporta la sobrecarga del WaitOne(Int32, Boolean) método cuando se llama a dentro de un dominio de sincronización. En primer lugar, un subproceso espera con exitContext establecido en false y se bloquea hasta que expire el tiempo de espera. Un segundo subproceso se ejecuta después de que finalice el primer subproceso y espere con exitContext establecido en true. La llamada para indicar el identificador de espera de este segundo subproceso no está bloqueado y el subproceso se completa antes del tiempo de espera.

C#

using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

Comentarios

Si millisecondsTimeout es cero, el método no se bloquea. Comprueba el estado del identificador de espera y devuelve inmediatamente.

Si se abandona una exclusión mutua, se produce una AbandonedMutexException excepción . Una exclusión mutua abandonada suele indicar un error de codificación grave. En el caso de una exclusión mutua en todo el sistema, puede indicar que una aplicación se ha terminado abruptamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El autor de la llamada de este método se bloquea hasta que la instancia actual recibe una señal o se agota el tiempo de espera. Use este método para bloquear hasta WaitHandle que un recibe una señal de otro subproceso, como se genera cuando se completa una operación asincrónica. Para obtener más información, consulte la interfaz IAsyncResult.

Invalide este método para personalizar el comportamiento de las clases derivadas.

Salir del contexto

El exitContext parámetro no tiene ningún efecto a menos que se llame a este método desde dentro de un contexto administrado no predeterminado. El contexto administrado puede no ser predeterminado si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject. Incluso si actualmente está ejecutando un método en una clase que no se deriva de ContextBoundObject, como String, puede estar en un contexto no predeterminado si ContextBoundObject está en la pila en el dominio de aplicación actual.

Cuando el código se ejecuta en un contexto no predeterminado, especificando true para exitContext que el subproceso salga del contexto administrado no predeterminado (es decir, para realizar la transición al contexto predeterminado) antes de ejecutar este método. El subproceso vuelve al contexto no predeterminado original una vez completada la llamada a este método.

Salir del contexto puede ser útil cuando la clase enlazada al contexto tiene el SynchronizationAttribute atributo . En ese caso, todas las llamadas a los miembros de la clase se sincronizan automáticamente y el dominio de sincronización es todo el cuerpo de código de la clase. Si el código de la pila de llamadas de un miembro llama a este método y especifica para exitContext, el subproceso true sale del dominio de sincronización, lo que permite que un subproceso bloqueado en una llamada a cualquier miembro del objeto continúe. Cuando este método vuelve, el subproceso que realizó la llamada debe esperar a volver a escribir el dominio de sincronización.

WaitOne(TimeSpan, Boolean)

Source:

WaitHandle.cs

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.

C#

public virtual bool WaitOne (TimeSpan timeout, bool exitContext);

Parámetros

timeout

TimeSpan

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.

exitContext

Boolean

true para salir del dominio de sincronización del contexto antes de la espera (en caso de encontrarse en un contexto sincronizado) y volver a adquirirlo más tarde; de lo contrario, false.

Devoluciones

Boolean

true si la instancia actual recibe una señal; en caso contrario, false.

Excepciones

ObjectDisposedException

Ya se ha eliminado la instancia actual.

ArgumentOutOfRangeException

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.

O bien

timeout es mayor que Int32.MaxValue.

AbandonedMutexException

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.

InvalidOperationException

La instancia actual es un proxy transparente para un objeto WaitHandle en otro dominio de aplicación.

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar un identificador de espera para evitar que un proceso finalice mientras espera a que un subproceso en segundo plano termine de ejecutarse.

C#

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Comentarios

Si timeout es cero, el método no se bloquea. Comprueba el estado del identificador de espera y devuelve inmediatamente.

Si se abandona una exclusión mutua, se produce una AbandonedMutexException excepción . Una exclusión mutua abandonada suele indicar un error de codificación grave. En el caso de una exclusión mutua en todo el sistema, puede indicar que una aplicación se ha terminado abruptamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El autor de la llamada de este método se bloquea hasta que la instancia actual recibe una señal o se agota el tiempo de espera. Use este método para bloquear hasta que un WaitHandle recibe una señal de otro subproceso, como se genera cuando se completa una operación asincrónica. Para obtener más información, consulte la interfaz IAsyncResult.

Invalide este método para personalizar el comportamiento de las clases derivadas.

El valor máximo de timeout es Int32.MaxValue.

Salir del contexto

El exitContext parámetro no tiene ningún efecto a menos que se llame a este método desde dentro de un contexto administrado no predeterminado. El contexto administrado puede ser no predeterminado si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject. Incluso si actualmente está ejecutando un método en una clase que no se deriva de ContextBoundObject, como String, puede estar en un contexto no predeterminado si ContextBoundObject está en la pila en el dominio de aplicación actual.

Cuando el código se ejecuta en un contexto no predeterminado, al especificar true para exitContext que el subproceso salga del contexto administrado no predeterminado (es decir, para realizar la transición al contexto predeterminado) antes de ejecutar este método. El subproceso vuelve al contexto no predeterminado original una vez completada la llamada a este método.

Salir del contexto puede ser útil cuando la clase enlazada al contexto tiene el SynchronizationAttribute atributo . En ese caso, todas las llamadas a los miembros de la clase se sincronizan automáticamente y el dominio de sincronización es todo el cuerpo de código de la clase. Si el código de la pila de llamadas de un miembro llama a este método y especifica para exitContext, el subproceso true sale del dominio de sincronización, lo que permite que un subproceso bloqueado en una llamada a cualquier miembro del objeto continúe. Cuando este método vuelve, el subproceso que realizó la llamada debe esperar a volver a escribir el dominio de sincronización.