WaitHandle.WaitAny WaitHandle.WaitAny WaitHandle.WaitAny WaitHandle.WaitAny Method

Définition

Attend que l'un des éléments du tableau spécifié reçoive un signal.Waits for any of the elements in the specified array to receive a signal.

Surcharges

WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[])

Attend que l'un des éléments du tableau spécifié reçoive un signal.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32)

Attend que l'un des éléments du tableau spécifié reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan)

Attend que l'un des éléments du tableau spécifié reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean)

Attend que l’un des éléments du tableau spécifié reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean)

Attend que l’un des éléments du tableau spécifié reçoive un signal ; en utilisant une valeur TimeSpan pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[]) WaitAny(WaitHandle[])

Attend que l'un des éléments du tableau spécifié reçoive un signal.Waits for any of the elements in the specified array to receive a signal.

public:
 static int WaitAny(cli::array <System::Threading::WaitHandle ^> ^ waitHandles);
public static int WaitAny (System.Threading.WaitHandle[] waitHandles);
static member WaitAny : System.Threading.WaitHandle[] -> int
Public Shared Function WaitAny (waitHandles As WaitHandle()) As Integer

Paramètres

waitHandles
WaitHandle[]

Tableau WaitHandle qui contient les objets que l'instance actuelle attendra.A WaitHandle array containing the objects for which the current instance will wait.

Retours

Index du tableau de l'objet ayant respecté l'attente.The array index of the object that satisfied the wait.

Exceptions

Le paramètre waitHandles a la valeur null.The waitHandles parameter is null.

- ou --or- Un ou plusieurs des objets dans le tableau waitHandles sont null.One or more of the objects in the waitHandles array is null.

Le nombre d’objets dans waitHandles est supérieur à ce que le système autorise.The number of objects in waitHandles is greater than the system permits.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 1.0 ou 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.The wait completed because a thread exited without releasing a mutex. Cette exception n’est pas levée sur Windows 98 ou Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 2.0 ou ultérieure.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

Le tableau waitHandles contient un proxy transparent pour un WaitHandle dans un autre domaine d’application.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Exemples

L’exemple de code suivant illustre l’appel de la méthode WaitAny.The following code example demonstrates calling the WaitAny method.

using namespace System;
using namespace System::Threading;

public ref class WaitHandleExample
{
    // Define a random number generator for testing.
private:
    static Random^ random = gcnew Random();
public:
    static void DoTask(Object^ state)
    {
        AutoResetEvent^ autoReset = (AutoResetEvent^) state;
        int time = 1000 * random->Next(2, 10);
        Console::WriteLine("Performing a task for {0} milliseconds.", time);
        Thread::Sleep(time);
        autoReset->Set();
    }
};

int main()
{
    // Define an array with two AutoResetEvent WaitHandles.
    array<WaitHandle^>^ handles = gcnew array<WaitHandle^> {
        gcnew AutoResetEvent(false), gcnew AutoResetEvent(false)};

    // Queue up two tasks on two different threads;
    // wait until all tasks are completed.
    DateTime timeInstance = DateTime::Now;
    Console::WriteLine("Main thread is waiting for BOTH tasks to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    WaitHandle::WaitAll(handles);
    // The time shown below should match the longest task.
    Console::WriteLine("Both tasks are completed (time waited={0})",
        (DateTime::Now - timeInstance).TotalMilliseconds);

    // Queue up two tasks on two different threads;
    // wait until any tasks are completed.
    timeInstance = DateTime::Now;
    Console::WriteLine();
    Console::WriteLine("The main thread is waiting for either task to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    int index = WaitHandle::WaitAny(handles);
    // The time shown below should match the shortest task.
    Console::WriteLine("Task {0} finished first (time waited={1}).",
        index + 1, (DateTime::Now - timeInstance).TotalMilliseconds);
}

// This code produces the following sample output.
//
// 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).
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).
Imports System.Threading

NotInheritable Public Class App
    ' Define an array with two AutoResetEvent WaitHandles.
    Private Shared waitHandles() As WaitHandle = _
        {New AutoResetEvent(False), New AutoResetEvent(False)}
    
    ' Define a random number generator for testing.
    Private Shared r As New Random()
    
    <MTAThreadAttribute> _
    Public Shared Sub Main() 
        ' Queue two tasks on two different threads; 
        ' wait until all tasks are completed.
        Dim dt As DateTime = DateTime.Now
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf 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(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        Dim index As Integer = 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)
    
    End Sub
    
    Shared Sub DoTask(ByVal state As [Object]) 
        Dim are As AutoResetEvent = CType(state, AutoResetEvent)
        Dim time As Integer = 1000 * r.Next(2, 10)
        Console.WriteLine("Performing a task for {0} milliseconds.", time)
        Thread.Sleep(time)
        are.Set()
    
    End Sub
End Class

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

Remarques

AbandonedMutexException est une nouveauté de la version 2,0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. Dans les versions précédentes, la méthode WaitAny retourne true si l’attente se termine parce qu’un mutex est abandonné.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abandonné indique souvent une erreur de codage grave.An abandoned mutex often indicates a serious coding error. Dans le cas d’un mutex à l’ensemble du système, cela peut indiquer qu’une application a été interrompue brusquement (par exemple, à l’aide du gestionnaire des tâches Windows).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). L’exception contient des informations utiles pour le débogage.The exception contains information useful for debugging.

La méthode WaitAny lève une AbandonedMutexException uniquement lorsque l’attente se termine en raison d’un mutex abandonné.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contient un mutex libéré avec un numéro d’index inférieur au mutex abandonné, la méthode WaitAny se termine normalement et l’exception n’est pas levée.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.

Notes

Dans les versions de la .NET Framework antérieures à la version 2,0, si un thread se termine ou s’abandonne sans libérer explicitement une Mutex, et que Mutex se trouve à l’index 0 (zéro) dans un tableau WaitAny sur un autre thread, l’index retourné par WaitAny est 128 au lieu de 0.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.

Cette méthode retourne lorsqu’un handle est signalé.This method returns when any handle is signaled. Si plusieurs objets sont signalés pendant l’appel, la valeur de retour est l’index de tableau de l’objet signalé avec la plus petite valeur d’index de tous les objets signalés.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. Dans certaines implémentations, si plus de 64 handles sont passés, un NotSupportedException est levé.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

L’appel de cette surcharge de méthode équivaut à appeler la surcharge de méthode WaitAny(WaitHandle[], Int32, Boolean) et à spécifier-1 (ou Timeout.Infinite) pour millisecondsTimeout et true pour exitContext.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.

WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32) WaitAny(WaitHandle[], Int32)

Attend que l'un des éléments du tableau spécifié reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

public:
 static int WaitAny(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout);
public static int WaitAny (System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout);
static member WaitAny : System.Threading.WaitHandle[] * int -> int
Public Shared Function WaitAny (waitHandles As WaitHandle(), millisecondsTimeout As Integer) As Integer

Paramètres

waitHandles
WaitHandle[]

Tableau WaitHandle qui contient les objets que l'instance actuelle attendra.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32 Int32 Int32 Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Retours

Index de tableau de l'objet ayant respecté l'attente ou WaitTimeout si aucun objet n'a respecté l'attente et qu'un intervalle de temps équivalent à millisecondsTimeout s'est écoulé.The array index of the object that satisfied the wait, or WaitTimeout if no object satisfied the wait and a time interval equivalent to millisecondsTimeout has passed.

Exceptions

Le paramètre waitHandles a la valeur null.The waitHandles parameter is null.

ou-or- Un ou plusieurs des objets dans le tableau waitHandles sont null.One or more of the objects in the waitHandles array is null.

Le nombre d’objets dans waitHandles est supérieur à ce que le système autorise.The number of objects in waitHandles is greater than the system permits.

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.The wait completed because a thread exited without releasing a mutex. Cette exception n’est pas levée sur Windows 98 ou Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles est un tableau sans éléments.waitHandles is an array with no elements.

Le tableau waitHandles contient un proxy transparent pour un WaitHandle dans un autre domaine d’application.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Remarques

Si millisecondsTimeout est égal à zéro, la méthode n’est pas bloquée.If millisecondsTimeout is zero, the method does not block. Il teste l’état des handles d’attente et retourne immédiatement.It tests the state of the wait handles and returns immediately.

La méthode WaitAny lève une AbandonedMutexException uniquement lorsque l’attente se termine en raison d’un mutex abandonné.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contient un mutex libéré avec un numéro d’index inférieur au mutex abandonné, la méthode WaitAny se termine normalement et l’exception n’est pas levée.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.

Cette méthode retourne lorsque l’attente se termine, soit lorsque l’un des handles est signalé, soit lorsqu’un délai d’attente se produit.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Si plusieurs objets sont signalés pendant l’appel, la valeur de retour est l’index de tableau de l’objet signalé avec la plus petite valeur d’index de tous les objets signalés.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. Dans certaines implémentations, si plus de 64 handles sont passés, un NotSupportedException est levé.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

L’appel de cette surcharge de méthode est identique à l’appel de la surcharge WaitAny(WaitHandle[], Int32, Boolean) et à la spécification de false pour exitContext.Calling this method overload is the same as calling the WaitAny(WaitHandle[], Int32, Boolean) overload and specifying false for exitContext.

WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan) WaitAny(WaitHandle[], TimeSpan)

Attend que l'un des éléments du tableau spécifié reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

public:
 static int WaitAny(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout);
public static int WaitAny (System.Threading.WaitHandle[] waitHandles, TimeSpan timeout);
static member WaitAny : System.Threading.WaitHandle[] * TimeSpan -> int
Public Shared Function WaitAny (waitHandles As WaitHandle(), timeout As TimeSpan) As Integer

Paramètres

waitHandles
WaitHandle[]

Tableau WaitHandle qui contient les objets que l'instance actuelle attendra.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan qui représente le nombre de millièmes de secondes à attendre ou TimeSpan qui représente -1 millième de seconde, pour attendre indéfiniment.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Retours

Index de tableau de l'objet ayant respecté l'attente ou WaitTimeout si aucun objet n'a respecté l'attente et qu'un intervalle de temps équivalent à timeout s'est écoulé.The array index of the object that satisfied the wait, or WaitTimeout if no object satisfied the wait and a time interval equivalent to timeout has passed.

Exceptions

Le paramètre waitHandles a la valeur null.The waitHandles parameter is null.

- ou --or- Un ou plusieurs des objets dans le tableau waitHandles sont null.One or more of the objects in the waitHandles array is null.

Le nombre d’objets dans waitHandles est supérieur à ce que le système autorise.The number of objects in waitHandles is greater than the system permits.

timeout est un nombre négatif autre que -1 milliseconde, qui représente un délai d’attente infini.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - ou --or- timeout est supérieur à MaxValue.timeout is greater than MaxValue.

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.The wait completed because a thread exited without releasing a mutex. Cette exception n’est pas levée sur Windows 98 ou Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles est un tableau sans éléments.waitHandles is an array with no elements.

Le tableau waitHandles contient un proxy transparent pour un WaitHandle dans un autre domaine d’application.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Remarques

Si timeout est égal à zéro, la méthode n’est pas bloquée.If timeout is zero, the method does not block. Il teste l’état des handles d’attente et retourne immédiatement.It tests the state of the wait handles and returns immediately.

La méthode WaitAny lève une AbandonedMutexException uniquement lorsque l’attente se termine en raison d’un mutex abandonné.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contient un mutex libéré avec un numéro d’index inférieur au mutex abandonné, la méthode WaitAny se termine normalement et l’exception n’est pas levée.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.

Cette méthode retourne lorsque l’attente se termine, soit lorsque l’un des handles est signalé, soit lorsqu’un délai d’attente se produit.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Si plusieurs objets sont signalés pendant l’appel, la valeur de retour est l’index de tableau de l’objet signalé avec la plus petite valeur d’index de tous les objets signalés.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. Dans certaines implémentations, si plus de 64 handles sont passés, un NotSupportedException est levé.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

La valeur maximale pour timeout est Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

L’appel de cette surcharge de méthode est identique à l’appel de la surcharge WaitAny(WaitHandle[], TimeSpan, Boolean) et à la spécification de false pour exitContext.Calling this method overload is the same as calling the WaitAny(WaitHandle[], TimeSpan, Boolean) overload and specifying false for exitContext.

WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean) WaitAny(WaitHandle[], Int32, Boolean)

Attend que l’un des éléments du tableau spécifié reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

public:
 static int WaitAny(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout, bool exitContext);
public static int WaitAny (System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext);
static member WaitAny : System.Threading.WaitHandle[] * int * bool -> int
Public Shared Function WaitAny (waitHandles As WaitHandle(), millisecondsTimeout As Integer, exitContext As Boolean) As Integer

Paramètres

waitHandles
WaitHandle[]

Tableau WaitHandle qui contient les objets que l'instance actuelle attendra.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32 Int32 Int32 Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean Boolean Boolean Boolean

true pour quitter le domaine de synchronisation du contexte avant l'attente (dans le cas d'un contexte synchronisé) et l'acquérir à nouveau ensuite ; sinon, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Retours

Index de tableau de l'objet ayant respecté l'attente ou WaitTimeout si aucun objet n'a respecté l'attente et qu'un intervalle de temps équivalent à millisecondsTimeout s'est écoulé.The array index of the object that satisfied the wait, or WaitTimeout if no object satisfied the wait and a time interval equivalent to millisecondsTimeout has passed.

Exceptions

Le paramètre waitHandles a la valeur null.The waitHandles parameter is null.

- ou --or- Un ou plusieurs des objets dans le tableau waitHandles sont null.One or more of the objects in the waitHandles array is null.

Le nombre d’objets dans waitHandles est supérieur à ce que le système autorise.The number of objects in waitHandles is greater than the system permits.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 1.0 ou 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.The wait completed because a thread exited without releasing a mutex. Cette exception n’est pas levée sur Windows 98 ou Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 2.0 ou ultérieure.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

Le tableau waitHandles contient un proxy transparent pour un WaitHandle dans un autre domaine d’application.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Exemples

L’exemple de code suivant montre comment utiliser le pool de threads pour rechercher simultanément un fichier sur plusieurs disques.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Pour des raisons d’espace, seul le répertoire racine de chaque disque est recherché.For space considerations, only the root directory of each disk is searched.

using namespace System;
using namespace System::IO;
using namespace System::Threading;
ref class Search
{
private:

   // Maintain state information to pass to FindCallback.
   ref class State
   {
   public:
      AutoResetEvent^ autoEvent;
      String^ fileName;
      State( AutoResetEvent^ autoEvent, String^ fileName )
         : autoEvent( autoEvent ), fileName( fileName )
      {}

   };


public:
   array<AutoResetEvent^>^autoEvents;
   array<String^>^diskLetters;

   // Search for stateInfo->fileName.
   void FindCallback( Object^ state )
   {
      State^ stateInfo = dynamic_cast<State^>(state);
      
      // Signal if the file is found.
      if ( File::Exists( stateInfo->fileName ) )
      {
         stateInfo->autoEvent->Set();
      }
   }

   Search()
   {
      
      // Retrieve an array of disk letters.
      diskLetters = Environment::GetLogicalDrives();
      autoEvents = gcnew array<AutoResetEvent^>(diskLetters->Length);
      for ( int i = 0; i < diskLetters->Length; i++ )
      {
         autoEvents[ i ] = gcnew AutoResetEvent( false );

      }
   }


   // Search for fileName in the root directory of all disks.
   void FindFile( String^ fileName )
   {
      for ( int i = 0; i < diskLetters->Length; i++ )
      {
         Console::WriteLine(  "Searching for {0} on {1}.", fileName, diskLetters[ i ] );
         ThreadPool::QueueUserWorkItem( gcnew WaitCallback( this, &Search::FindCallback ), gcnew State( autoEvents[ i ],String::Concat( diskLetters[ i ], fileName ) ) );

      }
      
      // Wait for the first instance of the file to be found.
      int index = WaitHandle::WaitAny( autoEvents, 3000, false );
      if ( index == WaitHandle::WaitTimeout )
      {
         Console::WriteLine( "\n{0} not found.", fileName );
      }
      else
      {
         Console::WriteLine( "\n{0} found on {1}.", fileName, diskLetters[ index ] );
      }
   }

};

int main()
{
   Search^ search = gcnew Search;
   search->FindFile( "SomeFile.dat" );
}

using System;
using System.IO;
using System.Threading;

class Test
{
    static void Main()
    {
        Search search = new Search();
        search.FindFile("SomeFile.dat");
    }
}

class Search
{
    // Maintain state information to pass to FindCallback.
    class State
    {
        public AutoResetEvent autoEvent;
        public string         fileName;

        public State(AutoResetEvent autoEvent, string fileName)
        {
            this.autoEvent    = autoEvent;
            this.fileName     = fileName;
        }
    }

    AutoResetEvent[] autoEvents;
    String[] diskLetters;

    public Search()
    {
        // Retrieve an array of disk letters.
        diskLetters = Environment.GetLogicalDrives();

        autoEvents = new AutoResetEvent[diskLetters.Length];
        for(int i = 0; i < diskLetters.Length; i++)
        {
            autoEvents[i] = new AutoResetEvent(false);
        }
    }

    // Search for fileName in the root directory of all disks.
    public void FindFile(string fileName)
    {
        for(int i = 0; i < diskLetters.Length; i++)
        {
            Console.WriteLine("Searching for {0} on {1}.",
                fileName, diskLetters[i]);
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(FindCallback), 
                new State(autoEvents[i], diskLetters[i] + fileName));
        }

