WaitHandle.WaitAny Metodo

Definizione

Attende che uno degli elementi nella matrice specificata riceva un segnale.Waits for any of the elements in the specified array to receive a signal.

Overload

WaitAny(WaitHandle[])

Attende che uno degli elementi nella matrice specificata riceva un segnale.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.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)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.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)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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[])

Attende che uno degli elementi nella matrice specificata riceva un segnale.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

Parametri

waitHandles
WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.A WaitHandle array containing the objects for which the current instance will wait.

Restituisce

Indice della matrice dell'oggetto che ha soddisfatto l'attesa.The array index of the object that satisfied the wait.

Eccezioni

Il valore del parametro waitHandles è null.The waitHandles parameter is null.

-oppure--or- Uno o più oggetti nella matrice waitHandles sono null.One or more of the objects in the waitHandles array is null.

Il numero di oggetti in waitHandles è maggiore di quello consentito dal sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles è una matrice senza elementi e la versione di .NET Framework è 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles è una matrice senza elementi e la versione di .NET Framework è la 2.0 o successiva.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matrice waitHandles contiene un proxy trasparente per un oggetto WaitHandle in un altro dominio di applicazione.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice riportato di seguito viene illustrata la chiamata al metodo 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).

Commenti

AbandonedMutexException è una novità della versione .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il metodo WaitAny restituisce true se l'attesa viene completata perché un mutex viene abbandonato.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di 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'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il metodo WaitAny genera un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato, il metodo WaitAny viene completato normalmente e l'eccezione non viene generata.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.

Nota

Nelle versioni del .NET Framework precedenti alla versione 2,0, se un thread viene chiuso o interrotto senza rilasciare esplicitamente un Mutex e il valore di Mutex si trova in corrispondenza dell'indice 0 (zero) in una matrice WaitAny in un altro thread, l'indice restituito da WaitAny è 128 anziché 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.

Questo metodo restituisce quando viene segnalato un handle.This method returns when any handle is signaled. Se durante la chiamata viene segnalato più di un oggetto, il valore restituito è l'indice della matrice dell'oggetto segnalato con il valore di indice più piccolo di tutti gli oggetti segnalati.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. In alcune implementazioni, se vengono passati più handle 64, viene generata un'NotSupportedException.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

La chiamata a questo overload del metodo equivale alla chiamata dell'overload del metodo WaitAny(WaitHandle[], Int32, Boolean) e alla specifica di-1 (o Timeout.Infinite) per millisecondsTimeout e true per 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)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.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

Parametri

waitHandles
WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Restituisce

Indice della matrice dell'oggetto che ha soddisfatto l'attesa oppure WaitTimeout se nessun oggetto ha soddisfatto l'attesa ed è trascorso un intervallo di tempo equivalente a millisecondsTimeout.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.

Eccezioni

Il valore del parametro waitHandles è null.The waitHandles parameter is null.

-oppure--or- Uno o più oggetti nella matrice waitHandles sono null.One or more of the objects in the waitHandles array is null.

Il numero di oggetti in waitHandles è maggiore di quello consentito dal sistema.The number of objects in waitHandles is greater than the system permits.

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles è una matrice senza elementi.waitHandles is an array with no elements.

La matrice waitHandles contiene un proxy trasparente per un oggetto WaitHandle in un altro dominio di applicazione.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Commenti

Se millisecondsTimeout è zero, il metodo non viene bloccato.If millisecondsTimeout is zero, the method does not block. Verifica lo stato degli handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handles and returns immediately.

Il metodo WaitAny genera un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato, il metodo WaitAny viene completato normalmente e l'eccezione non viene generata.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.

Questo metodo restituisce quando l'attesa termina, quando uno degli handle viene segnalato o quando si verifica un timeout.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Se durante la chiamata viene segnalato più di un oggetto, il valore restituito è l'indice della matrice dell'oggetto segnalato con il valore di indice più piccolo di tutti gli oggetti segnalati.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. In alcune implementazioni, se vengono passati più handle 64, viene generata un'NotSupportedException.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

La chiamata a questo overload del metodo equivale alla chiamata dell'overload WaitAny(WaitHandle[], Int32, Boolean) e alla specifica di false per exitContext.Calling this method overload is the same as calling the WaitAny(WaitHandle[], Int32, Boolean) overload and specifying false for exitContext.

WaitAny(WaitHandle[], TimeSpan)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.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

Parametri

waitHandles
WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan

Oggetto TimeSpan che rappresenta il numero di millisecondi di attesa oppure TimeSpan che rappresenta -1 millisecondi per un'attesa indefinita.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Restituisce

Indice della matrice dell'oggetto che ha soddisfatto l'attesa oppure WaitTimeout se nessun oggetto ha soddisfatto l'attesa ed è trascorso un intervallo di tempo equivalente a timeout.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.

Eccezioni

Il valore del parametro waitHandles è null.The waitHandles parameter is null.

In alternativa-or- Uno o più oggetti nella matrice waitHandles sono null.One or more of the objects in the waitHandles array is null.

Il numero di oggetti in waitHandles è maggiore di quello consentito dal sistema.The number of objects in waitHandles is greater than the system permits.

timeout è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. In alternativa-or- timeout è maggiore di MaxValue.timeout is greater than MaxValue.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles è una matrice senza elementi.waitHandles is an array with no elements.

La matrice waitHandles contiene un proxy trasparente per un oggetto WaitHandle in un altro dominio di applicazione.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Commenti

Se timeout è zero, il metodo non viene bloccato.If timeout is zero, the method does not block. Verifica lo stato degli handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handles and returns immediately.

Il metodo WaitAny genera un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato, il metodo WaitAny viene completato normalmente e l'eccezione non viene generata.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.

Questo metodo restituisce quando l'attesa termina, quando uno degli handle viene segnalato o quando si verifica un timeout.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Se durante la chiamata viene segnalato più di un oggetto, il valore restituito è l'indice della matrice dell'oggetto segnalato con il valore di indice più piccolo di tutti gli oggetti segnalati.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. In alcune implementazioni, se vengono passati più handle 64, viene generata un'NotSupportedException.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Il valore massimo per timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

La chiamata a questo overload del metodo equivale alla chiamata dell'overload WaitAny(WaitHandle[], TimeSpan, Boolean) e alla specifica di false per 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)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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

Parametri

waitHandles
WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean

true per uscire dal dominio di sincronizzazione per il contesto prima dell'attesa, se all'interno di un contesto sincronizzato, e riacquisirlo successivamente; in caso contrario, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Restituisce

Indice della matrice dell'oggetto che ha soddisfatto l'attesa oppure WaitTimeout se nessun oggetto ha soddisfatto l'attesa ed è trascorso un intervallo di tempo equivalente a millisecondsTimeout.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.

Eccezioni

Il valore del parametro waitHandles è null.The waitHandles parameter is null.

-oppure--or- Uno o più oggetti nella matrice waitHandles sono null.One or more of the objects in the waitHandles array is null.

Il numero di oggetti in waitHandles è maggiore di quello consentito dal sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles è una matrice senza elementi e la versione di .NET Framework è 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles è una matrice senza elementi e la versione di .NET Framework è la 2.0 o successiva.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matrice waitHandles contiene un proxy trasparente per un oggetto WaitHandle in un altro dominio di applicazione.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice riportato di seguito viene illustrato come utilizzare il pool di thread per cercare contemporaneamente un file su più dischi.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Per le considerazioni sullo spazio, viene eseguita la ricerca solo nella directory radice di ogni disco.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

Commenti

Se millisecondsTimeout è zero, il metodo non viene bloccato.If millisecondsTimeout is zero, the method does not block. Verifica lo stato degli handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handles and returns immediately.

AbandonedMutexException è una novità della versione .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il metodo WaitAny restituisce true se l'attesa viene completata perché un mutex viene abbandonato.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di 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'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il metodo WaitAny genera un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato, il metodo WaitAny viene completato normalmente e l'eccezione non viene generata.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.

Nota

Nelle versioni del .NET Framework precedenti alla versione 2,0, se un thread viene chiuso o interrotto senza rilasciare esplicitamente un Mutex e il valore di Mutex si trova in corrispondenza dell'indice 0 (zero) in una matrice WaitAny in un altro thread, l'indice restituito da WaitAny è 128 anziché 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.

Questo metodo restituisce quando l'attesa termina, quando uno degli handle viene segnalato o quando si verifica un timeout.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Se durante la chiamata viene segnalato più di un oggetto, il valore restituito è l'indice della matrice dell'oggetto segnalato con il valore di indice più piccolo di tutti gli oggetti segnalati.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. In alcune implementazioni, se vengono passati più handle 64, viene generata un'NotSupportedException.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Note sull'uscita dal contestoNotes on Exiting the Context

Il parametro exitContext non ha alcun effetto a meno che il metodo WaitAny non venga chiamato dall'interno di un contesto gestito non predefinito.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Questo problema può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di una classe derivata da ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se si sta eseguendo un metodo in una classe che non deriva da ContextBoundObject, ad esempio String, è possibile trovarsi in un contesto non predefinito se uno ContextBoundObject si trova nello stack nel dominio applicazione corrente.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.

Quando il codice è in esecuzione in un contesto non predefinito, se si specifica true per exitContext, il thread esce dal contesto gestito non predefinito, ovvero per passare al contesto predefinito, prima di eseguire il metodo 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. Il thread torna al contesto non predefinito originale dopo che la chiamata al metodo WaitAny è stata completata.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Questa operazione può essere utile quando la classe associata al contesto ha SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe vengono sincronizzate automaticamente e il dominio di sincronizzazione è l'intero corpo del codice per 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. Se il codice nello stack di chiamate di un membro chiama il metodo WaitAny e specifica true per exitContext, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a un membro dell'oggetto di continuare.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. Quando il metodo WaitAny restituisce, il thread che ha effettuato la chiamata deve attendere la reimmissione del dominio di sincronizzazione.When the WaitAny method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAny(WaitHandle[], TimeSpan, Boolean)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.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

Parametri

waitHandles
WaitHandle[]

Matrice WaitHandle contenente gli oggetti per i quali l'istanza corrente attenderà.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan

Oggetto TimeSpan che rappresenta il numero di millisecondi di attesa oppure TimeSpan che rappresenta -1 millisecondi per un'attesa indefinita.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

exitContext
Boolean

true per uscire dal dominio di sincronizzazione per il contesto prima dell'attesa, se all'interno di un contesto sincronizzato, e riacquisirlo successivamente; in caso contrario, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Restituisce

Indice della matrice dell'oggetto che ha soddisfatto l'attesa oppure WaitTimeout se nessun oggetto ha soddisfatto l'attesa ed è trascorso un intervallo di tempo equivalente a timeout.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.

Eccezioni

Il valore del parametro waitHandles è null.The waitHandles parameter is null.

-oppure--or- Uno o più oggetti nella matrice waitHandles sono null.One or more of the objects in the waitHandles array is null.

Il numero di oggetti in waitHandles è maggiore di quello consentito dal sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles è una matrice senza elementi e la versione di .NET Framework è 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

timeout è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. In alternativa-or- timeout è maggiore di MaxValue.timeout is greater than MaxValue.

L'attesa è terminata perché un thread è stato chiuso senza rilasciare un mutex.The wait completed because a thread exited without releasing a mutex. Questa eccezione non viene generata in Windows 98 o Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles è una matrice senza elementi e la versione di .NET Framework è la 2.0 o successiva.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matrice waitHandles contiene un proxy trasparente per un oggetto WaitHandle in un altro dominio di applicazione.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Esempi

