Assembly : mscorlib (dans mscorlib.dll)
SyntaxePublic Shared Function WaitAll ( _ waitHandles As WaitHandle() _ ) As Boolean
Dim waitHandles As WaitHandle() Dim returnValue As Boolean returnValue = WaitHandle.WaitAll(waitHandles)
public static bool WaitAll ( WaitHandle[] waitHandles )
public: static bool WaitAll ( array<WaitHandle^>^ waitHandles )
public static boolean WaitAll ( WaitHandle[] waitHandles )
public static function WaitAll ( waitHandles : WaitHandle[] ) : boolean
Paramètres
- waitHandles
Tableau WaitHandle qui contient les objets que l'instance en cours attendra. Ce tableau ne peut pas contenir plusieurs références au même objet.
Valeur de retour
true lorsque tous les éléments de waitHandles ont reçu un signal ; sinon, la méthode n'effectue jamais de retour.
Exceptions| Type d'exception | Condition |
|---|---|
| La valeur du paramètre waitHandles est référence Null (Nothing en Visual Basic). - ou - Un ou plusieurs objets du tableau waitHandles ont la valeur référence Null (Nothing en Visual Basic). - ou - waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 2.0. | |
| Le tableau waitHandles contient des éléments qui sont des doublons. | |
| Le nombre d'objets de waitHandles est supérieur à la limite autorisée par le système. - ou - L'attribut STAThreadAttribute est appliqué à la procédure de thread du thread en cours, et waitHandles contient plusieurs éléments. | |
| waitHandles est un tableau qui ne contient aucun élément et la version du .NET Framework est 1.0 ou 1.1. | |
| L'attente s'est terminée, car un thread a terminé son exécution sans libérer de mutex. Cette exception n'est pas levée dans Windows 98 ou Windows Millennium. |
NotesAbandonedMutexException est une nouveauté de la version 2.0 du .NET Framework. Dans les versions antérieures, la méthode WaitAll retourne true lorsqu'un mutex est abandonné. Un mutex abandonné indique une erreur de codage grave. L'exception contient des informations utiles pour le débogage.
La méthode WaitAll effectue un retour lorsque tous les handles sont signalés. Dans certaines implémentations, si plus de 64 handles sont passés, NotSupportedException est levée. Si le tableau contient des doublons, l'appel échoue à cause d'une DuplicateWaitObjectException.
Remarque |
|---|
| La méthode WaitAll n'est pas prise en charge sur les threads qui ont STAThreadAttribute. |
L'appel de cette surcharge de méthode équivaut à appeler la surcharge de méthode WaitAll(WaitHandle[],Int32,Boolean) et à spécifier -1 (ou Timeout.Infinite) pour millisecondsTimeout et true pour exitContext.
ExempleL'exemple de code suivant illustre l'utilisation du pool de threads pour la création d'un groupe de fichiers et l'écriture dans ce dernier. Chaque opération d'écriture est placée dans la file d'attente en tant qu'élément de travail et elle envoie un signal lorsqu'elle est terminée. Le thread principal attend le signal de tous les éléments puis il se ferme.
Imports System Imports System.IO Imports System.Security.Permissions Imports System.Threading ' Request permission to create and write files to C:\TestTest. <Assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, _ All := "C:\TestTest")> 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
using System; using System.IO; using System.Security.Permissions; using System.Threading; // Request permission to create and write files to C:\TestTest. [assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, All = @"C:\TestTest")] 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(); } } }
using namespace System; using namespace System::IO; using namespace System::Security::Permissions; using namespace System::Threading; // Request permission to create and write files to C:\TestTest. // Maintain state to pass to WriteToFile. [assembly:FileIOPermissionAttribute(SecurityAction::RequestMinimum, All="C:\\TestTest")]; ref class State { public: String^ fileName; array<Byte>^byteArray; ManualResetEvent^ manualEvent; State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent ) : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent ) {} }; ref class Writer { private: static int workItemCount = 0; Writer(){} public: static void WriteToFile( Object^ state ) { int workItemNumber = workItemCount; Interlocked::Increment( workItemCount ); Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() ); State^ stateInfo = dynamic_cast<State^>(state); FileStream^ fileWriter; // Create and write to the file. try { fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create ); fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length ); } finally { if ( fileWriter != nullptr ) { fileWriter->Close(); } // Signal main() that the work item has finished. Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() ); stateInfo->manualEvent->Set(); } } }; void main() { const int numberOfFiles = 5; String^ dirName = "C:\\TestTest"; String^ fileName; array<Byte>^byteArray; Random^ randomGenerator = gcnew Random; array<ManualResetEvent^>^manualEvents = gcnew array<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 = gcnew array<Byte>(1000000); randomGenerator->NextBytes( byteArray ); manualEvents[ i ] = gcnew ManualResetEvent( false ); stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] ); ThreadPool::QueueUserWorkItem( gcnew 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." ); }
import System.*; import System.IO.*; import System.Security.Permissions.*; import System.Threading.*; import System.Threading.Thread; // Request permission to create and write files to C:\TestTest. /** @assembly FileIOPermissionAttribute(SecurityAction.RequestMinimum, All = "C:\\TestTest") */ class Test { public static void main(String[] args) { final int numberOfFiles = 5; String dirName = "C:\\TestTest"; String fileName; ubyte 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", String.valueOf(i), ".dat"); // Create random data to write to the file. byteArray = new ubyte[1000000]; randomGenerator.NextBytes(byteArray); manualEvents.set_Item(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."); } //main } //Test // Maintain state to pass to WriteToFile. class State { public String fileName; public ubyte byteArray[]; public ManualResetEvent manualEvent; public State(String fileName, ubyte byteArray[], ManualResetEvent manualEvent) { this.fileName = fileName; this.byteArray = byteArray; this.manualEvent = manualEvent; } //State } //State class Writer { private static int workItemCount = 0; Writer() { } //Writer public static void WriteToFile(Object state) { int workItemNumber = workItemCount; Interlocked.Increment(workItemCount); Console.WriteLine("Starting work item {0}.", String.valueOf(workItemNumber)); 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}.", String.valueOf(workItemNumber)); stateInfo.manualEvent.Set(); } } //WriteToFile } //Writer
Plates-formesWindows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition
Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.
Remarque
Outils (masquer)
S'enregistrer
Liste des Membres
Qui est en ligne?
FAQ