        // Wait for the first instance of the file to be found.
        int index = WaitHandle.WaitAny(autoEvents, 3000, false);
        if(index == WaitHandle.WaitTimeout)
        {
            Console.WriteLine("\n{0} not found.", fileName);
        }
        else
        {
            Console.WriteLine("\n{0} found on {1}.", fileName,
                diskLetters[index]);
        }
    }

    // Search for stateInfo.fileName.
    void FindCallback(object state)
    {
        State stateInfo = (State)state;

        // Signal if the file is found.
        if(File.Exists(stateInfo.fileName))
        {
            stateInfo.autoEvent.Set();
        }
    }
}
Imports System.IO
Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        Dim search As New Search()
        search.FindFile("SomeFile.dat")
    End Sub    
End Class

Public Class Search

    ' Maintain state information to pass to FindCallback.
    Class State
        Public autoEvent As AutoResetEvent 
        Public fileName As String         

        Sub New(anEvent As AutoResetEvent, fName As String)
            autoEvent = anEvent
            fileName = fName
        End Sub
    End Class

    Dim autoEvents() As AutoResetEvent
    Dim diskLetters() As String

    Sub New()

        ' Retrieve an array of disk letters.
        diskLetters = Environment.GetLogicalDrives()

        autoEvents = New AutoResetEvent(diskLetters.Length - 1) {}
        For i As Integer = 0 To diskLetters.Length - 1
            autoEvents(i) = New AutoResetEvent(False)
        Next i
    End Sub    
    
    ' Search for fileName in the root directory of all disks.
    Sub FindFile(fileName As String)
        For i As Integer = 0 To diskLetters.Length - 1
            Console.WriteLine("Searching for {0} on {1}.", _
                fileName, diskLetters(i))
        
            ThreadPool.QueueUserWorkItem(AddressOf FindCallback, _ 
                New State(autoEvents(i), diskLetters(i) & fileName))
        Next i

        ' Wait for the first instance of the file to be found.
        Dim index As Integer = _
            WaitHandle.WaitAny(autoEvents, 3000, False)
        If index = WaitHandle.WaitTimeout
            Console.WriteLine(vbCrLf & "{0} not found.", fileName)
        Else
            Console.WriteLine(vbCrLf & "{0} found on {1}.", _
                fileName, diskLetters(index))
        End If
    End Sub

    ' Search for stateInfo.fileName.
    Sub FindCallback(state As Object)
        Dim stateInfo As State = DirectCast(state, State)

        ' Signal if the file is found.
        If File.Exists(stateInfo.fileName) Then
            stateInfo.autoEvent.Set()
        End If
    End Sub

End Class

Remarques

Si millisecondsTimeout est égal à zéro, la méthode n’est pas bloquée.If millisecondsTimeout is zero, the method does not block. Il teste l’état des handles d’attente et retourne immédiatement.It tests the state of the wait handles and returns immediately.

AbandonedMutexException est une nouveauté de la version 2,0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. Dans les versions précédentes, la méthode WaitAny retourne true si l’attente se termine parce qu’un mutex est abandonné.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abandonné indique souvent une erreur de codage grave.An abandoned mutex often indicates a serious coding error. Dans le cas d’un mutex à l’ensemble du système, cela peut indiquer qu’une application a été interrompue brusquement (par exemple, à l’aide du gestionnaire des tâches Windows).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). L’exception contient des informations utiles pour le débogage.The exception contains information useful for debugging.

La méthode WaitAny lève une AbandonedMutexException uniquement lorsque l’attente se termine en raison d’un mutex abandonné.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contient un mutex libéré avec un numéro d’index inférieur au mutex abandonné, la méthode WaitAny se termine normalement et l’exception n’est pas levée.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.

Notes

Dans les versions de la .NET Framework antérieures à la version 2,0, si un thread se termine ou s’abandonne sans libérer explicitement une Mutex, et que Mutex se trouve à l’index 0 (zéro) dans un tableau WaitAny sur un autre thread, l’index retourné par WaitAny est 128 au lieu de 0.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.

Cette méthode retourne lorsque l’attente se termine, soit lorsque l’un des handles est signalé, soit lorsqu’un délai d’attente se produit.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Si plusieurs objets sont signalés pendant l’appel, la valeur de retour est l’index de tableau de l’objet signalé avec la plus petite valeur d’index de tous les objets signalés.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. Dans certaines implémentations, si plus de 64 handles sont passés, un NotSupportedException est levé.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Remarques sur la sortie du contexteNotes on Exiting the Context

Le paramètre exitContext n’a aucun effet, à moins que la méthode WaitAny soit appelée à partir d’un contexte managé non défini par défaut.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Cela peut se produire si votre thread est à l’intérieur d’un appel à une instance d’une classe dérivée de ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Même si vous exécutez actuellement une méthode sur une classe qui ne dérive pas de ContextBoundObject, comme String, vous pouvez être dans un contexte non défini par défaut si un ContextBoundObject se trouve sur votre pile dans le domaine d’application actuel.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Lorsque votre code s’exécute dans un contexte non défini par défaut, la spécification de true pour exitContext provoque la sortie du thread du contexte managé autre que celui par défaut (autrement dit, la transition vers le contexte par défaut) avant l’exécution de la méthode WaitAny.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAny method. Le thread retourne au contexte non par défaut d’origine après l’appel à la méthode WaitAny.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Cela peut être utile lorsque la classe liée au contexte a SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. Dans ce cas, tous les appels aux membres de la classe sont automatiquement synchronisés et le domaine de synchronisation est le corps entier du code pour la classe.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Si le code de la pile des appels d’un membre appelle la méthode WaitAny et spécifie true pour exitContext, le thread quitte le domaine de synchronisation, ce qui permet à un thread qui est bloqué sur un appel à un membre de l’objet de continuer.If code in the call stack of a member calls the WaitAny method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Quand la méthode WaitAny retourne, le thread qui a effectué l’appel doit attendre pour entrer de nouveau dans le domaine de synchronisation.When the WaitAny method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean) WaitAny(WaitHandle[], TimeSpan, Boolean)

Attend que l’un des éléments du tableau spécifié reçoive un signal ; en utilisant une valeur TimeSpan pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

public:
 static int WaitAny(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout, bool exitContext);
public static int WaitAny (System.Threading.WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext);
static member WaitAny : System.Threading.WaitHandle[] * TimeSpan * bool -> int
Public Shared Function WaitAny (waitHandles As WaitHandle(), timeout As TimeSpan, exitContext As Boolean) As Integer

Paramètres

waitHandles
WaitHandle[]

Tableau WaitHandle qui contient les objets que l'instance actuelle attendra.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan qui représente le nombre de millièmes de secondes à attendre ou TimeSpan qui représente -1 millième de seconde, pour attendre indéfiniment.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

exitContext
Boolean Boolean Boolean Boolean

true pour quitter le domaine de synchronisation du contexte avant l'attente (dans le cas d'un contexte synchronisé) et l'acquérir à nouveau ensuite ; sinon, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Retours

Index de tableau de l'objet ayant respecté l'attente ou WaitTimeout si aucun objet n'a respecté l'attente et qu'un intervalle de temps équivalent à timeout s'est écoulé.The array index of the object that satisfied the wait, or WaitTimeout if no object satisfied the wait and a time interval equivalent to timeout has passed.

Exceptions

Le paramètre waitHandles a la valeur null.The waitHandles parameter is null.

ou-or- Un ou plusieurs des objets dans le tableau waitHandles sont null.One or more of the objects in the waitHandles array is null.

Le nombre d’objets dans waitHandles est supérieur à ce que le système autorise.The number of objects in waitHandles is greater than the system permits.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 1.0 ou 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

timeout est un nombre négatif autre que -1 milliseconde, qui représente un délai d’attente infini.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - ou --or- timeout est supérieur à MaxValue.timeout is greater than MaxValue.

L’attente s’est arrêtée, car un thread s’est terminé sans libérer de mutex.The wait completed because a thread exited without releasing a mutex. Cette exception n’est pas levée sur Windows 98 ou Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 2.0 ou ultérieure.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

Le tableau waitHandles contient un proxy transparent pour un WaitHandle dans un autre domaine d’application.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Exemples

L’exemple de code suivant montre comment utiliser le pool de threads pour rechercher simultanément un fichier sur plusieurs disques.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Pour des raisons d’espace, seul le répertoire racine de chaque disque est recherché.For space considerations, only the root directory of each disk is searched.

using namespace System;
using namespace System::IO;
using namespace System::Threading;
ref class Search
{
private:

   // Maintain state information to pass to FindCallback.
   ref class State
   {
   public:
      AutoResetEvent^ autoEvent;
      String^ fileName;
      State( AutoResetEvent^ autoEvent, String^ fileName )
         : autoEvent( autoEvent ), fileName( fileName )
      {}

   };


public:
   array<AutoResetEvent^>^autoEvents;
   array<String^>^diskLetters;

   // Search for stateInfo->fileName.
   void FindCallback( Object^ state )
   {
      State^ stateInfo = dynamic_cast<State^>(state);
      
      // Signal if the file is found.
      if ( File::Exists( stateInfo->fileName ) )
      {
         stateInfo->autoEvent->Set();
      }
   }

   Search()
   {
      
      // Retrieve an array of disk letters.
      diskLetters = Environment::GetLogicalDrives();
      autoEvents = gcnew array<AutoResetEvent^>(diskLetters->Length);
      for ( int i = 0; i < diskLetters->Length; i++ )
      {
         autoEvents[ i ] = gcnew AutoResetEvent( false );

      }
   }


   // Search for fileName in the root directory of all disks.
   void FindFile( String^ fileName )
   {
      for ( int i = 0; i < diskLetters->Length; i++ )
      {
         Console::WriteLine(  "Searching for {0} on {1}.", fileName, diskLetters[ i ] );
         ThreadPool::QueueUserWorkItem( gcnew WaitCallback( this, &Search::FindCallback ), gcnew State( autoEvents[ i ],String::Concat( diskLetters[ i ], fileName ) ) );

      }
      
      // Wait for the first instance of the file to be found.
      int index = WaitHandle::WaitAny( autoEvents, TimeSpan(0,0,3), false );
      if ( index == WaitHandle::WaitTimeout )
      {
         Console::WriteLine( "\n{0} not found.", fileName );
      }
      else
      {
         Console::WriteLine( "\n{0} found on {1}.", fileName, diskLetters[ index ] );
      }
   }

};

int main()
{
   Search^ search = gcnew Search;
   search->FindFile( "SomeFile.dat" );
}

using System;
using System.IO;
using System.Threading;

class Test
{
    static void Main()
    {
        Search search = new Search();
        search.FindFile("SomeFile.dat");
    }
}

class Search
{
    // Maintain state information to pass to FindCallback.
    class State
    {
        public AutoResetEvent autoEvent;
        public string         fileName;

        public State(AutoResetEvent autoEvent, string fileName)
        {
            this.autoEvent    = autoEvent;
            this.fileName     = fileName;
        }
    }

    AutoResetEvent[] autoEvents;
    String[] diskLetters;

    public Search()
    {
        // Retrieve an array of disk letters.
        diskLetters = Environment.GetLogicalDrives();

        autoEvents = new AutoResetEvent[diskLetters.Length];
        for(int i = 0; i < diskLetters.Length; i++)
        {
            autoEvents[i] = new AutoResetEvent(false);
        }
    }

    // Search for fileName in the root directory of all disks.
    public void FindFile(string fileName)
    {
        for(int i = 0; i < diskLetters.Length; i++)
        {
            Console.WriteLine("Searching for {0} on {1}.",
                fileName, diskLetters[i]);
            ThreadPool.QueueUserWorkItem(
                new WaitCallback(FindCallback), 
                new State(autoEvents[i], diskLetters[i] + fileName));
        }

        // Wait for the first instance of the file to be found.
        int index = WaitHandle.WaitAny(
            autoEvents, new TimeSpan(0, 0, 3), false);
        if(index == WaitHandle.WaitTimeout)
        {
            Console.WriteLine("\n{0} not found.", fileName);
        }
        else
        {
            Console.WriteLine("\n{0} found on {1}.", fileName,
                diskLetters[index]);
        }
    }

    // Search for stateInfo.fileName.
    void FindCallback(object state)
    {
        State stateInfo = (State)state;

        // Signal if the file is found.
        if(File.Exists(stateInfo.fileName))
        {
            stateInfo.autoEvent.Set();
        }
    }
}
Imports System.IO
Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        Dim search As New Search()
        search.FindFile("SomeFile.dat")
    End Sub    
End Class

Public Class Search

    ' Maintain state information to pass to FindCallback.
    Class State
        Public autoEvent As AutoResetEvent 
        Public fileName As String         

        Sub New(anEvent As AutoResetEvent, fName As String)
            autoEvent = anEvent
            fileName = fName
        End Sub
    End Class

    Dim autoEvents() As AutoResetEvent
    Dim diskLetters() As String

    Sub New()

        ' Retrieve an array of disk letters.
        diskLetters = Environment.GetLogicalDrives()

        autoEvents = New AutoResetEvent(diskLetters.Length - 1) {}
        For i As Integer = 0 To diskLetters.Length - 1
            autoEvents(i) = New AutoResetEvent(False)
        Next i
    End Sub    
    
    ' Search for fileName in the root directory of all disks.
    Sub FindFile(fileName As String)
        For i As Integer = 0 To diskLetters.Length - 1
            Console.WriteLine("Searching for {0} on {1}.", _
                fileName, diskLetters(i))
        
            ThreadPool.QueueUserWorkItem(AddressOf FindCallback, _ 
                New State(autoEvents(i), diskLetters(i) & fileName))
        Next i

        ' Wait for the first instance of the file to be found.
        Dim index As Integer = WaitHandle.WaitAny( _
            autoEvents, New TimeSpan(0, 0, 3), False)
        If index = WaitHandle.WaitTimeout
            Console.WriteLine(vbCrLf & "{0} not found.", fileName)
        Else
            Console.WriteLine(vbCrLf & "{0} found on {1}.", _
                fileName, diskLetters(index))
        End If
    End Sub

    ' Search for stateInfo.fileName.
    Sub FindCallback(state As Object)
        Dim stateInfo As State = DirectCast(state, State)

        ' Signal if the file is found.
        If File.Exists(stateInfo.fileName) Then
            stateInfo.autoEvent.Set()
        End If
    End Sub

End Class

Remarques

Si timeout est égal à zéro, la méthode n’est pas bloquée.If timeout is zero, the method does not block. Il teste l’état des handles d’attente et retourne immédiatement.It tests the state of the wait handles and returns immediately.

AbandonedMutexException est une nouveauté de la version 2,0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. Dans les versions précédentes, la méthode WaitAny retourne true si l’attente se termine parce qu’un mutex est abandonné.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abandonné indique souvent une erreur de codage grave.An abandoned mutex often indicates a serious coding error. Dans le cas d’un mutex à l’ensemble du système, cela peut indiquer qu’une application a été interrompue brusquement (par exemple, à l’aide du gestionnaire des tâches Windows).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). L’exception contient des informations utiles pour le débogage.The exception contains information useful for debugging.

La méthode WaitAny lève une AbandonedMutexException uniquement lorsque l’attente se termine en raison d’un mutex abandonné.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contient un mutex libéré avec un numéro d’index inférieur au mutex abandonné, la méthode WaitAny se termine normalement et l’exception n’est pas levée.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.

Notes

Dans les versions de la .NET Framework antérieures à la version 2,0, si un thread se termine ou s’abandonne sans libérer explicitement une Mutex, et que Mutex se trouve à l’index 0 (zéro) dans un tableau WaitAny sur un autre thread, l’index retourné par WaitAny est 128 au lieu de 0.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.

Cette méthode retourne lorsque l’attente se termine, soit lorsque l’un des handles est signalé, soit lorsqu’un délai d’attente se produit.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Si plusieurs objets sont signalés pendant l’appel, la valeur de retour est l’index de tableau de l’objet signalé avec la plus petite valeur d’index de tous les objets signalés.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. Dans certaines implémentations, si plus de 64 handles sont passés, un NotSupportedException est levé.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

La valeur maximale pour timeout est Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Remarques sur la sortie du contexteNotes on Exiting the Context

Le paramètre exitContext n’a aucun effet, à moins que la méthode WaitAny soit appelée à partir d’un contexte managé non défini par défaut.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Cela peut se produire si votre thread est à l’intérieur d’un appel à une instance d’une classe dérivée de ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Même si vous exécutez actuellement une méthode sur une classe qui ne dérive pas de ContextBoundObject, comme String, vous pouvez être dans un contexte non défini par défaut si un ContextBoundObject se trouve sur votre pile dans le domaine d’application actuel.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Lorsque votre code s’exécute dans un contexte non défini par défaut, la spécification de true pour exitContext provoque la sortie du thread du contexte managé autre que celui par défaut (autrement dit, la transition vers le contexte par défaut) avant l’exécution de la méthode WaitAny.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAny method. Le thread retourne au contexte non par défaut d’origine après l’appel à la méthode WaitAny.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Cela peut être utile lorsque la classe liée au contexte a SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. Dans ce cas, tous les appels aux membres de la classe sont automatiquement synchronisés et le domaine de synchronisation est le corps entier du code pour la classe.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Si le code de la pile des appels d’un membre appelle la méthode WaitAny et spécifie true pour exitContext, le thread quitte le domaine de synchronisation, ce qui permet à un thread qui est bloqué sur un appel à un membre de l’objet de continuer.If code in the call stack of a member calls the WaitAny method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Quand la méthode WaitAny retourne, le thread qui a effectué l’appel doit attendre pour entrer de nouveau dans le domaine de synchronisation.When the WaitAny method returns, the thread that made the call must wait to reenter the synchronization domain.

S’applique à