Nell'esempio di codice riportato di seguito viene illustrato come utilizzare il pool di thread per cercare contemporaneamente un file su più dischi.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Per le considerazioni sullo spazio, viene eseguita la ricerca solo nella directory radice di ogni disco.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

Commenti

Se timeout è zero, il metodo non viene bloccato.If timeout is zero, the method does not block. Verifica lo stato degli handle di attesa e restituisce immediatamente un risultato.It tests the state of the wait handles and returns immediately.

AbandonedMutexException è una novità della versione .NET Framework 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. Nelle versioni precedenti il metodo WaitAny restituisce true se l'attesa viene completata perché un mutex viene abbandonato.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. Un mutex abbandonato spesso indica un errore di codifica grave.An abandoned mutex often indicates a serious coding error. Nel caso di un mutex a livello di sistema, potrebbe indicare che un'applicazione è stata interrotta bruscamente, ad esempio tramite Gestione attività di 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'eccezione contiene informazioni utili per il debug.The exception contains information useful for debugging.

Il metodo WaitAny genera un AbandonedMutexException solo quando l'attesa viene completata a causa di un mutex abbandonato.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Se waitHandles contiene un mutex rilasciato con un numero di indice inferiore rispetto al mutex abbandonato, il metodo WaitAny viene completato normalmente e l'eccezione non viene generata.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.

Nota

Nelle versioni del .NET Framework precedenti alla versione 2,0, se un thread viene chiuso o interrotto senza rilasciare esplicitamente un Mutex e il valore di Mutex si trova in corrispondenza dell'indice 0 (zero) in una matrice WaitAny in un altro thread, l'indice restituito da WaitAny è 128 anziché 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.

Questo metodo restituisce quando l'attesa termina, quando uno degli handle viene segnalato o quando si verifica un timeout.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Se durante la chiamata viene segnalato più di un oggetto, il valore restituito è l'indice della matrice dell'oggetto segnalato con il valore di indice più piccolo di tutti gli oggetti segnalati.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. In alcune implementazioni, se vengono passati più handle 64, viene generata un'NotSupportedException.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Il valore massimo per timeout è Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Note sull'uscita dal contestoNotes on Exiting the Context

Il parametro exitContext non ha alcun effetto a meno che il metodo WaitAny non venga chiamato dall'interno di un contesto gestito non predefinito.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Questo problema può verificarsi se il thread si trova all'interno di una chiamata a un'istanza di una classe derivata da ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Anche se si sta eseguendo un metodo in una classe che non deriva da ContextBoundObject, ad esempio String, è possibile trovarsi in un contesto non predefinito se uno ContextBoundObject si trova nello stack nel dominio applicazione corrente.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.

Quando il codice è in esecuzione in un contesto non predefinito, se si specifica true per exitContext, il thread esce dal contesto gestito non predefinito, ovvero per passare al contesto predefinito, prima di eseguire il metodo 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. Il thread torna al contesto non predefinito originale dopo che la chiamata al metodo WaitAny è stata completata.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Questa operazione può essere utile quando la classe associata al contesto ha SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. In tal caso, tutte le chiamate ai membri della classe vengono sincronizzate automaticamente e il dominio di sincronizzazione è l'intero corpo del codice per 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. Se il codice nello stack di chiamate di un membro chiama il metodo WaitAny e specifica true per exitContext, il thread esce dal dominio di sincronizzazione, consentendo a un thread bloccato in una chiamata a un membro dell'oggetto di continuare.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. Quando il metodo WaitAny restituisce, il thread che ha effettuato la chiamata deve attendere la reimmissione del dominio di sincronizzazione.When the WaitAny method returns, the thread that made the call must wait to reenter the synchronization domain.

Si applica a