WaitHandle.WaitAll Methode

Definition

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen.Waits for all the elements in the specified array to receive a signal.

Überlädt

WaitAll(WaitHandle[], TimeSpan, Boolean)

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen, wobei ein TimeSpan-Wert zum Angeben des Zeitintervalls verwendet wird, und gibt an, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], Int32, Boolean)

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen, wobei ein Int32-Wert zum Angeben des Zeitintervalls verwendet wird, und gibt an, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan)

Wartet auf den Empfang eines Signals für alle Elemente im angegebenen Array und gibt das Zeitintervall mit einem TimeSpan-Wert an.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], Int32)

Wartet auf den Empfang eines Signals für alle Elemente im angegebenen Array und gibt das Zeitintervall mit einem Int32-Wert an.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[])

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen, wobei ein TimeSpan-Wert zum Angeben des Zeitintervalls verwendet wird, und gibt an, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

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

Parameter

waitHandles
WaitHandle[]

Ein WaitHandle-Array mit den Objekten, auf die die aktuelle Instanz wartet.A WaitHandle array containing the objects for which the current instance will wait. Dieses Array kann nicht mehrere Verweise auf dasselbe Objekt enthalten.This array cannot contain multiple references to the same object.

timeout
TimeSpan

Eine TimeSpan-Struktur, die die Anzahl der zu Millisekunden für die Wartezeit angibt, oder eine TimeSpan-Struktur, die -1 Millisekunden angibt, also eine unbeschränkte Wartezeit.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.

exitContext
Boolean

true, um die Synchronisierungsdomäne für den Kontext vor dem Wartevorgang (sofern in einem synchronisierten Kontext) zu verlassen und diese anschließend erneut abzurufen, andernfalls false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Gibt zurück

true, wenn jedes Element in waitHandles ein Signal empfangen hat, andernfalls false.true when every element in waitHandles has received a signal; otherwise false.

Ausnahmen

Der waitHandles-Parameter ist null.The waitHandles parameter is null.

- oder --or- Mindestens ein Objekt im waitHandles-Array ist null.One or more of the objects in the waitHandles array is null.

- oder --or- waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 2.0 oder höher.waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

Das waitHandles-Array enthält doppelte Elemente.The waitHandles array contains elements that are duplicates.

Die Anzahl von Objekten in waitHandles ist größer, als das System erlaubt.The number of objects in waitHandles is greater than the system permits.

- oder --or- Das STAThreadAttribute-Attribut wird für den aktuellen Thread auf die Threadprozedur angewendet, und waitHandles enthält mehrere Elemente.The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 1.0 oder 1.1.waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - oder --or- timeout ist größer als MaxValue.timeout is greater than MaxValue.

Der Wartevorgang wird beendet, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait terminated because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Das waitHandles-Array enthält einen transparenten Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie der Thread Pool verwendet wird, um asynchron eine Gruppe von Dateien zu erstellen und in diese zu schreiben.The following code example shows how to use the thread pool to asynchronously create and write to a group of files. Jeder Schreibvorgang wird als Arbeits Element in die Warteschlange eingereiht und signalisiert, wann er abgeschlossen ist.Each write operation is queued as a work item and signals when it is finished. Der Haupt Thread wartet darauf, dass alle Elemente signalisiert und dann beendet werden.The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

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


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

int main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<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 = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &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( "Files written - main exiting." );
   }
   else
   {
      
      // The wait operation times out.
      Console::WriteLine( "Error writing files - main exiting." );
   }
}

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

Hinweise

Wenn timeout 0 (null) ist, wird die-Methode nicht blockiert.If timeout is zero, the method does not block. Es testet den Zustand der Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handles and returns immediately.

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitAll-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitAll method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Die WaitAll-Methode gibt zurück, wenn der Warte Vorgang beendet wird, was bedeutet, dass entweder alle Handles signalisiert werden oder ein Timeout auftritt.The WaitAll method returns when the wait terminates, which means either all the handles are signaled or a time-out occurs. Bei einigen Implementierungen wird eine NotSupportedException ausgelöst, wenn mehr als 64 Handles überschritten werden.On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. Wenn das Array Duplikate enthält, schlägt der-Befehl fehl.If the array contains duplicates, the call will fail.

Hinweis

Die WaitAll-Methode wird in Threads, die STAThreadAttribute aufweisen, nicht unterstützt.The WaitAll method is not supported on threads that have STAThreadAttribute.

Der Höchstwert für timeout ist Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Hinweise zum Beenden des KontextsNotes on Exiting the Context

Der exitContext-Parameter hat keine Auswirkung, es sei denn, die WaitAll-Methode wird von einem nicht standardmäßigen verwalteten Kontext aus aufgerufen.The exitContext parameter has no effect unless the WaitAll method is called from inside a nondefault managed context. Dies kann vorkommen, wenn sich der Thread innerhalb eines Aufrufes einer Instanz einer Klasse befindet, die von ContextBoundObject abgeleitet ist.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject abgeleitet ist, z. b. String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in der aktuellen Anwendungsdomäne auf dem Stapel befindet.Even if you are currently executing a method on a class that is not derived from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe von true für exitContext, dass der Thread den nicht standardmäßigen verwalteten Kontext (d. h. den Übergang zum Standardkontext) beendet, bevor die WaitAll-Methode ausgeführt wird.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAll method. Sie kehrt in den ursprünglichen nicht standardmäßigen Kontext zurück, nachdem der aufzurufende WaitAll-Methode abgeschlossen wurde.It returns to the original nondefault context after the call to the WaitAll method completes.

Dies kann nützlich sein, wenn die Kontext gebundene Klasse SynchronizationAttribute hat.This can be useful when the context-bound class has SynchronizationAttribute. In diesem Fall werden alle Aufrufe an Member der-Klasse automatisch synchronisiert, und die Synchronisierungs Domäne ist der gesamte Code Körper für die-Klasse.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Wenn Code in der Aufruf Stapel eines Members die WaitAll-Methode aufruft und true für exitContext angibt, beendet der Thread die Synchronisierungs Domäne, sodass ein Thread, der bei einem Aufruf von einem beliebigen Member des Objekts blockiert ist, fortgesetzt werden kann.If code in the call stack of a member calls the WaitAll method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Wenn die WaitAll-Methode zurückgibt, muss der Thread, der den-Befehl erstellt hat, warten, bis die Synchronisierungs Domäne erneut eingegeben wird.When the WaitAll method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAll(WaitHandle[], Int32, Boolean)

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen, wobei ein Int32-Wert zum Angeben des Zeitintervalls verwendet wird, und gibt an, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

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

Parameter

waitHandles
WaitHandle[]

Ein WaitHandle-Array mit den Objekten, auf die die aktuelle Instanz wartet.A WaitHandle array containing the objects for which the current instance will wait. Dieses Array kann nicht mehrere Verweise auf dasselbe Objekt (Duplikate) enthalten.This array cannot contain multiple references to the same object (duplicates).

millisecondsTimeout
Int32

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean

true, um die Synchronisierungsdomäne für den Kontext vor dem Wartevorgang (sofern in einem synchronisierten Kontext) zu verlassen und diese anschließend erneut abzurufen, andernfalls false.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Gibt zurück

true, wenn jedes Element in waitHandles ein Signal empfangen hat, andernfalls false.true when every element in waitHandles has received a signal; otherwise, false.

Ausnahmen

Der waitHandles-Parameter ist null.The waitHandles parameter is null.

- oder --or- Mindestens ein Objekt im waitHandles-Array ist null.One or more of the objects in the waitHandles array is null.

- oder --or- waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 2.0 oder höher.waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

Das waitHandles-Array enthält doppelte Elemente.The waitHandles array contains elements that are duplicates.

Die Anzahl von Objekten in waitHandles ist größer, als das System erlaubt.The number of objects in waitHandles is greater than the system permits.

- oder --or- Das STAThreadAttribute-Attribut wird für den aktuellen Thread auf die Threadprozedur angewendet, und waitHandles enthält mehrere Elemente.The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 1.0 oder 1.1.waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Das waitHandles-Array enthält einen transparenten Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie der Thread Pool verwendet wird, um asynchron eine Gruppe von Dateien zu erstellen und in diese zu schreiben.The following code example shows how to use the thread pool to asynchronously create and write to a group of files. Jeder Schreibvorgang wird als Arbeits Element in die Warteschlange eingereiht und signalisiert, wann er abgeschlossen ist.Each write operation is queued as a work item and signals when it is finished. Der Haupt Thread wartet darauf, dass alle Elemente signalisiert und dann beendet werden.The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

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


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

int main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<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 = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew 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." );
   }
}

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

Hinweise

Wenn millisecondsTimeout 0 (null) ist, wird die-Methode nicht blockiert.If millisecondsTimeout is zero, the method does not block. Es testet den Zustand der Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handles and returns immediately.

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitAll-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitAll method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Die WaitAll-Methode gibt zurück, wenn der Warte Vorgang beendet wird, was bedeutet, dass entweder alle Handles signalisiert werden oder ein Timeout auftritt.The WaitAll method returns when the wait terminates, which means either when all the handles are signaled or when time-out occurs. Bei einigen Implementierungen wird eine NotSupportedException ausgelöst, wenn mehr als 64 Handles überschritten werden.On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. Wenn Duplikate im Array vorhanden sind, schlägt der-Befehl mit einem DuplicateWaitObjectException fehl.If there are duplicates in the array, the call fails with a DuplicateWaitObjectException.

Hinweis

Die WaitAll-Methode wird in Threads, die STAThreadAttribute aufweisen, nicht unterstützt.The WaitAll method is not supported on threads that have STAThreadAttribute.

Hinweise zum Beenden des KontextsNotes on Exiting the Context

Der exitContext-Parameter hat keine Auswirkung, es sei denn, die WaitAll-Methode wird von einem nicht standardmäßigen verwalteten Kontext aus aufgerufen.The exitContext parameter has no effect unless the WaitAll method is called from inside a nondefault managed context. Dies kann vorkommen, wenn sich der Thread innerhalb eines Aufrufes einer Instanz einer Klasse befindet, die von ContextBoundObject abgeleitet ist.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject abgeleitet ist, z. b. String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in der aktuellen Anwendungsdomäne auf dem Stapel befindet.Even if you are currently executing a method on a class that is not derived from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe von true für exitContext, dass der Thread den nicht standardmäßigen verwalteten Kontext (d. h. den Übergang zum Standardkontext) beendet, bevor die WaitAll-Methode ausgeführt wird.When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAll method. Der Thread kehrt in den ursprünglichen nicht standardmäßigen Kontext zurück, nachdem der aufzurufende WaitAll-Methode abgeschlossen wurde.The thread returns to the original nondefault context after the call to the WaitAll method completes.

Dies kann hilfreich sein, wenn die Kontext gebundene Klasse das SynchronizationAttribute-Attribut aufweist.This can be useful when the context-bound class has the SynchronizationAttribute attribute. In diesem Fall werden alle Aufrufe an Member der-Klasse automatisch synchronisiert, und die Synchronisierungs Domäne ist der gesamte Code Körper für die-Klasse.In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. Wenn Code in der Aufruf Stapel eines Members die WaitAll-Methode aufruft und true für exitContext angibt, beendet der Thread die Synchronisierungs Domäne, sodass ein Thread, der bei einem Aufruf von einem beliebigen Member des Objekts blockiert ist, fortgesetzt werden kann.If code in the call stack of a member calls the WaitAll method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. Wenn die WaitAll-Methode zurückgibt, muss der Thread, der den-Befehl erstellt hat, warten, bis die Synchronisierungs Domäne erneut eingegeben wird.When the WaitAll method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAll(WaitHandle[], TimeSpan)

Wartet auf den Empfang eines Signals für alle Elemente im angegebenen Array und gibt das Zeitintervall mit einem TimeSpan-Wert an.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

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

Parameter

waitHandles
WaitHandle[]

Ein WaitHandle-Array mit den Objekten, auf die die aktuelle Instanz wartet.A WaitHandle array containing the objects for which the current instance will wait. Dieses Array kann nicht mehrere Verweise auf dasselbe Objekt enthalten.This array cannot contain multiple references to the same object.

timeout
TimeSpan

Eine TimeSpan-Struktur, die die Anzahl der zu Millisekunden für die Wartezeit angibt, oder eine TimeSpan-Struktur, die -1 Millisekunden angibt, also eine unbeschränkte Wartezeit.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.

Gibt zurück

true, wenn jedes Element in waitHandles ein Signal empfangen hat, andernfalls false.true when every element in waitHandles has received a signal; otherwise, false.

Ausnahmen

Der waitHandles-Parameter ist null.The waitHandles parameter is null.

- oder --or- Mindestens ein Objekt im waitHandles-Array ist null.One or more of the objects in the waitHandles array is null.

- oder --or- waitHandles ist ein Array ohne Elemente.waitHandles is an array with no elements.

Fangen Sie in .NET für Windows Store-Apps oder der portablen Klassenbibliothek stattdessen die Basisklassenausnahme ArgumentException ab.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

Das waitHandles-Array enthält doppelte Elemente.The waitHandles array contains elements that are duplicates.

Die Anzahl von Objekten in waitHandles ist größer, als das System erlaubt.The number of objects in waitHandles is greater than the system permits.

- oder --or- Das STAThreadAttribute-Attribut wird für den aktuellen Thread auf die Threadprozedur angewendet, und waitHandles enthält mehr als ein Element.The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - oder --or- timeout ist größer als MaxValue.timeout is greater than MaxValue.

Der Wartevorgang wird beendet, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait terminated because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Das waitHandles-Array enthält einen transparenten Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Hinweise

Wenn timeout 0 (null) ist, wird die-Methode nicht blockiert.If timeout is zero, the method does not block. Es testet den Zustand der Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handles and returns immediately.

Die WaitAll-Methode gibt zurück, wenn der Warte Vorgang beendet wird, was bedeutet, dass entweder alle Handles signalisiert werden oder ein Timeout auftritt.The WaitAll method returns when the wait terminates, which means either all the handles are signaled or a time-out occurs. Bei einigen Implementierungen wird eine NotSupportedException ausgelöst, wenn mehr als 64 Handles überschritten werden.On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. Wenn das Array Duplikate enthält, schlägt der-Befehl fehl.If the array contains duplicates, the call will fail.

Hinweis

Die WaitAll-Methode wird in Threads, die STAThreadAttribute aufweisen, nicht unterstützt.The WaitAll method is not supported on threads that have STAThreadAttribute.

Der Höchstwert für timeout ist Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der Überladung WaitAll(WaitHandle[], TimeSpan, Boolean) und der Angabe von false für exitContext.Calling this method overload is the same as calling the WaitAll(WaitHandle[], TimeSpan, Boolean) overload and specifying false for exitContext.

WaitAll(WaitHandle[], Int32)

Wartet auf den Empfang eines Signals für alle Elemente im angegebenen Array und gibt das Zeitintervall mit einem Int32-Wert an.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

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

Parameter

waitHandles
WaitHandle[]

Ein WaitHandle-Array mit den Objekten, auf die die aktuelle Instanz wartet.A WaitHandle array containing the objects for which the current instance will wait. Dieses Array kann nicht mehrere Verweise auf dasselbe Objekt (Duplikate) enthalten.This array cannot contain multiple references to the same object (duplicates).

millisecondsTimeout
Int32

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Gibt zurück

true, wenn jedes Element in waitHandles ein Signal empfangen hat, andernfalls false.true when every element in waitHandles has received a signal; otherwise, false.

Ausnahmen

Der waitHandles-Parameter ist null.The waitHandles parameter is null.

- oder --or- Mindestens ein Objekt im waitHandles-Array ist null.One or more of the objects in the waitHandles array is null.

- oder --or- waitHandles ist ein Array ohne Elemente.waitHandles is an array with no elements.

Fangen Sie in .NET für Windows Store-Apps oder der portablen Klassenbibliothek stattdessen die Basisklassenausnahme ArgumentException ab.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

Das waitHandles-Array enthält doppelte Elemente.The waitHandles array contains elements that are duplicates.

Die Anzahl von Objekten in waitHandles ist größer, als das System erlaubt.The number of objects in waitHandles is greater than the system permits.

- oder --or- Das STAThreadAttribute-Attribut wird für den aktuellen Thread auf die Threadprozedur angewendet, und waitHandles enthält mehrere Elemente.The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Das waitHandles-Array enthält einen transparenten Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Hinweise

Wenn millisecondsTimeout 0 (null) ist, wird die-Methode nicht blockiert.If millisecondsTimeout is zero, the method does not block. Es testet den Zustand der Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handles and returns immediately.

Die WaitAll-Methode gibt zurück, wenn der Warte Vorgang beendet wird, was bedeutet, dass entweder alle Handles signalisiert werden oder ein Timeout auftritt.The WaitAll method returns when the wait terminates, which means either when all the handles are signaled or when time-out occurs. Bei einigen Implementierungen wird eine NotSupportedException ausgelöst, wenn mehr als 64 Handles überschritten werden.On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. Wenn Duplikate im Array vorhanden sind, schlägt der-Befehl mit einem DuplicateWaitObjectException fehl.If there are duplicates in the array, the call fails with a DuplicateWaitObjectException.

Hinweis

Die WaitAll-Methode wird in Threads, die STAThreadAttribute aufweisen, nicht unterstützt.The WaitAll method is not supported on threads that have STAThreadAttribute.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der Überladung WaitAll(WaitHandle[], Int32, Boolean) und der Angabe von false für exitContext.Calling this method overload is the same as calling the WaitAll(WaitHandle[], Int32, Boolean) overload and specifying false for exitContext.

WaitAll(WaitHandle[])

Wartet, bis alle Elemente im angegebenen Array ein Signal empfangen.Waits for all the elements in the specified array to receive a signal.

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

Parameter

waitHandles
WaitHandle[]

Ein WaitHandle-Array mit den Objekten, auf die die aktuelle Instanz wartet.A WaitHandle array containing the objects for which the current instance will wait. Dieses Array kann nicht mehrere Verweise auf dasselbe Objekt enthalten.This array cannot contain multiple references to the same object.

Gibt zurück

true, wenn jedes Element in waitHandles ein Signal empfangen hat, andernfalls wird die Methode nicht beendet.true when every element in waitHandles has received a signal; otherwise the method never returns.

Ausnahmen

Der waitHandles-Parameter ist null.The waitHandles parameter is null. - oder --or- Mindestens ein Objekt im waitHandles-Array ist null.One or more of the objects in the waitHandles array are null.

- oder --or- waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 2.0 oder höher.waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

Fangen Sie in .NET für Windows Store-Apps oder der portablen Klassenbibliothek stattdessen die Basisklassenausnahme ArgumentException ab.In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

Das waitHandles-Array enthält doppelte Elemente.The waitHandles array contains elements that are duplicates.

Die Anzahl von Objekten in waitHandles ist größer, als das System erlaubt.The number of objects in waitHandles is greater than the system permits.

- oder --or- Das STAThreadAttribute-Attribut wird für den aktuellen Thread auf die Threadprozedur angewendet, und waitHandles enthält mehrere Elemente.The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles ist ein Array ohne Elemente, und die .NET Framework-Version ist 1.0 oder 1.1.waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

Der Wartevorgang wird beendet, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait terminated because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Das waitHandles-Array enthält einen transparenten Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie der Thread Pool verwendet wird, um asynchron eine Gruppe von Dateien zu erstellen und in diese zu schreiben.The following code example shows how to use the thread pool to asynchronously create and write to a group of files. Jeder Schreibvorgang wird als Arbeits Element in die Warteschlange eingereiht und signalisiert, wann er abgeschlossen ist.Each write operation is queued as a work item and signals when it is finished. Der Haupt Thread wartet darauf, dass alle Elemente signalisiert und dann beendet werden.The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

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


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

void main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<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 = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew 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." );
}

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

Hinweise

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitAll-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitAll method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Die WaitAll-Methode gibt zurück, wenn alle Handles signalisiert werden.The WaitAll method returns when all the handles are signaled. Bei einigen Implementierungen wird eine NotSupportedException ausgelöst, wenn mehr als 64 Handles überschritten werden.On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. Wenn das Array Duplikate enthält, schlägt der-Befehl mit einem DuplicateWaitObjectException fehl.If the array contains duplicates, the call fails with a DuplicateWaitObjectException.

Hinweis

Die WaitAll-Methode wird in Threads, die STAThreadAttribute aufweisen, nicht unterstützt.The WaitAll method is not supported on threads that have STAThreadAttribute.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der WaitAll(WaitHandle[], Int32, Boolean)-Methoden Überladung und der Angabe von-1 (oder Timeout.Infinite) für millisecondsTimeout und true für exitContext.Calling this method overload is equivalent to calling the WaitAll(WaitHandle[], Int32, Boolean) method overload and specifying -1 (or Timeout.Infinite) for millisecondsTimeout and true for exitContext.

Gilt für: