Waits for all the elements in the specified array to receive a signal.
Overload List
Waits for all the elements in the specified array to receive a signal.
[Visual Basic] Overloads Public Shared Function WaitAll(WaitHandle()) As Boolean
[C#] public static bool WaitAll(WaitHandle[]);
[C++] public: static bool WaitAll(WaitHandle*[]);
[JScript] public static function WaitAll(WaitHandle[]) : Boolean;
Waits for all the elements in the specified array to receive a signal, using an Int32 value to measure the time interval and specifying whether to exit the synchronization domain before the wait.
[Visual Basic] Overloads Public Shared Function WaitAll(WaitHandle(), Integer, Boolean) As Boolean
[C#] public static bool WaitAll(WaitHandle[], int, bool);
[C++] public: static bool WaitAll(WaitHandle*[], int, bool);
[JScript] public static function WaitAll(WaitHandle[], int, Boolean) : Boolean;
Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to measure the time interval and specifying whether to exit the synchronization domain before the wait.
[Visual Basic] Overloads Public Shared Function WaitAll(WaitHandle(), TimeSpan, Boolean) As Boolean
[C#] public static bool WaitAll(WaitHandle[], TimeSpan, bool);
[C++] public: static bool WaitAll(WaitHandle*[], TimeSpan, bool);
[JScript] public static function WaitAll(WaitHandle[], TimeSpan, Boolean) : Boolean;
Example
[Visual Basic, C#, C++] 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.
[Visual Basic, C#, C++] Note This example shows how to use one of the overloaded versions of WaitAll. For other examples that might be available, see the individual overload topics.
[Visual Basic]
Imports System
Imports System.IO
Imports System.Security.Permissions
Imports System.Threading
' Request permission to create and write files to C:\TestTest.
<Assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, _
All := "C:\TestTest")>
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
[C#]
using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;
// Request permission to create and write files to C:\TestTest.
[assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum,
All = @"C:\TestTest")]
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();
}
}
}
[C++]
#using <mscorlib.dll>
using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;
// Request permission to create and write files to C:\TestTest.
[assembly: FileIOPermissionAttribute(SecurityAction::RequestMinimum,
All = "C:\\TestTest")];
// Maintain state to pass to WriteToFile.
__gc class State
{
public:
String* fileName;
Byte byteArray __gc [];
ManualResetEvent* manualEvent;
State(String* fileName, Byte byteArray __gc [],
ManualResetEvent* manualEvent) : fileName(fileName),
byteArray(byteArray), manualEvent(manualEvent) {}
};
__gc class Writer
{
static int workItemCount = 0;
Writer() {}
public:
static void WriteToFile(Object* state)
{
int workItemNumber = workItemCount;
Interlocked::Increment(&workItemCount);
Console::WriteLine(S"Starting work item {0}.",
workItemNumber.ToString());
State* stateInfo = dynamic_cast<State*>(state);
FileStream* fileWriter;
// 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 != 0)
{
fileWriter->Close();
}
// Signal main() that the work item has finished.
Console::WriteLine(S"Ending work item {0}.",
workItemNumber.ToString());
stateInfo->manualEvent->Set();
}
}
};
void main()
{
const int numberOfFiles = 5;
String* dirName = "C:\\TestTest";
String* fileName;
Byte byteArray __gc [];
Random* randomGenerator = new Random();
ManualResetEvent* manualEvents __gc [] =
new ManualResetEvent* __gc [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 __gc [1000000];
randomGenerator->NextBytes(byteArray);
manualEvents[i] = new ManualResetEvent(false);
stateInfo = new State(fileName, byteArray, manualEvents[i]);
ThreadPool::QueueUserWorkItem(new WaitCallback(
0, &Writer::WriteToFile), stateInfo);
}
// Since ThreadPool threads are background threads,
// wait for the work items to signal before exiting.
if(WaitHandle::WaitAll(manualEvents, TimeSpan(0, 0, 5), false))
{
Console::WriteLine(S"Files written - main exiting.");
}
else
{
// The wait operation times out.
Console::WriteLine(S"Error writing files - main exiting.");
}
}
[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button .gif)
in the upper-left corner of the page.
See Also
WaitHandle Class | WaitHandle Members | System.Threading Namespace