WaitHandle.WaitAll Metódus

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

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

Paraméterek

Válaszok

true ha minden elem waitHandles kapott egy jelet; ellenkező esetben false.

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet a szálkészletet aszinkron módon létrehozni és fájlcsoportba írni. Minden írási művelet munkaelemként van várólistára állítva, és jelzi, ha befejeződött. A fő szál megvárja, amíg az összes elem jelez, majd kilép.

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

Megjegyzések

Ha timeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópontok állapotát, és azonnal visszatér.

Ha egy mutex elhagyatott, egy AbandonedMutexException dobni. Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A WaitAll metódus a várakozás leállásakor ad vissza, ami azt jelenti, hogy a rendszer az összes fogópontot jelzi, vagy időtúllépés történik. Ha 64-nél több fogópontot adnak át, NotSupportedException a ki lesz dobva. Ha a tömb duplikált elemeket tartalmaz, a hívás sikertelen lesz.

A maximális érték az timeout .Int32.MaxValue

Kilépés a környezetből

A exitContext paraméternek nincs hatása, hacsak ezt a metódust nem egy nem megbízható felügyelt környezetből hívja meg. A felügyelt környezet nem lehet hibás, ha a szál egy, a forrásból ContextBoundObjectszármaztatott osztály egy példányának hívásán belül van. Még akkor is, ha egy olyan osztályon hajt végre metódust, amely nem származik ContextBoundObjectpéldául Stringabból, akkor is lehet nem megfelelő környezetben, ha egy ContextBoundObject az aktuális alkalmazástartományban található a veremen.

Ha a kód nem megfelelő környezetben fut, a metódus végrehajtása előtt meg kell adnia trueexitContext , hogy a szál kilép-e a nemdefault felügyelt környezetből (vagyis áttér az alapértelmezett környezetre). A szál a metódus hívásának befejeződése után visszatér az eredeti nem megfelelő környezethez.

A környezetből való kilépés akkor lehet hasznos, ha a környezethez kötött osztály rendelkezik az SynchronizationAttribute attribútummal. Ebben az esetben a rendszer automatikusan szinkronizálja az osztály tagjaihoz intézett összes hívást, és a szinkronizálási tartomány az osztály kódjának teljes törzse. Ha egy tag hívási vermében lévő kód meghívja ezt a metódust, és megadja trueexitContextazt, a szál kilép a szinkronizálási tartományból, ami lehetővé teszi, hogy az objektum bármely tagjára irányuló hívás során blokkolt szál folytassa a műveletet. Amikor ez a metódus visszatér, a hívást kezdeményező szálnak várnia kell a szinkronizálási tartomány újraküldésére.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

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

Paraméterek

Válaszok

trueha minden elem waitHandles kapott egy jelet; ellenkező esetben. false

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet a szálkészletet aszinkron módon létrehozni és fájlcsoportba írni. Minden írási művelet munkaelemként van várólistára állítva, és jelzi, ha befejeződött. A fő szál megvárja, amíg az összes elem jelez, majd kilép.

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

Megjegyzések

Ha millisecondsTimeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópontok állapotát, és azonnal visszatér.

Ha egy mutex elhagyatott, egy AbandonedMutexException dobni. Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A WaitAll metódus a várakozás leállásakor ad vissza, ami azt jelenti, hogy az összes fogópont jelzése vagy időtúllépés esetén történik. Ha 64-nél több fogópontot adnak át, NotSupportedException a ki lesz dobva. Ha a tömbben ismétlődések vannak, a hívás meghiúsul egy DuplicateWaitObjectException.

Kilépés a környezetből

A exitContext paraméternek nincs hatása, hacsak ezt a metódust nem egy nem megbízható felügyelt környezetből hívja meg. A felügyelt környezet nem lehet hibás, ha a szál egy, a forrásból ContextBoundObjectszármaztatott osztály egy példányának hívásán belül van. Még akkor is, ha egy olyan osztályon hajt végre metódust, amely nem származik ContextBoundObjectpéldául Stringabból, akkor is lehet nem megfelelő környezetben, ha egy ContextBoundObject az aktuális alkalmazástartományban található a veremen.

Ha a kód nem megfelelő környezetben fut, a metódus végrehajtása előtt meg kell adnia trueexitContext , hogy a szál kilép-e a nemdefault felügyelt környezetből (vagyis áttér az alapértelmezett környezetre). A szál a metódus hívásának befejeződése után visszatér az eredeti nem megfelelő környezethez.

A környezetből való kilépés akkor lehet hasznos, ha a környezethez kötött osztály rendelkezik az SynchronizationAttribute attribútummal. Ebben az esetben a rendszer automatikusan szinkronizálja az osztály tagjaihoz intézett összes hívást, és a szinkronizálási tartomány az osztály kódjának teljes törzse. Ha egy tag hívási vermében lévő kód meghívja ezt a metódust, és megadja trueexitContextazt, a szál kilép a szinkronizálási tartományból, ami lehetővé teszi, hogy az objektum bármely tagjára irányuló hívás során blokkolt szál folytassa a műveletet. Amikor ez a metódus visszatér, a hívást kezdeményező szálnak várnia kell a szinkronizálási tartomány újraküldésére.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

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

Paraméterek

Válaszok

trueha minden elem waitHandles kapott egy jelet; ellenkező esetben. false

Kivételek

Megjegyzések

Ha timeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópontok állapotát, és azonnal visszatér.

A WaitAll metódus a várakozás leállásakor ad vissza, ami azt jelenti, hogy a rendszer az összes fogópontot jelzi, vagy időtúllépés történik. Ha 64-nél több fogópontot adnak át, NotSupportedException a ki lesz dobva. Ha a tömb duplikált elemeket tartalmaz, a hívás sikertelen lesz.

A maximális érték az timeout .Int32.MaxValue

A metódus túlterhelésének meghívása ugyanaz, mint a WaitAll(WaitHandle[], TimeSpan, Boolean) túlterhelés meghívása falseexitContext és a túlterhelés megadása.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

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

Paraméterek

Válaszok

trueha minden elem waitHandles kapott egy jelet; ellenkező esetben. false

Kivételek

Megjegyzések

Ha millisecondsTimeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópontok állapotát, és azonnal visszatér.

A WaitAll metódus a várakozás leállásakor ad vissza, ami azt jelenti, hogy az összes fogópont jelzése vagy időtúllépés esetén történik. Ha 64-nél több fogópontot adnak át, NotSupportedException a ki lesz dobva. Ha a tömbben ismétlődések vannak, a hívás meghiúsul egy DuplicateWaitObjectException.

A metódus túlterhelésének meghívása ugyanaz, mint a WaitAll(WaitHandle[], Int32, Boolean) túlterhelés meghívása falseexitContext és a túlterhelés megadása.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

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

Paraméterek

Válaszok

true ha minden elem waitHandles kapott egy jelet; ellenkező esetben a metódus soha nem tér vissza.

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet a szálkészletet aszinkron módon létrehozni és fájlcsoportba írni. Minden írási művelet munkaelemként van várólistára állítva, és jelzi, ha befejeződött. A fő szál megvárja, amíg az összes elem jelez, majd kilép.

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

Megjegyzések

AbandonedMutexException a .NET Framework 2.0-s verziójában új. A korábbi verziókban a WaitAll metódus a mutex elhagyásakor ad vissza true . Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A WaitAll metódus az összes fogópont jelzése után tér vissza. Ha 64-nél több fogópontot adnak át, NotSupportedException a ki lesz dobva. Ha a tömb duplikált elemeket tartalmaz, a hívás meghiúsul egy DuplicateWaitObjectException.

A metódus túlterhelésének meghívása egyenértékű a metódus túlterhelésének meghívásával, valamint a WaitAll(WaitHandle[], Int32, Boolean) -1 (vagy Timeout.Infinite) millisecondsTimeouttrueexitContextmegadásával.