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

Método WaitHandle.WaitAny (WaitHandle[])

 

Publicado: octubre de 2016

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

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

public static int WaitAny(
	WaitHandle[] waitHandles
)

Parámetros

waitHandles
Type: System.Threading.WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.

Valor devuelto

Type: System.Int32

Índice de la matriz del objeto que satisfizo la espera.

Exception Condition
ArgumentNullException

El parámetro waitHandles es null.

-o-

Uno o varios de los objetos de la waitHandles matriz es null.

NotSupportedException

El número de objetos de waitHandles es mayor que permite el sistema.

ApplicationException

waitHandles es una matriz sin elementos y la versión de .NET Framework es 1.0 o 1.1.

AbandonedMutexException

La espera se completó porque un subproceso sale sin liberar una exclusión mutua. Esta excepción no se produce en Windows 98 o Windows Millennium Edition.

ArgumentException

waitHandles es una matriz sin elementos y la versión de .NET Framework es 2.0 o posterior.

InvalidOperationException

El waitHandles matriz contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.

AbandonedMutexException es nuevo en la versión 2.0 de .NET Framework. En versiones anteriores, el WaitAny método devuelve true Si la espera finaliza porque se abandona una exclusión mutua. A menudo, un mutex abandonado indica un error de codificación grave. En el caso de una exclusión mutua todo el sistema, podría indicar que una aplicación ha finalizado inesperadamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El WaitAny método produce un AbandonedMutexException sólo cuando la espera finaliza por una exclusión mutua abandonada. Si waitHandles contiene una exclusión mutua liberada con un número inferior de índice de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.

System_CAPS_noteNota

En las versiones de .NET Framework anteriores a la versión 2.0, si un subproceso termina o se interrumpe sin liberar explícitamente un Mutex, y que Mutex está en el índice 0 (cero) en un WaitAny matriz en otro subproceso, el índice devuelto por WaitAny es 128 en lugar de 0.

Este método se devuelve cuando se señala a cualquiera de ellos. Si durante la llamada se señala más de un objeto, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados. En algunas implementaciones, si se pasan 64 identificadores, más de un NotSupportedException se produce.

Llamar a esta sobrecarga del método es equivalente a llamar a la WaitAny(WaitHandle[], Int32, Boolean) sobrecarga del método y especificar -1 (o Timeout.Infinite) para millisecondsTimeouty true para exitContext.

En el ejemplo de código siguiente se muestra cómo llamar a la WaitAny(método).

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
Volver al principio
Mostrar: