WaitHandle.WaitAll Metod

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

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

Parametrar

Returer

true när varje element i waitHandles har fått en signal, annars false.

Undantag

Exempel

Följande kodexempel visar hur du använder trådpoolen för att asynkront skapa och skriva till en grupp med filer. Varje skrivåtgärd placeras i kö som ett arbetsobjekt och signalerar när den är klar. Huvudtråden väntar på att alla objekt ska signalera och sedan avslutas.

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

Kommentarer

Om timeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtagen och returnerar omedelbart.

Om en mutex överges utlöses en AbandonedMutexException . Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Metoden WaitAll returnerar när väntetiden avslutas, vilket innebär att antingen alla referenser signaleras eller en timeout inträffar. Om fler än 64 handtag skickas utlöses en NotSupportedException . Om matrisen innehåller dubbletter misslyckas anropet.

Det maximala värdet för timeout är Int32.MaxValue.

Avsluta kontexten

Parametern exitContext har ingen effekt om inte den här metoden anropas inifrån en nondefault-hanterad kontext. Den hanterade kontexten kan vara nondefault om tråden finns i ett anrop till en instans av en klass som härletts från ContextBoundObject. Även om du för närvarande kör en metod på en klass som inte härleds från ContextBoundObject, till exempel String, kan du vara i en nondefault-kontext om en ContextBoundObject finns på stacken i den aktuella programdomänen.

När koden körs i en nondefault-kontext anger du true för exitContext att tråden ska avsluta den nondefault-hanterade kontexten (dvs. att övergå till standardkontexten) innan den här metoden körs. Tråden återgår till den ursprungliga nondefault-kontexten när anropet till den här metoden har slutförts.

Det kan vara användbart att avsluta kontexten när den kontextbundna klassen har attributet SynchronizationAttribute . I så fall synkroniseras alla anrop till medlemmar i klassen automatiskt och synkroniseringsdomänen är hela kodtexten för klassen. Om kod i anropsstacken för en medlem anropar true den här metoden och anger för exitContextavslutar tråden synkroniseringsdomänen, vilket gör att en tråd som blockeras vid ett anrop till alla medlemmar i objektet kan fortsätta. När den här metoden returneras måste tråden som gjorde anropet vänta tills synkroniseringsdomänen har återaktiviserats.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

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

Parametrar

Returer

truenär varje element i waitHandles har fått en signal, annars . false

Undantag

Exempel

Följande kodexempel visar hur du använder trådpoolen för att asynkront skapa och skriva till en grupp med filer. Varje skrivåtgärd placeras i kö som ett arbetsobjekt och signalerar när den är klar. Huvudtråden väntar på att alla objekt ska signalera och sedan avslutas.

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

Kommentarer

Om millisecondsTimeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtagen och returnerar omedelbart.

Om en mutex överges utlöses en AbandonedMutexException . Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Metoden WaitAll returnerar när väntetiden avslutas, vilket innebär antingen när alla referenser signaleras eller när tidsgränsen uppnås. Om fler än 64 handtag skickas utlöses en NotSupportedException . Om det finns dubbletter i matrisen misslyckas anropet med en DuplicateWaitObjectException.

Avsluta kontexten

Parametern exitContext har ingen effekt om inte den här metoden anropas inifrån en nondefault-hanterad kontext. Den hanterade kontexten kan vara nondefault om tråden finns i ett anrop till en instans av en klass som härletts från ContextBoundObject. Även om du för närvarande kör en metod på en klass som inte härleds från ContextBoundObject, till exempel String, kan du vara i en nondefault-kontext om en ContextBoundObject finns på stacken i den aktuella programdomänen.

När koden körs i en nondefault-kontext anger du true för exitContext att tråden ska avsluta den nondefault-hanterade kontexten (dvs. att övergå till standardkontexten) innan den här metoden körs. Tråden återgår till den ursprungliga nondefault-kontexten när anropet till den här metoden har slutförts.

Det kan vara användbart att avsluta kontexten när den kontextbundna klassen har attributet SynchronizationAttribute . I så fall synkroniseras alla anrop till medlemmar i klassen automatiskt och synkroniseringsdomänen är hela kodtexten för klassen. Om kod i anropsstacken för en medlem anropar true den här metoden och anger för exitContextavslutar tråden synkroniseringsdomänen, vilket gör att en tråd som blockeras vid ett anrop till alla medlemmar i objektet kan fortsätta. När den här metoden returneras måste tråden som gjorde anropet vänta tills synkroniseringsdomänen har återaktiviserats.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

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

Parametrar

Returer

truenär varje element i waitHandles har fått en signal, annars . false

Undantag

Kommentarer

Om timeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtagen och returnerar omedelbart.

Metoden WaitAll returnerar när väntetiden avslutas, vilket innebär att antingen alla referenser signaleras eller en timeout inträffar. Om fler än 64 handtag skickas utlöses en NotSupportedException . Om matrisen innehåller dubbletter misslyckas anropet.

Det maximala värdet för timeout är Int32.MaxValue.

Att anropa den här metodens överlagring är detsamma som att anropa överlagringen WaitAll(WaitHandle[], TimeSpan, Boolean) och ange false för exitContext.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

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

Parametrar

Returer

truenär varje element i waitHandles har fått en signal, annars . false

Undantag

Kommentarer

Om millisecondsTimeout är noll blockeras inte metoden. Den testar tillståndet för väntehandtagen och returnerar omedelbart.

Metoden WaitAll returnerar när väntetiden avslutas, vilket innebär antingen när alla referenser signaleras eller när tidsgränsen uppnås. Om fler än 64 handtag skickas utlöses en NotSupportedException . Om det finns dubbletter i matrisen misslyckas anropet med en DuplicateWaitObjectException.

Att anropa den här metodens överlagring är detsamma som att anropa överlagringen WaitAll(WaitHandle[], Int32, Boolean) och ange false för exitContext.

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

WaitHandle.cs

Källa:

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

Parametrar

Returer

true när varje element i waitHandles har fått en signal, annars returnerar metoden aldrig.

Undantag

Exempel

Följande kodexempel visar hur du använder trådpoolen för att asynkront skapa och skriva till en grupp med filer. Varje skrivåtgärd placeras i kö som ett arbetsobjekt och signalerar när den är klar. Huvudtråden väntar på att alla objekt ska signalera och sedan avslutas.

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

Kommentarer

AbandonedMutexException är nytt i .NET Framework version 2.0. I tidigare versioner WaitAll returnerar true metoden när en mutex avbryts. Ett övergivet mutex indikerar ofta ett allvarligt kodfel. När det gäller en systemomfattande mutex kan det tyda på att ett program har avslutats plötsligt (till exempel med hjälp av Windows Aktivitetshanteraren). Undantaget innehåller information som är användbar för felsökning.

Metoden WaitAll returnerar när alla referenser signaleras. Om fler än 64 handtag skickas utlöses en NotSupportedException . Om matrisen innehåller dubbletter misslyckas anropet med en DuplicateWaitObjectException.

Att anropa den här metodens överlagring motsvarar att anropa WaitAll(WaitHandle[], Int32, Boolean) metodens överlagring och ange -1 (eller Timeout.Infinite) för millisecondsTimeout och true för exitContext.