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.WaitAll (WaitHandle[])

 

Espera a que todos los elementos de la matriz especificada reciban una señal.

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

public static bool WaitAll(
	WaitHandle[] waitHandles
)

Parámetros

waitHandles
Type: 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.

Valor devuelto

Type: System.Boolean

true cuando todos los elementos de waitHandles reciben una señal; en caso contrario, el método nunca devuelve ningún valor.

Exception Condition
ArgumentNullException

El parámetro waitHandles es null. O bien

Uno o varios objetos de la matriz waitHandles son null.

-o-

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

DuplicateWaitObjectException
System_CAPS_noteNota

En las aplicaciones .NET para la Tienda Windows o la Biblioteca de clases portable, capture en su lugar la excepción de clase base, ArgumentException.

La matriz waitHandles contiene elementos que son duplicados.

NotSupportedException

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

O bien

El atributo STAThreadAttribute se aplica al procedimiento de subproceso para el 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 o 1.1.

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.

InvalidOperationException

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

AbandonedMutexException is new in the .NET Framework version 2.0. In previous versions, the WaitAll method returns true when a mutex is abandoned. An abandoned mutex often indicates a serious coding error. 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). The exception contains information useful for debugging.

The Overload:System.Threading.WaitHandle.WaitAll method returns when all the handles are signaled. On some implementations, if more than 64 handles are passed, a T:System.NotSupportedException is thrown. If the array contains duplicates, the call fails with a T:System.DuplicateWaitObjectException.

System_CAPS_noteNota

The Overload:System.Threading.WaitHandle.WaitAll method is not supported on threads that have T:System.STAThreadAttribute.

Calling this method overload is equivalent to calling the M:System.Threading.WaitHandle.WaitAll(System.Threading.WaitHandle[],System.Int32,System.Boolean) method overload and specifying -1 (or F:System.Threading.Timeout.Infinite) for millisecondsTimeoutand true for exitContext.

The following code example shows how to use the thread pool to asynchronously create and write to a group of files. Each write operation is queued as a work item and signals when it is finished. The main thread waits for all the items to signal and then exits.

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.
        WaitHandle.WaitAll(manualEvents);
        Console.WriteLine("Files written - 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();
        }
    }
}

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: