Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

WaitHandle.WaitAll (Método) (WaitHandle[], Int32, Boolean)

Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un valor Int32 para especificar el intervalo de tiempo y especificar 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 bool WaitAll(
	WaitHandle[] waitHandles,
	int millisecondsTimeout,
	bool exitContext
)

Parámetros

waitHandles
Tipo: System.Threading.WaitHandle[]
Matriz WaitHandle que contiene los objetos por los que la instancia actual esperará. Esta matriz no puede contener varias referencias al mismo objeto (duplicados).
millisecondsTimeout
Tipo: System.Int32
Número de milisegundos de espera o Timeout.Infinite (-1) para esperar indefinidamente.
exitContext
Tipo: System.Boolean
true para salir del dominio de sincronización para el contexto antes de la espera (en caso de encontrarse en un contexto sincronizado) y volver a adquirirlo más tarde; en caso contrario, false.

Valor devuelto

Tipo: System.Boolean
Es true cuando todos los elementos de waitHandles han recibido una señal; en caso contrario, es false.

ExcepciónCondición
ArgumentNullException

El parámetro waitHandles es null.

O bien

Al menos uno de los objetos de la matriz waitHandles es null.

O bien

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

DuplicateWaitObjectException

La matriz waitHandles contiene elementos duplicados.

NotSupportedException

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

O bien

El atributo STAThreadAttribute se aplica al procedimiento de subproceso del subproceso actual y waitHandles contiene más de un elemento.

ApplicationException

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

ArgumentOutOfRangeException

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

AbandonedMutexException

La espera finalizó porque un subproceso se cerró sin liberar una exclusión mutua. Esta excepción no se genera en Windows 98 ni en Windows Millennium.

InvalidOperationException

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

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

AbandonedMutexException es nuevo en la versión 2.0 de .NET Framework. En las versiones anteriores, el método WaitAll devuelve true cuando se abandona una exclusión mutua. Una exclusión mutua abandonada suele indicar un error de codificación grave. En el caso de exclusión mutua en todo el sistema, podría indicar que una aplicación ha finalizado de forma abrupta (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para depurar.

El método WaitAll devuelve el momento de finalización de la espera, lo que significa que todos los identificadores están señalados o que ha transcurrido el tiempo de espera. En algunas implementaciones, si se pasan más de 64 identificadores, se produce una excepción NotSupportedException. Si la matriz contiene duplicados, la llamada producirá errores y una excepción DuplicateWaitObjectException.

NotaNota

El método WaitAll no se admite en los subprocesos con STAThreadAttribute.

Notas sobre la salida del contexto

El parámetro exitContext no tiene ningún efecto a menos que se llame al método WaitAll desde un contexto administrado no predeterminado. Esto puede suceder si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject. Aunque esté ejecutando un método en una clase que no se derive de ContextBoundObject, como String, puede estar en un contexto no predeterminado si hay una clase ContextBoundObject en la pila del actual dominio de aplicación.

Cuando el código se ejecuta en un contexto no predeterminado, especificar el valor true para exitContext hace que el subproceso salga del contexto administrado no predeterminado (es decir, que pase al contexto predeterminado) antes de que se ejecute el método WaitAll. El subproceso volverá al contexto no predeterminado original cuando finalice la llamada al método WaitAll.

Esto puede ser útil cuando la clase enlazada al contexto tenga el atributo SynchronizationAttribute. En ese caso, todas las llamadas a los miembros de la clase se sincronizan automáticamente y el dominio de sincronización es el cuerpo de código completo para la clase. Si el código de la pila de llamadas de un miembro llama al método WaitAll y especifica true para exitContext, el subproceso saldrá del dominio de sincronización, permitiendo la continuación de un subproceso que esté bloqueado en una llamada a cualquier miembro del objeto. Cuando el método WaitAll realiza una devolución, el subproceso que hizo la llamada debe esperar para volver a entrar en el dominio de sincronización.

En el ejemplo de código siguiente se muestra la forma de utilizar el grupo de subprocesos para crear y escribir de forma asincrónica en un grupo de archivos. Cada operación de escritura se sitúa en la cola como un elemento de trabajo y señala cuando ha finalizado. El subproceso principal espera a que todos los elementos señalen y después se cierra.


using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

class Test
{
    static void Main()
    {
        const int numberOfFiles = 5;
        string dirName = @"C:\TestTest";
        string fileName;

        byte[] byteArray;
        Random randomGenerator = new Random();

        ManualResetEvent[] manualEvents = 
            new ManualResetEvent[numberOfFiles];
        State stateInfo;

        if(!Directory.Exists(dirName))
        {
            Directory.CreateDirectory(dirName);
        }

        // Queue the work items that create and write to the files.
        for(int i = 0; i < numberOfFiles; i++)
        {
            fileName = string.Concat(
                dirName, @"\Test", i.ToString(), ".dat");

            // Create random data to write to the file.
            byteArray = new byte[1000000];
            randomGenerator.NextBytes(byteArray);

            manualEvents[i] = new ManualResetEvent(false);

            stateInfo = 
                new State(fileName, byteArray, manualEvents[i]);

            ThreadPool.QueueUserWorkItem(new WaitCallback(
                Writer.WriteToFile), stateInfo);
        }

        // Since ThreadPool threads are background threads, 
        // wait for the work items to signal before exiting.
        if(WaitHandle.WaitAll(manualEvents, 5000, false))
        {
            Console.WriteLine("Files written - main exiting.");
        }
        else
        {
            // The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.");
        }
    }
}

// Maintain state to pass to WriteToFile.
class State
{
    public string fileName;
    public byte[] byteArray;
    public ManualResetEvent manualEvent;

    public State(string fileName, byte[] byteArray, 
        ManualResetEvent manualEvent)
    {
        this.fileName = fileName;
        this.byteArray = byteArray;
        this.manualEvent = manualEvent;
    }
}

class Writer
{
    static int workItemCount = 0;
    Writer() {}

    public static void WriteToFile(object state)
    {
        int workItemNumber = workItemCount;
        Interlocked.Increment(ref workItemCount);
        Console.WriteLine("Starting work item {0}.",
            workItemNumber.ToString());
        State stateInfo = (State)state;
        FileStream fileWriter = null;

        // Create and write to the file.
        try
        {
            fileWriter = new FileStream(
                stateInfo.fileName, FileMode.Create);
            fileWriter.Write(stateInfo.byteArray, 
                0, stateInfo.byteArray.Length);
        }
        finally
        {
            if(fileWriter != null)
            {
                fileWriter.Close();
            }

            // Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", 
                workItemNumber.ToString());
            stateInfo.manualEvent.Set();
        }
    }
}


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft