Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método WaitHandle.WaitAny (WaitHandle[], TimeSpan, Boolean)

 

Publicado: octubre de 2016

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.

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

public static int WaitAny(
	WaitHandle[] waitHandles,
	TimeSpan timeout,
	bool exitContext
)

Parámetros

waitHandles
Type: System.Threading.WaitHandle[]

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

timeout
Type: System.TimeSpan

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.

exitContext
Type: System.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.

Valor devuelto

Type: System.Int32

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

Exception Condition
ArgumentNullException

El parámetro waitHandles es null.

-o-

Uno o varios objetos de la matriz waitHandles son null.

NotSupportedException

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

ApplicationException

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

ArgumentOutOfRangeException

timeout es un número negativo distinto de-1 milisegundos, que representa un tiempo de espera infinito.

-o-

timeout es mayor que Int32.MaxValue.

AbandonedMutexException

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

ArgumentException

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

InvalidOperationException

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

Si timeout es cero, el método no se bloquea. Comprueba el estado de los identificadores de espera y vuelve inmediatamente.

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

El WaitAny método produce un AbandonedMutexException sólo cuando finaliza la espera debido a un mutex abandonado. Si waitHandles contiene una exclusión mutua liberada con un número de índice menor que el mutex abandonado la WaitAny método se completa con normalidad y no se produce la excepción.

System_CAPS_noteNota

En las versiones de .NET Framework anterior a la versión 2.0, si un subproceso termina o se interrumpe 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.

Este método devuelve cuando finaliza la espera, cuando cualquiera de los identificadores está señalado o cuando se produce un tiempo de espera. 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. En algunas implementaciones, si se pasan 64 identificadores, más de un NotSupportedException se produce.

El valor máximo de timeout es Int32.MaxValue.

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. Esto puede ocurrir si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject. Incluso si está ejecutando actualmente 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.

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, pase al contexto predeterminado) antes de ejecutar el WaitAny método. El subproceso vuelve al contexto no predeterminado original después de llamar a la WaitAny método se completa.

Esto puede ser útil cuando la clase enlazadas a un contexto tiene SynchronizationAttribute. En ese caso, todas las llamadas a miembros de la clase se sincronizan automáticamente y el dominio de sincronización es el cuerpo completo del código de la clase. Si el código de la pila de llamadas de un miembro llama el WaitAny método y especifica true para exitContext, el subproceso sale del dominio de sincronización, permitiendo la continuación un subproceso que esté bloqueado en una llamada a cualquier miembro del objeto para continuar. Cuando el WaitAny método vuelve, el subproceso que realiza la llamada debe esperar para volver a escribir el dominio de sincronización.

En el ejemplo de código siguiente se muestra cómo utilizar el grupo de subprocesos para buscar un archivo en varios discos al mismo tiempo. Por motivos de espacio, se busca únicamente el directorio raíz de cada disco.

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();
        }
    }
}

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: