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

Definición

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal.Waits for any of the elements in the specified array to receive a signal.

Sobrecargas

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

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal.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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo.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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, usando un TimeSpan para especificar el intervalo de tiempo.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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; utiliza un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; usa un TimeSpan para especificar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.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[])

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal.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

Parámetros

waitHandles
WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.A WaitHandle array containing the objects for which the current instance will wait.

Devoluciones

Índice de la matriz del objeto que satisfizo la espera.The array index of the object that satisfied the wait.

Excepciones

El parámetro waitHandles es null.The waitHandles parameter is null.

O bien-or- Uno o varios objetos de la matriz waitHandles son null.One or more of the objects in the waitHandles array is null.

El número de objetos de waitHandles es mayor de lo que permite el sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.The wait completed because a thread exited without releasing a mutex. Esta excepción no se produce en Windows 98 o en Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 2.0 o posterior.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matriz waitHandles contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Ejemplos

El ejemplo de código siguiente se muestra cómo llamar el WaitAny método.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
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 'Main
    
    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 'DoTask
End Class 'App

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

Comentarios

AbandonedMutexException Novedades de la versión 2.0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. En versiones anteriores, el WaitAny devuelve del método true si la espera finaliza porque se abandona una exclusión mutua.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. A menudo, una exclusión mutua abandonada indica un error grave de codificación.An abandoned mutex often indicates a serious coding error. En el caso de una exclusión mutua todo el sistema, podría indicar que una aplicación ha finalizado abruptamente (por ejemplo, mediante el Administrador de tareas de 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). La excepción contiene información útil para la depuración.The exception contains information useful for debugging.

El WaitAny método produce una AbandonedMutexException solo cuando finaliza la espera debido a una exclusión mutua abandonada.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contiene una exclusión mutua liberada con un número de índice inferior de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.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

En las versiones de .NET Framework anteriores a la versión 2.0, si un subproceso se cierra o anula sin liberar explícitamente un Mutexy que Mutex está en el índice 0 (cero) en un WaitAny matriz en otro subproceso, el índice devuelto por WaitAny es 128 en lugar de 0.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.

Este método devuelve cuando se señala a cualquiera de ellos.This method returns when any handle is signaled. Si más de un objeto se señaliza durante la llamada, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados.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. En algunas implementaciones, si más de 64 identificadores se pasan, un NotSupportedException se produce.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Llamar a esta sobrecarga del método es equivalente a llamar a la WaitAny(WaitHandle[], Int32, Boolean) sobrecarga del método y especificar -1 (o Timeout.Infinite) para millisecondsTimeout y true para 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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo.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

Parámetros

waitHandles
WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32 Int32 Int32 Int32

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Devoluciones

Índice de matriz del objeto que satisfizo la espera o WaitTimeout si ningún objeto satisfizo la espera y transcurrió un intervalo de tiempo 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.

Excepciones

El parámetro waitHandles es null.The waitHandles parameter is null.

O bien-or- Uno o varios objetos de la matriz waitHandles son null.One or more of the objects in the waitHandles array is null.

El número de objetos de waitHandles es mayor de lo que permite el sistema.The number of objects in waitHandles is greater than the system permits.

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.The wait completed because a thread exited without releasing a mutex. Esta excepción no se produce en Windows 98 o en Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles es una matriz sin elementos.waitHandles is an array with no elements.

La matriz waitHandles contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Comentarios

Si millisecondsTimeout es cero, el método no se bloquea.If millisecondsTimeout is zero, the method does not block. Comprueba el estado de los identificadores de espera y vuelve inmediatamente.It tests the state of the wait handles and returns immediately.

El WaitAny método produce una AbandonedMutexException solo cuando finaliza la espera debido a una exclusión mutua abandonada.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contiene una exclusión mutua liberada con un número de índice inferior de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.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.

Este método devuelve cuando finaliza la espera, o cuando se señala a cualquiera de los controladores cuando se produce un tiempo de espera.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Si más de un objeto se señaliza durante la llamada, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados.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. En algunas implementaciones, si más de 64 identificadores se pasan, un NotSupportedException se produce.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Llamar a esta sobrecarga del método es igual que llamar a la WaitAny(WaitHandle[], Int32, Boolean) sobrecarga y especificando false para 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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, usando un TimeSpan para especificar el intervalo de tiempo.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

Parámetros

waitHandles
WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Devoluciones

Índice de matriz del objeto que satisfizo la espera o WaitTimeout si ningún objeto satisfizo la espera y transcurrió un intervalo de tiempo 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.

Excepciones

El parámetro waitHandles es null.The waitHandles parameter is null.

O bien-or- Uno o varios objetos de la matriz waitHandles son null.One or more of the objects in the waitHandles array is null.

El número de objetos de waitHandles es mayor de lo que permite el sistema.The number of objects in waitHandles is greater than the system permits.

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. O bien-or- timeout es mayor que MaxValue.timeout is greater than MaxValue.

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.The wait completed because a thread exited without releasing a mutex. Esta excepción no se produce en Windows 98 o en Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles es una matriz sin elementos.waitHandles is an array with no elements.

La matriz waitHandles contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Comentarios

Si timeout es cero, el método no se bloquea.If timeout is zero, the method does not block. Comprueba el estado de los identificadores de espera y vuelve inmediatamente.It tests the state of the wait handles and returns immediately.

El WaitAny método produce una AbandonedMutexException solo cuando finaliza la espera debido a una exclusión mutua abandonada.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contiene una exclusión mutua liberada con un número de índice inferior de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.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.

Este método devuelve cuando finaliza la espera, o cuando se señala a cualquiera de los controladores cuando se produce un tiempo de espera.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Si más de un objeto se señaliza durante la llamada, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados.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. En algunas implementaciones, si más de 64 identificadores se pasan, un NotSupportedException se produce.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

El valor máximo de timeout es Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Llamar a esta sobrecarga del método es igual que llamar a la WaitAny(WaitHandle[], TimeSpan, Boolean) sobrecarga y especificando false para 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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; utiliza un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.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

Parámetros

waitHandles
WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.A WaitHandle array containing the objects for which the current instance will wait.

millisecondsTimeout
Int32 Int32 Int32 Int32

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean Boolean Boolean Boolean

true para salir del dominio de sincronización del contexto antes de la espera (en caso de encontrarse en un contexto sincronizado) y volver a adquirirlo más tarde; de lo contrario, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Devoluciones

Índice de matriz del objeto que satisfizo la espera o WaitTimeout si ningún objeto satisfizo la espera y transcurrió un intervalo de tiempo 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.

Excepciones

El parámetro waitHandles es null.The waitHandles parameter is null.

O bien-or- Uno o varios objetos de la matriz waitHandles son null.One or more of the objects in the waitHandles array is null.

El número de objetos de waitHandles es mayor de lo que permite el sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.The wait completed because a thread exited without releasing a mutex. Esta excepción no se produce en Windows 98 o en Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 2.0 o posterior.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matriz waitHandles contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Ejemplos

El ejemplo de código siguiente muestra cómo usar el grupo de subprocesos para buscar un archivo en varios discos simultáneamente.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Por motivos de espacio, se busca sólo el directorio raíz de cada 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 Microsoft.VisualBasic
Imports System
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

Comentarios

Si millisecondsTimeout es cero, el método no se bloquea.If millisecondsTimeout is zero, the method does not block. Comprueba el estado de los identificadores de espera y vuelve inmediatamente.It tests the state of the wait handles and returns immediately.

AbandonedMutexException Novedades de la versión 2.0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. En versiones anteriores, el WaitAny devuelve del método true si la espera finaliza porque se abandona una exclusión mutua.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. A menudo, una exclusión mutua abandonada indica un error grave de codificación.An abandoned mutex often indicates a serious coding error. En el caso de una exclusión mutua todo el sistema, podría indicar que una aplicación ha finalizado abruptamente (por ejemplo, mediante el Administrador de tareas de 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). La excepción contiene información útil para la depuración.The exception contains information useful for debugging.

El WaitAny método produce una AbandonedMutexException solo cuando finaliza la espera debido a una exclusión mutua abandonada.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contiene una exclusión mutua liberada con un número de índice inferior de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.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

En las versiones de .NET Framework anteriores a la versión 2.0, si un subproceso se cierra o anula sin liberar explícitamente un Mutexy que Mutex está en el índice 0 (cero) en un WaitAny matriz en otro subproceso, el índice devuelto por WaitAny es 128 en lugar de 0.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.

Este método devuelve cuando finaliza la espera, o cuando se señala a cualquiera de los controladores cuando se produce un tiempo de espera.This method returns when the wait terminates, either when any of the handles are signaled or when a timeout occurs. Si más de un objeto se señaliza durante la llamada, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados.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. En algunas implementaciones, si más de 64 identificadores se pasan, un NotSupportedException se produce.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

Notas sobre la salida del contextoNotes on Exiting the Context

El exitContext parámetro no tiene ningún efecto a menos que el WaitAny método se llama desde dentro de un contexto administrado no predeterminado.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Esto puede ocurrir si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Incluso si se están ejecutando un método en una clase que no se deriva de ContextBoundObject, como String, puede estar en un contexto no predeterminado si un ContextBoundObject en la pila en el dominio de aplicación actual.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.

Cuando el código se ejecuta en un contexto no predeterminado, especificar true para exitContext hace que el subproceso salga del contexto administrado no predeterminado (es decir, para realizar la transición al contexto predeterminado) antes de ejecutar el WaitAny método.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. El subproceso vuelve al contexto original no predeterminado después de llamar a la WaitAny método se completa.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Esto puede ser útil cuando la clase de contexto enlazado tiene SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. En ese caso, todas las llamadas a miembros de la clase se sincronizan automáticamente y el dominio de sincronización es todo el cuerpo de código para la clase.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 llama código en la pila de llamadas de un miembro de la WaitAny método y especifica true para exitContext, el subproceso sale del dominio de sincronización, lo que permite un subproceso que esté bloqueado en una llamada a cualquier miembro del objeto para continuar.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. Cuando el WaitAny método finaliza, el subproceso que realizó la llamada debe esperar para volver a escribir el dominio de sincronización.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)

Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; usa un TimeSpan para especificar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.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

Parámetros

waitHandles
WaitHandle[]

Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará.A WaitHandle array containing the objects for which the current instance will wait.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.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 para salir del dominio de sincronización del contexto antes de la espera (en caso de encontrarse en un contexto sincronizado) y volver a adquirirlo más tarde; de lo contrario, false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Devoluciones

Índice de matriz del objeto que satisfizo la espera o WaitTimeout si ningún objeto satisfizo la espera y transcurrió un intervalo de tiempo 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.

Excepciones

El parámetro waitHandles es null.The waitHandles parameter is null.

O bien-or- Uno o varios objetos de la matriz waitHandles son null.One or more of the objects in the waitHandles array is null.

El número de objetos de waitHandles es mayor de lo que permite el sistema.The number of objects in waitHandles is greater than the system permits.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 1.0 o 1.1.waitHandles is an array with no elements, and the .NET Framework version is 1.0 or 1.1.

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. O bien-or- timeout es mayor que MaxValue.timeout is greater than MaxValue.

La espera finalizó porque un subproceso se cierra sin liberar una exclusión mutua.The wait completed because a thread exited without releasing a mutex. Esta excepción no se produce en Windows 98 o en Windows Millennium Edition.This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles es una matriz sin elementos y la versión de .NET Framework es 2.0 o posterior.waitHandles is an array with no elements, and the .NET Framework version is 2.0 or later.

La matriz waitHandles contiene un proxy transparente para un WaitHandle en otro dominio de aplicación.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Ejemplos

El ejemplo de código siguiente muestra cómo usar el grupo de subprocesos para buscar un archivo en varios discos simultáneamente.The following code example demonstrates how to use the thread pool to simultaneously search for a file on multiple disks. Por motivos de espacio, se busca sólo el directorio raíz de cada 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 Microsoft.VisualBasic
Imports System
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

Comentarios

Si timeout es cero, el método no se bloquea.If timeout is zero, the method does not block. Comprueba el estado de los identificadores de espera y vuelve inmediatamente.It tests the state of the wait handles and returns immediately.

AbandonedMutexException Novedades de la versión 2.0 de .NET Framework.AbandonedMutexException is new in the .NET Framework version 2.0. En versiones anteriores, el WaitAny devuelve del método true si la espera finaliza porque se abandona una exclusión mutua.In previous versions, the WaitAny method returns true if the wait completes because a mutex is abandoned. A menudo, una exclusión mutua abandonada indica un error grave de codificación.An abandoned mutex often indicates a serious coding error. En el caso de una exclusión mutua todo el sistema, podría indicar que una aplicación ha finalizado abruptamente (por ejemplo, mediante el Administrador de tareas de 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). La excepción contiene información útil para la depuración.The exception contains information useful for debugging.

El WaitAny método produce una AbandonedMutexException solo cuando finaliza la espera debido a una exclusión mutua abandonada.The WaitAny method throws an AbandonedMutexException only when the wait completes because of an abandoned mutex. Si waitHandles contiene una exclusión mutua liberada con un número de índice inferior de la exclusión mutua abandonada, el WaitAny método se completa con normalidad y no se produce la excepción.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

En las versiones de .NET Framework anteriores a la versión 2.0, si un subproceso se cierra o anula sin liberar explícitamente un Mutexy que Mutex está en el índice 0 (cero) en un WaitAny matriz en otro subproceso, el índice devuelto por WaitAny es 128 en lugar de 0.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.

Este método devuelve cuando finaliza la espera, o cuando se señala a cualquiera de los controladores cuando se produce un tiempo de espera.This method returns when the wait terminates, either when any of the handles are signaled or when a time-out occurs. Si más de un objeto se señaliza durante la llamada, el valor devuelto es el índice de matriz del objeto señalado con el menor valor de índice de todos los objetos señalados.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. En algunas implementaciones, si más de 64 identificadores se pasan, un NotSupportedException se produce.On some implementations, if more that 64 handles are passed, a NotSupportedException is thrown.

El valor máximo de timeout es Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Notas sobre la salida del contextoNotes on Exiting the Context

El exitContext parámetro no tiene ningún efecto a menos que el WaitAny método se llama desde dentro de un contexto administrado no predeterminado.The exitContext parameter has no effect unless the WaitAny method is called from inside a nondefault managed context. Esto puede ocurrir si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Incluso si se están ejecutando un método en una clase que no se deriva de ContextBoundObject, como String, puede estar en un contexto no predeterminado si un ContextBoundObject en la pila en el dominio de aplicación actual.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.

Cuando el código se ejecuta en un contexto no predeterminado, especificar true para exitContext hace que el subproceso salga del contexto administrado no predeterminado (es decir, para realizar la transición al contexto predeterminado) antes de ejecutar el WaitAny método.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. El subproceso vuelve al contexto original no predeterminado después de llamar a la WaitAny método se completa.The thread returns to the original nondefault context after the call to the WaitAny method completes.

Esto puede ser útil cuando la clase de contexto enlazado tiene SynchronizationAttribute.This can be useful when the context-bound class has SynchronizationAttribute. En ese caso, todas las llamadas a miembros de la clase se sincronizan automáticamente y el dominio de sincronización es todo el cuerpo de código para la clase.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 llama código en la pila de llamadas de un miembro de la WaitAny método y especifica true para exitContext, el subproceso sale del dominio de sincronización, lo que permite un subproceso que esté bloqueado en una llamada a cualquier miembro del objeto para continuar.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. Cuando el WaitAny método finaliza, el subproceso que realizó la llamada debe esperar para volver a escribir el dominio de sincronización.When the WaitAny method returns, the thread that made the call must wait to reenter the synchronization domain.

Se aplica a