WaitHandle.WaitAll Método

Definición

Espacio de nombres:: System.Threading

Ensamblados:: netstandard.dll, System.Runtime.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Ensamblados:: mscorlib.dll, System.Runtime.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

Sobrecargas

Nombre	Description
WaitAll(WaitHandle[], TimeSpan, Boolean)	Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un TimeSpan valor para especificar el intervalo de tiempo y especificando si se sale del dominio de sincronización antes de la espera.
WaitAll(WaitHandle[], Int32, Boolean)	Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un Int32 valor para especificar el intervalo de tiempo y especificando si salir del dominio de sincronización antes de la espera.
WaitAll(WaitHandle[], TimeSpan)	Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un TimeSpan valor para especificar el intervalo de tiempo.
WaitAll(WaitHandle[], Int32)	Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un Int32 valor para especificar el intervalo de tiempo.
WaitAll(WaitHandle[])	Espera a que todos los elementos de la matriz especificada reciban una señal.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un TimeSpan valor para especificar el intervalo de tiempo y especificando si se sale del dominio de sincronización antes de la espera.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout, bool exitContext);

public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext);

static member WaitAll : System.Threading.WaitHandle[] * TimeSpan * bool -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), timeout As TimeSpan, exitContext As Boolean) As Boolean

Parámetros

waitHandles: WaitHandle[]

Matriz WaitHandle que contiene los objetos para los que esperará la instancia actual. Esta matriz no puede contener varias referencias al mismo objeto.

timeout: TimeSpan

TimeSpan que representa el número de milisegundos que se van a esperar, o que TimeSpan representa -1 milisegundos, para esperar indefinidamente.

exitContext: Boolean

true para salir del dominio de sincronización del contexto antes de la espera (si está en un contexto sincronizado) y volver a adquirirlo después; de lo contrario, false.

Devoluciones

Boolean

true cuando cada elemento de waitHandles ha recibido una señal; en caso contrario false, .

Excepciones

ArgumentNullException

El waitHandles parámetro es null.

O bien

Uno o varios de los objetos de la waitHandles matriz son null.

O bien

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

DuplicateWaitObjectException

La waitHandles matriz contiene elementos duplicados.

NotSupportedException

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

O bien

El STAThreadAttribute atributo 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 o 1.1.

ArgumentOutOfRangeException

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

O bien

timeout es mayor que Int32.MaxValue.

AbandonedMutexException

La espera finalizó porque un subproceso salió sin liberar una exclusión mutua.

InvalidOperationException

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

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar el grupo de subprocesos para crear y escribir de forma asincrónica en un grupo de archivos. Cada operación de escritura se pone en cola como un elemento de trabajo y señala cuando finaliza. El subproceso principal espera a que todos los elementos señalen y, a continuación, salga.

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, new TimeSpan(0, 0, 5), 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();
        }
    }
}

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            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(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        If WaitHandle.WaitAll( _
            manualEvents, New TimeSpan(0, 0, 5), false) = True  Then

            Console.WriteLine("Files written - main exiting.")
        Else
        
            ' The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.")
        End If
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Comentarios

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

Si se abandona una exclusión mutua, se produce una AbandonedMutexException excepción . Una exclusión mutua abandonada suele indicar un error de codificación grave. En el caso de una exclusión mutua en todo el sistema, podría indicar que una aplicación se ha terminado abruptamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El WaitAll método devuelve cuando finaliza la espera, lo que significa que se indican todos los identificadores o se produce un tiempo de espera. Si se pasan más de 64 identificadores, se produce una NotSupportedException excepción . Si la matriz contiene duplicados, se producirá un error en la llamada.

Nota:

El WaitAll método no se admite en subprocesos en STA estado.

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

Salir del contexto

El exitContext parámetro no tiene ningún efecto a menos que se llame a este método desde dentro de un contexto administrado no predeterminado. El contexto administrado puede no ser predeterminado si el subproceso está dentro de una llamada a una instancia de una clase derivada de ContextBoundObject. Incluso si actualmente está ejecutando un método en una clase que no se deriva de ContextBoundObject, como String, puede estar en un contexto no predeterminado si se ContextBoundObject encuentra 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, para realizar la transición al contexto predeterminado) antes de ejecutar este método. El subproceso vuelve al contexto no predeterminado original una vez completada la llamada a este método.

Salir del contexto puede ser útil cuando la clase enlazada al contexto tiene el SynchronizationAttribute atributo . En ese caso, todas las llamadas a los miembros de la clase se sincronizan automáticamente y el dominio de sincronización es todo el cuerpo de código de la clase. Si el código de la pila de llamadas de un miembro llama a este método y especifica para exitContext, el subproceso true sale del dominio de sincronización, lo que permite que un subproceso bloqueado en una llamada a cualquier miembro del objeto continúe. Cuando este método vuelve, el subproceso que realizó la llamada debe esperar a volver a escribir el dominio de sincronización.

Se aplica a

WaitAll(WaitHandle[], Int32, Boolean)

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un Int32 valor para especificar el intervalo de tiempo y especificando si salir del dominio de sincronización antes de la espera.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout, bool exitContext);

public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext);

static member WaitAll : System.Threading.WaitHandle[] * int * bool -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parámetros

waitHandles: WaitHandle[]

Matriz WaitHandle que contiene los objetos para los que esperará la instancia actual. Esta matriz no puede contener varias referencias al mismo objeto (duplicados).

millisecondsTimeout: Int32

Número de milisegundos que se van a esperar o Infinite (-1) para esperar indefinidamente.

exitContext: Boolean

true para salir del dominio de sincronización del contexto antes de la espera (si está en un contexto sincronizado) y volver a adquirirlo después; de lo contrario, false.

Devoluciones

Boolean

true cuando cada elemento de waitHandles ha recibido una señal; de lo contrario, falsees .

Excepciones

ArgumentNullException

El waitHandles parámetro es null.

O bien

Uno o varios de los objetos de la waitHandles matriz son null.

O bien

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

DuplicateWaitObjectException

La waitHandles matriz contiene elementos duplicados.

NotSupportedException

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

O bien

El subproceso actual está en STA estado 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.

ArgumentOutOfRangeException

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

AbandonedMutexException

La espera se completó porque un subproceso salió sin liberar una exclusión mutua.

InvalidOperationException

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

Ejemplos

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

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            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(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        If WaitHandle.WaitAll(manualEvents, 5000, false) = True  Then

            Console.WriteLine("Files written - main exiting.")
        Else
        
            ' The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.")
        End If
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Comentarios

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

El WaitAll método devuelve cuando finaliza la espera, lo que significa cuando se señalizan todos los identificadores o cuando se produce el tiempo de espera. Si se pasan más de 64 identificadores, se produce una NotSupportedException excepción . Si hay duplicados en la matriz, se produce un error en la llamada con .DuplicateWaitObjectException

Nota:

El WaitAll método no se admite en subprocesos en STA estado.

Salir del contexto

Se aplica a

WaitAll(WaitHandle[], TimeSpan)

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un TimeSpan valor para especificar el intervalo de tiempo.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout);

public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, TimeSpan timeout);

static member WaitAll : System.Threading.WaitHandle[] * TimeSpan -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), timeout As TimeSpan) As Boolean

Parámetros

waitHandles: WaitHandle[]

Matriz WaitHandle que contiene los objetos para los que esperará la instancia actual. Esta matriz no puede contener varias referencias al mismo objeto.

timeout: TimeSpan

TimeSpan que representa el número de milisegundos que se van a esperar, o que TimeSpan representa -1 milisegundos, para esperar indefinidamente.

Devoluciones

Boolean

true cuando cada elemento de waitHandles ha recibido una señal; de lo contrario, falsees .

Excepciones

ArgumentNullException

El waitHandles parámetro es null.

O bien

Uno o varios de los objetos de la waitHandles matriz son null.

O bien

waitHandles es una matriz sin elementos.

DuplicateWaitObjectException

La waitHandles matriz contiene elementos duplicados.

NotSupportedException

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

O bien

El subproceso actual está en STA estado y waitHandles contiene más de un elemento.

ArgumentOutOfRangeException

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

O bien

timeout es mayor que Int32.MaxValue.

AbandonedMutexException

La espera finalizó porque un subproceso salió sin liberar una exclusión mutua.

InvalidOperationException

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

Comentarios

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

Nota:

El WaitAll método no se admite en subprocesos en STA estado.

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

Llamar a esta sobrecarga de método es la misma que llamar a la WaitAll(WaitHandle[], TimeSpan, Boolean) sobrecarga y especificar false para exitContext.

Se aplica a

WaitAll(WaitHandle[], Int32)

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Espera a que todos los elementos de la matriz especificada reciban una señal, utilizando un Int32 valor para especificar el intervalo de tiempo.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout);

public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout);

static member WaitAll : System.Threading.WaitHandle[] * int -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), millisecondsTimeout As Integer) As Boolean

Parámetros

waitHandles: WaitHandle[]

Matriz WaitHandle que contiene los objetos para los que esperará la instancia actual. Esta matriz no puede contener varias referencias al mismo objeto (duplicados).

millisecondsTimeout: Int32

Número de milisegundos que se van a esperar o Infinite (-1) para esperar indefinidamente.

Devoluciones

Boolean

true cuando cada elemento de waitHandles ha recibido una señal; de lo contrario, falsees .

Excepciones

ArgumentNullException

El waitHandles parámetro es null.

O bien

Uno o varios de los objetos de la waitHandles matriz son null.

O bien

waitHandles es una matriz sin elementos.

DuplicateWaitObjectException

La waitHandles matriz contiene elementos duplicados.

NotSupportedException

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

O bien

El subproceso actual está en STA estado y waitHandles contiene más de un elemento.

ArgumentOutOfRangeException

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

AbandonedMutexException

La espera se completó porque un subproceso salió sin liberar una exclusión mutua.

InvalidOperationException

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

Comentarios

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

Nota:

El WaitAll método no se admite en subprocesos en STA estado.

Llamar a esta sobrecarga de método es la misma que llamar a la WaitAll(WaitHandle[], Int32, Boolean) sobrecarga y especificar false para exitContext.

Se aplica a

WaitAll(WaitHandle[])

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

Source:: WaitHandle.cs

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

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles);

public static bool WaitAll(System.Threading.WaitHandle[] waitHandles);

static member WaitAll : System.Threading.WaitHandle[] -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle()) As Boolean

Parámetros

waitHandles: WaitHandle[]

Matriz WaitHandle que contiene los objetos para los que esperará la instancia actual. Esta matriz no puede contener varias referencias al mismo objeto.

Devoluciones

Boolean

true cuando cada elemento de waitHandles ha recibido una señal; de lo contrario, el método nunca devuelve.

Excepciones

ArgumentNullException

El waitHandles parámetro es null. O bien

Uno o varios de los objetos de la waitHandles matriz son null.

O bien

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

DuplicateWaitObjectException

La waitHandles matriz contiene elementos duplicados.

NotSupportedException

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

O bien

El subproceso actual está en STA estado 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 salió sin liberar una exclusión mutua.

InvalidOperationException

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

Ejemplos

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

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            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(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        WaitHandle.WaitAll(manualEvents)
        Console.WriteLine("Files written - main exiting.")
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Comentarios

AbandonedMutexException es nuevo en la versión 2.0 de .NET Framework. En versiones anteriores, el WaitAll método 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 una exclusión mutua en todo el sistema, podría indicar que una aplicación se ha terminado abruptamente (por ejemplo, mediante el Administrador de tareas de Windows). La excepción contiene información útil para la depuración.

El WaitAll método devuelve cuando se indican todos los identificadores. Si se pasan más de 64 identificadores, se produce una NotSupportedException excepción . Si la matriz contiene duplicados, se produce un DuplicateWaitObjectExceptionerror en la llamada a .

Nota:

El WaitAll método no se admite en subprocesos en STA estado.

Llamar a esta sobrecarga de método es equivalente a llamar a la sobrecarga del WaitAll(WaitHandle[], Int32, Boolean) método y especificar -1 (o Timeout.Infinite) para millisecondsTimeout y true para exitContext.

Se aplica a

Comentarios

¿Le ha resultado útil esta página?

Compartir a través de

WaitHandle.WaitAll Método

Definición

Sobrecargas

WaitAll(WaitHandle[], TimeSpan, Boolean)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Salir del contexto

Se aplica a

WaitAll(WaitHandle[], Int32, Boolean)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Salir del contexto

Se aplica a

WaitAll(WaitHandle[], TimeSpan)

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

WaitAll(WaitHandle[], Int32)

Parámetros

Devoluciones

Excepciones

Comentarios

Se aplica a

WaitAll(WaitHandle[])

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Se aplica a

Comentarios