WaitHandle.WaitAll Metoda

Definicja

Przestrzeń nazw:

System.Threading

Zestawy:

netstandard.dll, System.Runtime.dll

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał.

Przeciążenia

Nazwa	Opis
WaitAll(WaitHandle[], TimeSpan, Boolean)	Czeka na wszystkie elementy w określonej tablicy, aby odebrać sygnał, używając TimeSpan wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.
WaitAll(WaitHandle[], Int32, Boolean)	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.
WaitAll(WaitHandle[], TimeSpan)	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając TimeSpan wartości w celu określenia interwału czasu.
WaitAll(WaitHandle[], Int32)	Oczekuje, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu.
WaitAll(WaitHandle[])	Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Źródło:

WaitHandle.cs

Czeka na wszystkie elementy w określonej tablicy, aby odebrać sygnał, używając TimeSpan wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.

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

Parametry

waitHandles

WaitHandle[]

Tablica WaitHandle zawierająca obiekty, dla których będzie czekać bieżące wystąpienie. Ta tablica nie może zawierać wielu odwołań do tego samego obiektu.

timeout

TimeSpan

Wartość TimeSpan reprezentująca liczbę milisekund oczekiwania lub wartość reprezentującą TimeSpan -1 milisekund, aby czekać na czas nieokreślony.

exitContext

Boolean

true aby zamknąć domenę synchronizacji dla kontekstu przed oczekiwaniem (jeśli w zsynchronizowanym kontekście) i ponownie go później; w przeciwnym razie, false.

Zwraca

Boolean

true gdy każdy element w waitHandles elemecie otrzymał sygnał; w przeciwnym razie false.

Wyjątki

ArgumentNullException

Parametr waitHandles jest null.

— lub —

Co najmniej jeden obiekt w tablicy waitHandles to null.

— lub —

waitHandles jest tablicą bez elementów, a program .NET Framework w wersji 2.0 lub nowszej.

DuplicateWaitObjectException

Tablica waitHandles zawiera elementy, które są duplikatami.

NotSupportedException

Liczba obiektów w obiekcie waitHandles jest większa niż zezwala system.

— lub —

Atrybut STAThreadAttribute jest stosowany do procedury wątku dla bieżącego wątku i waitHandles zawiera więcej niż jeden element.

ApplicationException

waitHandles jest tablicą bez elementów, a wersja programu .NET Framework to 1.0 lub 1.1.

ArgumentOutOfRangeException

timeout jest liczbą ujemną inną niż -1 milisekund, która reprezentuje nieskończony limit czasu.

— lub —

timeout wartość jest większa niż Int32.MaxValue.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

InvalidOperationException

Tablica waitHandles zawiera przezroczysty serwer proxy dla obiektu WaitHandle w innej domenie aplikacji.

Przykłady

W poniższym przykładzie kodu pokazano, jak używać puli wątków do asynchronicznego tworzenia i zapisywania w grupie plików. Każda operacja zapisu jest kolejkowana jako element roboczy i sygnały po zakończeniu. Główny wątek czeka na sygnał wszystkich elementów, a następnie kończy.

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

Uwagi

Jeśli timeout ma wartość zero, metoda nie blokuje. Testuje stan uchwytów oczekiwania i zwraca natychmiast.

Jeśli mutex zostanie porzucony, AbandonedMutexException zostanie zgłoszony. Porzucony mutex często wskazuje poważny błąd kodowania. W przypadku całego systemu mutex może wskazywać, że aplikacja została nagle zakończona (na przykład za pomocą Menedżera zadań systemu Windows). Wyjątek zawiera informacje przydatne do debugowania.

Metoda WaitAll zwraca czas zakończenia oczekiwania, co oznacza, że wszystkie dojścia są sygnalizowane lub występuje przekroczenie limitu czasu. Jeśli przekazano więcej niż 64 uchwyty, NotSupportedException zostanie zwrócony wyjątek . Jeśli tablica zawiera duplikaty, wywołanie zakończy się niepowodzeniem.

Note

Metoda nie jest obsługiwana WaitAll w wątkach w STA stanie.

Wartość maksymalna dla timeout parametru to Int32.MaxValue.

Zamykanie kontekstu

Parametr exitContext nie ma wpływu, chyba że ta metoda jest wywoływana z wewnątrz kontekstu zarządzanego bez definicji. Kontekst zarządzany może być niezdefinicyjny, jeśli wątek znajduje się wewnątrz wywołania wystąpienia klasy pochodzącej z ContextBoundObjectklasy . Nawet jeśli obecnie wykonujesz metodę w klasie, która nie pochodzi z ContextBoundObjectklasy , na przykład String, możesz być w kontekście niedefault, jeśli ContextBoundObject element znajduje się na stosie w bieżącej domenie aplikacji.

Gdy kod jest wykonywany w kontekście niezdefinicyjnym, określając true , że exitContext wątek ma zamknąć kontekst zarządzany bez definicji (tj. przejść do kontekstu domyślnego) przed wykonaniem tej metody. Po zakończeniu wywołania tej metody w wątku nastąpi powrót do oryginalnego kontekstu niezdefinicyjnego.

Wyjście z kontekstu może być przydatne, gdy klasa powiązana kontekstowo SynchronizationAttribute ma atrybut . W takim przypadku wszystkie wywołania elementów członkowskich klasy są automatycznie synchronizowane, a domena synchronizacji jest całą treścią kodu dla klasy. Jeśli kod w stosie wywołań elementu członkowskiego wywołuje tę metodę i określa true metodę exitContext, wątek kończy domenę synchronizacji, co umożliwia wątkowi zablokowanemu wywołaniu dowolnego elementu członkowskiego obiektu. Po powrocie tej metody wątek, który wykonał wywołanie, musi czekać na ponowne włączenie domeny synchronizacji.

WaitAll(WaitHandle[], Int32, Boolean)

Źródło:

WaitHandle.cs

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.

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

Parametry

waitHandles

WaitHandle[]

Tablica WaitHandle zawierająca obiekty, dla których będzie czekać bieżące wystąpienie. Ta tablica nie może zawierać wielu odwołań do tego samego obiektu (duplikaty).

millisecondsTimeout

Int32

Liczba milisekund oczekiwania lub Infinite (-1) do oczekiwania na czas nieokreślony.

exitContext

Boolean

true aby zamknąć domenę synchronizacji dla kontekstu przed oczekiwaniem (jeśli w zsynchronizowanym kontekście) i ponownie go później; w przeciwnym razie, false.

Zwraca

Boolean

true gdy każdy element w waitHandles elemecie otrzymał sygnał; w przeciwnym razie false.

Wyjątki

ArgumentNullException

Parametr waitHandles jest null.

— lub —

Co najmniej jeden obiekt w tablicy waitHandles to null.

— lub —

waitHandles jest tablicą bez elementów, a program .NET Framework w wersji 2.0 lub nowszej.

DuplicateWaitObjectException

Tablica waitHandles zawiera elementy, które są duplikatami.

NotSupportedException

Liczba obiektów w obiekcie waitHandles jest większa niż zezwala system.

— lub —

Bieżący wątek jest w STA stanie i waitHandles zawiera więcej niż jeden element.

ApplicationException

waitHandles jest tablicą bez elementów, a wersja programu .NET Framework to 1.0 lub 1.1.

ArgumentOutOfRangeException

millisecondsTimeout jest liczbą ujemną inną niż -1, która reprezentuje nieskończony limit czasu.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

InvalidOperationException

Tablica waitHandles zawiera przezroczysty serwer proxy dla obiektu WaitHandle w innej domenie aplikacji.

Przykłady

W poniższym przykładzie kodu pokazano, jak używać puli wątków do asynchronicznego tworzenia i zapisywania w grupie plików. Każda operacja zapisu jest kolejkowana jako element roboczy i sygnały po zakończeniu. Główny wątek czeka na sygnał wszystkich elementów, a następnie kończy.

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

Uwagi

Jeśli millisecondsTimeout ma wartość zero, metoda nie blokuje. Testuje stan uchwytów oczekiwania i zwraca natychmiast.

Jeśli mutex zostanie porzucony, AbandonedMutexException zostanie zgłoszony. Porzucony mutex często wskazuje poważny błąd kodowania. W przypadku całego systemu mutex może wskazywać, że aplikacja została nagle zakończona (na przykład za pomocą Menedżera zadań systemu Windows). Wyjątek zawiera informacje przydatne do debugowania.

Metoda WaitAll zwraca czas zakończenia oczekiwania, co oznacza, że gdy wszystkie dojścia są sygnalizowane lub gdy wystąpi przekroczenie limitu czasu. Jeśli przekazano więcej niż 64 uchwyty, NotSupportedException zostanie zwrócony wyjątek . Jeśli w tablicy występują duplikaty, wywołanie kończy się niepowodzeniem z parametrem DuplicateWaitObjectException.

Note

Metoda nie jest obsługiwana WaitAll w wątkach w STA stanie.

Zamykanie kontekstu

Parametr exitContext nie ma wpływu, chyba że ta metoda jest wywoływana z wewnątrz kontekstu zarządzanego bez definicji. Kontekst zarządzany może być niezdefinicyjny, jeśli wątek znajduje się wewnątrz wywołania wystąpienia klasy pochodzącej z ContextBoundObjectklasy . Nawet jeśli obecnie wykonujesz metodę w klasie, która nie pochodzi z ContextBoundObjectklasy , na przykład String, możesz być w kontekście niedefault, jeśli ContextBoundObject element znajduje się na stosie w bieżącej domenie aplikacji.

Gdy kod jest wykonywany w kontekście niezdefinicyjnym, określając true , że exitContext wątek ma zamknąć kontekst zarządzany bez definicji (tj. przejść do kontekstu domyślnego) przed wykonaniem tej metody. Po zakończeniu wywołania tej metody w wątku nastąpi powrót do oryginalnego kontekstu niezdefinicyjnego.

Wyjście z kontekstu może być przydatne, gdy klasa powiązana kontekstowo SynchronizationAttribute ma atrybut . W takim przypadku wszystkie wywołania elementów członkowskich klasy są automatycznie synchronizowane, a domena synchronizacji jest całą treścią kodu dla klasy. Jeśli kod w stosie wywołań elementu członkowskiego wywołuje tę metodę i określa true metodę exitContext, wątek kończy domenę synchronizacji, co umożliwia wątkowi zablokowanemu wywołaniu dowolnego elementu członkowskiego obiektu. Po powrocie tej metody wątek, który wykonał wywołanie, musi czekać na ponowne włączenie domeny synchronizacji.

WaitAll(WaitHandle[], TimeSpan)

Źródło:

WaitHandle.cs

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając TimeSpan wartości w celu określenia interwału czasu.

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

Parametry

waitHandles

WaitHandle[]

Tablica WaitHandle zawierająca obiekty, dla których będzie czekać bieżące wystąpienie. Ta tablica nie może zawierać wielu odwołań do tego samego obiektu.

timeout

TimeSpan

Wartość TimeSpan reprezentująca liczbę milisekund oczekiwania lub wartość reprezentującą TimeSpan -1 milisekund, aby czekać na czas nieokreślony.

Zwraca

Boolean

true gdy każdy element w waitHandles elemecie otrzymał sygnał; w przeciwnym razie false.

Wyjątki

ArgumentNullException

Parametr waitHandles jest null.

— lub —

Co najmniej jeden obiekt w tablicy waitHandles to null.

— lub —

waitHandles jest tablicą bez elementów.

DuplicateWaitObjectException

Tablica waitHandles zawiera elementy, które są duplikatami.

NotSupportedException

Liczba obiektów w obiekcie waitHandles jest większa niż zezwala system.

— lub —

Bieżący wątek jest w STA stanie i waitHandles zawiera więcej niż jeden element.

ArgumentOutOfRangeException

timeout jest liczbą ujemną inną niż -1 milisekund, która reprezentuje nieskończony limit czasu.

— lub —

timeout wartość jest większa niż Int32.MaxValue.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

InvalidOperationException

Tablica waitHandles zawiera przezroczysty serwer proxy dla obiektu WaitHandle w innej domenie aplikacji.

Uwagi

Jeśli timeout ma wartość zero, metoda nie blokuje. Testuje stan uchwytów oczekiwania i zwraca natychmiast.

Metoda WaitAll zwraca czas zakończenia oczekiwania, co oznacza, że wszystkie dojścia są sygnalizowane lub występuje przekroczenie limitu czasu. Jeśli przekazano więcej niż 64 uchwyty, NotSupportedException zostanie zwrócony wyjątek . Jeśli tablica zawiera duplikaty, wywołanie zakończy się niepowodzeniem.

Note

Metoda nie jest obsługiwana WaitAll w wątkach w STA stanie.

Wartość maksymalna dla timeout parametru to Int32.MaxValue.

Wywołanie tego przeciążenia metody jest takie samo, jak wywołanie WaitAll(WaitHandle[], TimeSpan, Boolean) przeciążenia i określenie false parametru .exitContext

WaitAll(WaitHandle[], Int32)

Źródło:

WaitHandle.cs

Oczekuje, aż wszystkie elementy w określonej tablicy otrzymają sygnał, używając Int32 wartości w celu określenia interwału czasu.

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

Parametry

waitHandles

WaitHandle[]

Tablica WaitHandle zawierająca obiekty, dla których będzie czekać bieżące wystąpienie. Ta tablica nie może zawierać wielu odwołań do tego samego obiektu (duplikaty).

millisecondsTimeout

Int32

Liczba milisekund oczekiwania lub Infinite (-1) do oczekiwania na czas nieokreślony.

Zwraca

Boolean

true gdy każdy element w waitHandles elemecie otrzymał sygnał; w przeciwnym razie false.

Wyjątki

ArgumentNullException

Parametr waitHandles jest null.

— lub —

Co najmniej jeden obiekt w tablicy waitHandles to null.

— lub —

waitHandles jest tablicą bez elementów.

DuplicateWaitObjectException

Tablica waitHandles zawiera elementy, które są duplikatami.

NotSupportedException

Liczba obiektów w obiekcie waitHandles jest większa niż zezwala system.

— lub —

Bieżący wątek jest w STA stanie i waitHandles zawiera więcej niż jeden element.

ArgumentOutOfRangeException

millisecondsTimeout jest liczbą ujemną inną niż -1, która reprezentuje nieskończony limit czasu.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

InvalidOperationException

Tablica waitHandles zawiera przezroczysty serwer proxy dla obiektu WaitHandle w innej domenie aplikacji.

Uwagi

Jeśli millisecondsTimeout ma wartość zero, metoda nie blokuje. Testuje stan uchwytów oczekiwania i zwraca natychmiast.

Metoda WaitAll zwraca czas zakończenia oczekiwania, co oznacza, że gdy wszystkie dojścia są sygnalizowane lub gdy wystąpi przekroczenie limitu czasu. Jeśli przekazano więcej niż 64 uchwyty, NotSupportedException zostanie zwrócony wyjątek . Jeśli w tablicy występują duplikaty, wywołanie kończy się niepowodzeniem z parametrem DuplicateWaitObjectException.

Note

Metoda nie jest obsługiwana WaitAll w wątkach w STA stanie.

Wywołanie tego przeciążenia metody jest takie samo, jak wywołanie WaitAll(WaitHandle[], Int32, Boolean) przeciążenia i określenie false parametru .exitContext

WaitAll(WaitHandle[])

Źródło:

WaitHandle.cs

Czeka, aż wszystkie elementy w określonej tablicy otrzymają sygnał.

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

Parametry

waitHandles

WaitHandle[]

Tablica WaitHandle zawierająca obiekty, dla których będzie czekać bieżące wystąpienie. Ta tablica nie może zawierać wielu odwołań do tego samego obiektu.

Zwraca

Boolean

true gdy każdy element w waitHandles elemecie otrzymał sygnał; w przeciwnym razie metoda nigdy nie zwraca.

Wyjątki

ArgumentNullException

Parametr waitHandles jest null. — lub —

Co najmniej jeden obiekt w tablicy waitHandles to null.

— lub —

waitHandles jest tablicą bez elementów, a program .NET Framework w wersji 2.0 lub nowszej.

DuplicateWaitObjectException

Tablica waitHandles zawiera elementy, które są duplikatami.

NotSupportedException

Liczba obiektów w obiekcie waitHandles jest większa niż zezwala system.

— lub —

Bieżący wątek jest w STA stanie i waitHandles zawiera więcej niż jeden element.

ApplicationException

waitHandles jest tablicą bez elementów, a wersja programu .NET Framework to 1.0 lub 1.1.

AbandonedMutexException

Oczekiwanie zostało zakończone, ponieważ wątek zakończył się bez zwalniania mutexu.

InvalidOperationException

Tablica waitHandles zawiera przezroczysty serwer proxy dla obiektu WaitHandle w innej domenie aplikacji.

Przykłady

W poniższym przykładzie kodu pokazano, jak używać puli wątków do asynchronicznego tworzenia i zapisywania w grupie plików. Każda operacja zapisu jest kolejkowana jako element roboczy i sygnały po zakończeniu. Główny wątek czeka na sygnał wszystkich elementów, a następnie kończy.

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

Uwagi

AbandonedMutexException jest nowy w programie .NET Framework w wersji 2.0. W poprzednich wersjach WaitAll metoda zwraca true wartość po porzuceniu mutexu. Porzucony mutex często wskazuje poważny błąd kodowania. W przypadku całego systemu mutex może wskazywać, że aplikacja została nagle zakończona (na przykład za pomocą Menedżera zadań systemu Windows). Wyjątek zawiera informacje przydatne do debugowania.

Metoda WaitAll zwraca wartość, gdy wszystkie dojścia są sygnalizowane. Jeśli przekazano więcej niż 64 uchwyty, NotSupportedException zostanie zwrócony wyjątek . Jeśli tablica zawiera duplikaty, wywołanie zakończy się niepowodzeniem z parametrem DuplicateWaitObjectException.

Note

Metoda nie jest obsługiwana WaitAll w wątkach w STA stanie.

Wywołanie tego przeciążenia metody jest równoważne wywołaniu przeciążenia metody i określeniu WaitAll(WaitHandle[], Int32, Boolean) -1 (lub Timeout.Infinite) dla millisecondsTimeout elementu i true dla exitContextelementu .