WaitHandle.WaitAll Methode

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

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

Parameters

Retouren

true wanneer elk element in waitHandles een signaal is ontvangen; anders false.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de threadgroep gebruikt om asynchroon een groep bestanden te maken en te schrijven. Elke schrijfbewerking wordt in de wachtrij geplaatst als een werkitem en signalen wanneer het is voltooid. De hoofdthread wacht tot alle items worden gesignaleert en vervolgens wordt afgesloten.

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

Opmerkingen

Als timeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgrepen getest en onmiddellijk geretourneerd.

Als een mutex wordt verlaten, wordt er een AbandonedMutexException gegooid. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De WaitAll methode retourneert wanneer de wacht wordt beëindigd, wat betekent dat alle ingangen worden gesignaleerd of dat er een time-out optreedt. Als er meer dan 64 ingangen worden doorgegeven, wordt er een NotSupportedException gegenereerd. Als de matrix duplicaten bevat, mislukt de aanroep.

De maximumwaarde voor timeout is Int32.MaxValue.

De context afsluiten

De exitContext parameter heeft geen effect, tenzij deze methode wordt aangeroepen vanuit een niet-standaard beheerde context. De beheerde context kan niet-standaard zijn als uw thread zich in een aanroep bevindt naar een exemplaar van een klasse die is afgeleid van ContextBoundObject. Zelfs als u momenteel een methode uitvoert op een klasse die niet is afgeleid van ContextBoundObject, zoals String, kunt u zich in een niet-standaardcontext bevinden als een ContextBoundObject is op uw stack in het huidige toepassingsdomein.

Wanneer uw code wordt uitgevoerd in een niet-standaardcontext, geeft trueexitContext u aan dat de thread de niet-standaard beheerde context verlaat (dat wil gezegd, om over te stappen op de standaardcontext) voordat deze methode wordt uitgevoerd. De thread keert terug naar de oorspronkelijke niet-standaardcontext nadat de aanroep van deze methode is voltooid.

Het afsluiten van de context kan handig zijn wanneer de contextgebonden klasse het SynchronizationAttribute kenmerk heeft. In dat geval worden alle aanroepen naar leden van de klasse automatisch gesynchroniseerd en is het synchronisatiedomein de volledige hoofdtekst van de code voor de klasse. Als code in de aanroepstack van een lid deze methode aanroept en opgeeft trueexitContext, sluit de thread het synchronisatiedomein af, waardoor een thread die wordt geblokkeerd voor een aanroep naar een lid van het object, wordt voortgezet. Wanneer deze methode wordt geretourneerd, moet de thread die de aanroep heeft gedaan wachten om het synchronisatiedomein opnieuw in te voeren.

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

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

Parameters

Retouren

truewanneer elk element in waitHandles een signaal is ontvangen; anders. false

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de threadgroep gebruikt om asynchroon een groep bestanden te maken en te schrijven. Elke schrijfbewerking wordt in de wachtrij geplaatst als een werkitem en signalen wanneer het is voltooid. De hoofdthread wacht tot alle items worden gesignaleert en vervolgens wordt afgesloten.

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

Opmerkingen

Als millisecondsTimeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgrepen getest en onmiddellijk geretourneerd.

Als een mutex wordt verlaten, wordt er een AbandonedMutexException gegooid. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De WaitAll methode retourneert wanneer de wachttijd wordt beëindigd, wat betekent dat alle ingangen worden gesignaleerd of wanneer er een time-out optreedt. Als er meer dan 64 ingangen worden doorgegeven, wordt er een NotSupportedException gegenereerd. Als de matrix dubbele waarden bevat, mislukt de aanroep met een DuplicateWaitObjectException.

De context afsluiten

De exitContext parameter heeft geen effect, tenzij deze methode wordt aangeroepen vanuit een niet-standaard beheerde context. De beheerde context kan niet-standaard zijn als uw thread zich in een aanroep bevindt naar een exemplaar van een klasse die is afgeleid van ContextBoundObject. Zelfs als u momenteel een methode uitvoert op een klasse die niet is afgeleid van ContextBoundObject, zoals String, kunt u zich in een niet-standaardcontext bevinden als een ContextBoundObject is op uw stack in het huidige toepassingsdomein.

Wanneer uw code wordt uitgevoerd in een niet-standaardcontext, geeft trueexitContext u aan dat de thread de niet-standaard beheerde context verlaat (dat wil gezegd, om over te stappen op de standaardcontext) voordat deze methode wordt uitgevoerd. De thread keert terug naar de oorspronkelijke niet-standaardcontext nadat de aanroep van deze methode is voltooid.

Het afsluiten van de context kan handig zijn wanneer de contextgebonden klasse het SynchronizationAttribute kenmerk heeft. In dat geval worden alle aanroepen naar leden van de klasse automatisch gesynchroniseerd en is het synchronisatiedomein de volledige hoofdtekst van de code voor de klasse. Als code in de aanroepstack van een lid deze methode aanroept en opgeeft trueexitContext, sluit de thread het synchronisatiedomein af, waardoor een thread die wordt geblokkeerd voor een aanroep naar een lid van het object, wordt voortgezet. Wanneer deze methode wordt geretourneerd, moet de thread die de aanroep heeft gedaan wachten om het synchronisatiedomein opnieuw in te voeren.

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

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

Parameters

Retouren

truewanneer elk element in waitHandles een signaal is ontvangen; anders. false

Uitzonderingen

Opmerkingen

Als timeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgrepen getest en onmiddellijk geretourneerd.

De WaitAll methode retourneert wanneer de wacht wordt beëindigd, wat betekent dat alle ingangen worden gesignaleerd of dat er een time-out optreedt. Als er meer dan 64 ingangen worden doorgegeven, wordt er een NotSupportedException gegenereerd. Als de matrix duplicaten bevat, mislukt de aanroep.

De maximumwaarde voor timeout is Int32.MaxValue.

Het aanroepen van deze methode-overbelasting is hetzelfde als het aanroepen van de WaitAll(WaitHandle[], TimeSpan, Boolean) overbelasting en het opgeven voor falseexitContext.

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

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

Parameters

Retouren

truewanneer elk element in waitHandles een signaal is ontvangen; anders. false

Uitzonderingen

Opmerkingen

Als millisecondsTimeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgrepen getest en onmiddellijk geretourneerd.

De WaitAll methode retourneert wanneer de wachttijd wordt beëindigd, wat betekent dat alle ingangen worden gesignaleerd of wanneer er een time-out optreedt. Als er meer dan 64 ingangen worden doorgegeven, wordt er een NotSupportedException gegenereerd. Als de matrix dubbele waarden bevat, mislukt de aanroep met een DuplicateWaitObjectException.

Het aanroepen van deze methode-overbelasting is hetzelfde als het aanroepen van de WaitAll(WaitHandle[], Int32, Boolean) overbelasting en het opgeven voor falseexitContext.

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

WaitHandle.cs

Bron:

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

Parameters

Retouren

true wanneer elk element in waitHandles een signaal is ontvangen; anders retourneert de methode nooit.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de threadgroep gebruikt om asynchroon een groep bestanden te maken en te schrijven. Elke schrijfbewerking wordt in de wachtrij geplaatst als een werkitem en signalen wanneer het is voltooid. De hoofdthread wacht tot alle items worden gesignaleert en vervolgens wordt afgesloten.

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

Opmerkingen

AbandonedMutexException is nieuw in de .NET Framework-versie 2.0. In eerdere versies wordt de WaitAll methode geretourneerd true wanneer een mutex wordt verlaten. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De WaitAll methode retourneert wanneer alle ingangen worden gesignaleerd. Als er meer dan 64 ingangen worden doorgegeven, wordt er een NotSupportedException gegenereerd. Als de matrix duplicaten bevat, mislukt de aanroep met een DuplicateWaitObjectException.

Het aanroepen van deze methode-overbelasting is gelijk aan het aanroepen van de WaitAll(WaitHandle[], Int32, Boolean) methode-overbelasting en het opgeven van -1 (of Timeout.Infinite) voor millisecondsTimeout en true voor exitContext.