WaitHandle.WaitAll Methode

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

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

Gibt zurück

true wenn jedes Element in waitHandles ein Signal empfangen hat; andernfalls false.

Ausnahmen

Beispiele

Das folgende Codebeispiel zeigt, wie Sie den Threadpool zum asynchronen Erstellen und Schreiben in eine Gruppe von Dateien verwenden. Jeder Schreibvorgang wird als Arbeitsaufgabe in die Warteschlange gestellt und signalisiert, wann er abgeschlossen ist. Der Hauptthread wartet, bis alle Elemente signalisiert und dann beendet werden.

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 null ist, wird die Methode nicht blockiert. Er testet den Zustand der Wartepunkte und gibt sofort zurück.

Wenn ein Mutex abgebrochen wird, wird ein AbandonedMutexException Geworfen. Ein verlassener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Bei einem systemweiten Mutex kann es darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows-Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen hilfreich sind.

Die WaitAll Methode gibt zurück, wenn die Wartezeit beendet wird, was bedeutet, dass entweder alle Ziehpunkte signalisiert oder ein Timeout auftritt. Wenn mehr als 64 Ziehpunkte übergeben werden, wird ein NotSupportedException Fehler ausgelöst. Wenn das Array Duplikate enthält, schlägt der Aufruf fehl.

Der maximal zulässige Wert timeout ist Int32.MaxValue.

Beenden des Kontexts

Der exitContext Parameter hat keine Auswirkung, es sei denn, diese Methode wird aus einem nicht standardmäßigen verwalteten Kontext aufgerufen. Der verwaltete Kontext kann nicht standardmäßig sein, wenn sich Ihr Thread in einem Aufruf einer Instanz einer von einer Klasse abgeleiteten Klasse befindet ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject, z String. B. abgeleitet ist, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject Stapel in der aktuellen Anwendungsdomäne befindet.

Wenn Der Code in einem nicht standardmäßigen Kontext ausgeführt wird, geben Sie true an exitContext , dass der Thread den nicht standardmäßigen verwalteten Kontext beendet (d. h. zum Übergang zum Standardkontext), bevor diese Methode ausgeführt wird. Der Thread kehrt zum ursprünglichen Nicht-Standardkontext zurück, nachdem der Aufruf dieser Methode abgeschlossen wurde.

Das Beenden des Kontexts kann nützlich sein, wenn die kontextgebundene Klasse über das SynchronizationAttribute Attribut verfügt. In diesem Fall werden alle Aufrufe an Member der Klasse automatisch synchronisiert, und die Synchronisierungsdomäne ist der gesamte Codetext für die Klasse. Wenn Code im Aufrufstapel eines Mitglieds diese Methode aufruft und angibt trueexitContext, beendet der Thread die Synchronisierungsdomäne, wodurch ein Thread, der für einen Aufruf eines Elements des Objekts blockiert wird, beendet wird. Wenn diese Methode zurückgegeben wird, muss der Thread, der den Aufruf ausgeführt hat, warten, um die Synchronisierungsdomäne erneut einzuweisen.

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

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

Gibt zurück

truewenn jedes Element in waitHandles ein Signal empfangen hat; andernfalls . false

Ausnahmen

Beispiele

Das folgende Codebeispiel zeigt, wie Sie den Threadpool zum asynchronen Erstellen und Schreiben in eine Gruppe von Dateien verwenden. Jeder Schreibvorgang wird als Arbeitsaufgabe in die Warteschlange gestellt und signalisiert, wann er abgeschlossen ist. Der Hauptthread wartet, bis alle Elemente signalisiert und dann beendet werden.

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 null ist, wird die Methode nicht blockiert. Er testet den Zustand der Wartepunkte und gibt sofort zurück.

Wenn ein Mutex abgebrochen wird, wird ein AbandonedMutexException Geworfen. Ein verlassener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Bei einem systemweiten Mutex kann es darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows-Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen hilfreich sind.

Die WaitAll Methode gibt zurück, wenn die Wartezeit beendet wird, was bedeutet, dass entweder alle Ziehpunkte signalisiert werden oder wenn Timeout auftritt. Wenn mehr als 64 Ziehpunkte übergeben werden, wird ein NotSupportedException Fehler ausgelöst. Wenn im Array Duplikate vorhanden sind, schlägt der Aufruf mit einem DuplicateWaitObjectException.

Beenden des Kontexts

Der exitContext Parameter hat keine Auswirkung, es sei denn, diese Methode wird aus einem nicht standardmäßigen verwalteten Kontext aufgerufen. Der verwaltete Kontext kann nicht standardmäßig sein, wenn sich Ihr Thread in einem Aufruf einer Instanz einer von einer Klasse abgeleiteten Klasse befindet ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject, z String. B. abgeleitet ist, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject Stapel in der aktuellen Anwendungsdomäne befindet.

Wenn Der Code in einem nicht standardmäßigen Kontext ausgeführt wird, geben Sie true an exitContext , dass der Thread den nicht standardmäßigen verwalteten Kontext beendet (d. h. zum Übergang zum Standardkontext), bevor diese Methode ausgeführt wird. Der Thread kehrt zum ursprünglichen Nicht-Standardkontext zurück, nachdem der Aufruf dieser Methode abgeschlossen wurde.

Das Beenden des Kontexts kann nützlich sein, wenn die kontextgebundene Klasse über das SynchronizationAttribute Attribut verfügt. In diesem Fall werden alle Aufrufe an Member der Klasse automatisch synchronisiert, und die Synchronisierungsdomäne ist der gesamte Codetext für die Klasse. Wenn Code im Aufrufstapel eines Mitglieds diese Methode aufruft und angibt trueexitContext, beendet der Thread die Synchronisierungsdomäne, wodurch ein Thread, der für einen Aufruf eines Elements des Objekts blockiert wird, beendet wird. Wenn diese Methode zurückgegeben wird, muss der Thread, der den Aufruf ausgeführt hat, warten, um die Synchronisierungsdomäne erneut einzuweisen.

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

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

Gibt zurück

truewenn jedes Element in waitHandles ein Signal empfangen hat; andernfalls . false

Ausnahmen

Hinweise

Wenn timeout null ist, wird die Methode nicht blockiert. Er testet den Zustand der Wartepunkte und gibt sofort zurück.

Die WaitAll Methode gibt zurück, wenn die Wartezeit beendet wird, was bedeutet, dass entweder alle Ziehpunkte signalisiert oder ein Timeout auftritt. Wenn mehr als 64 Ziehpunkte übergeben werden, wird ein NotSupportedException Fehler ausgelöst. Wenn das Array Duplikate enthält, schlägt der Aufruf fehl.

Der maximal zulässige Wert timeout ist Int32.MaxValue.

Das Aufrufen dieser Methodenüberladung entspricht dem Aufrufen der WaitAll(WaitHandle[], TimeSpan, Boolean) Überladung und der Angabe false für exitContext.

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

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

Gibt zurück

truewenn jedes Element in waitHandles ein Signal empfangen hat; andernfalls . false

Ausnahmen

Hinweise

Wenn millisecondsTimeout null ist, wird die Methode nicht blockiert. Er testet den Zustand der Wartepunkte und gibt sofort zurück.

Die WaitAll Methode gibt zurück, wenn die Wartezeit beendet wird, was bedeutet, dass entweder alle Ziehpunkte signalisiert werden oder wenn Timeout auftritt. Wenn mehr als 64 Ziehpunkte übergeben werden, wird ein NotSupportedException Fehler ausgelöst. Wenn im Array Duplikate vorhanden sind, schlägt der Aufruf mit einem DuplicateWaitObjectException.

Das Aufrufen dieser Methodenüberladung entspricht dem Aufrufen der WaitAll(WaitHandle[], Int32, Boolean) Überladung und der Angabe false für exitContext.

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

Quelle:

WaitHandle.cs

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

Gibt zurück

true wenn jedes Element in waitHandles ein Signal empfangen hat; andernfalls gibt die Methode nie zurück.

Ausnahmen

Beispiele

Das folgende Codebeispiel zeigt, wie Sie den Threadpool zum asynchronen Erstellen und Schreiben in eine Gruppe von Dateien verwenden. Jeder Schreibvorgang wird als Arbeitsaufgabe in die Warteschlange gestellt und signalisiert, wann er abgeschlossen ist. Der Hauptthread wartet, bis alle Elemente signalisiert und dann beendet werden.

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. In früheren Versionen gibt die WaitAll Methode zurück true , wenn ein Mutex abgebrochen wird. Ein verlassener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Bei einem systemweiten Mutex kann es darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows-Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen hilfreich sind.

Die WaitAll Methode gibt zurück, wenn alle Ziehpunkte signalisiert werden. Wenn mehr als 64 Ziehpunkte übergeben werden, wird ein NotSupportedException Fehler ausgelöst. Wenn das Array Duplikate enthält, schlägt der Aufruf mit einem DuplicateWaitObjectException.

Das Aufrufen dieser Methodenüberladung entspricht dem Aufrufen der WaitAll(WaitHandle[], Int32, Boolean) Methodenüberladung und dem Angeben von -1 (oder Timeout.Infinite) für millisecondsTimeout und true für exitContext.