Export (0) Print
Expand All

WaitHandle.WaitAny Method (WaitHandle[])

Waits for any of the elements in the specified array to receive a signal.

Namespace:  System.Threading
Assembly:  mscorlib (in mscorlib.dll)

public static int WaitAny(
	WaitHandle[] waitHandles
)

Parameters

waitHandles
Type: System.Threading.WaitHandle[]

A WaitHandle array containing the objects for which the current instance will wait.

Return Value

Type: System.Int32
The array index of the object that satisfied the wait.

ExceptionCondition
ArgumentNullException

The waitHandles parameter is null.

-or-

One or more of the objects in the waitHandles array is null.

NotSupportedException

The number of objects in waitHandles is greater than the system permits.

ApplicationException

waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

AbandonedMutexException

The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.

ArgumentException

waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

InvalidOperationException

The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

AbandonedMutexException is new in the .NET Framework version 2.0. In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. An abandoned mutex often indicates a serious coding error. In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). The exception contains information useful for debugging.

The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. If waitHandles contains a released mutex with a lower index number than the abandoned mutex, the WaitAny method completes normally and the exception is not thrown.

NoteNote

In versions of the .NET Framework earlier than version 2.0, if a thread exits or aborts without explicitly releasing a Mutex, and that Mutex is at index 0 (zero) in a WaitAny array on another thread, the index returned by WaitAny is 128 instead of 0.

This method returns when any handle is signaled. If more than one object becomes signaled during the call, the return value is the array index of the signaled object with the smallest index value of all the signaled objects. On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Calling this method overload is equivalent to calling the WaitAny(WaitHandle[], Int32, Boolean) method overload and specifying -1 (or Timeout.Infinite) for millisecondsTimeout and true for exitContext.

The following code example demonstrates calling the WaitAny method.

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

.NET Framework

Supported in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft