WaitHandle.WaitAll WaitHandle.WaitAll WaitHandle.WaitAll WaitHandle.WaitAll Method

定義

指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal.

オーバーロード

WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean)

指定した配列内のすべての要素がシグナルを受信するまで待機します。TimeSpan 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean)

指定した配列内のすべての要素がシグナルを受信するまで待機します。Int32 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan)

TimeSpan 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32)

Int32 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[])

指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean) WaitAll(WaitHandle[], TimeSpan, Boolean)

指定した配列内のすべての要素がシグナルを受信するまで待機します。TimeSpan 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

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

パラメーター

waitHandles
WaitHandle[]

現在のインスタンスが待機する対象のオブジェクトを格納している WaitHandle 配列。A WaitHandle array containing the objects for which the current instance will wait. この配列には、同一オブジェクトに対する複数の参照を含めることはできません。This array cannot contain multiple references to the same object.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

待機するミリ秒数を表す TimeSpan。無制限に待機する場合は、-1 ミリ秒を表す TimeSpanA TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.

exitContext
Boolean Boolean Boolean Boolean

待機する前にコンテキストの同期ドメインを終了し (同期されたコンテキスト内にいる場合)、後で再取得する場合は、true。それ以外の場合は falsetrue to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合は true、それ以外の場合は falsetrue when every element in waitHandles has received a signal; otherwise false.

例外

waitHandles パラメーターが null です。The waitHandles parameter is null.

または-or- waitHandles 配列内の 1 つ以上のオブジェクトが null です。One or more of the objects in the waitHandles array is null.

- または --or- waitHandles は要素を持たない配列で、.NET Framework のバージョンが 2.0 以降です。waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

waitHandles 配列に、重複する要素が含まれています。The waitHandles array contains elements that are duplicates.

waitHandles のオブジェクトの数が、システムで許可されている範囲を超えています。The number of objects in waitHandles is greater than the system permits.

または-or- STAThreadAttribute 属性は、現在のスレッドのスレッド プロシージャに適用されており、waitHandles には複数の要素が含まれています。The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles は要素を持たない配列で、.NET Framework のバージョンが 1.0 または 1.1 です。waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. または-or- timeoutMaxValue より大きくなっています。timeout is greater than MaxValue.

スレッドがミューテックスを解放せずに終了したため、待機が終了しました。The wait terminated because a thread exited without releasing a mutex. Windows 98 または Windows Millennium Edition では、この例外はスローされません。This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles 配列には、別のアプリケーション ドメインのWaitHandle の透過プロキシが含まれます。The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

次のコード例では、スレッドプールを使用して、ファイルのグループに対して非同期的に作成および書き込みを行う方法を示します。The following code example shows how to use the thread pool to asynchronously create and write to a group of files. 各書き込み操作は、作業項目としてキューに登録され、完了時に通知されます。Each write operation is queued as a work item and signals when it is finished. メインスレッドは、すべての項目がシグナル状態になるのを待機してから終了します。The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
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();
      }

   }

};

int 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.
   if ( WaitHandle::WaitAll( manualEvents, TimeSpan(0,0,5), false ) )
   {
      Console::WriteLine( "Files written - main exiting." );
   }
   else
   {
      
      // The wait operation times out.
      Console::WriteLine( "Error writing files - main exiting." );
   }
}

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
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

注釈

timeout 0 の場合、メソッドはブロックしません。If timeout is zero, the method does not block. 待機ハンドルの状態をテストし、すぐに制御を戻します。It tests the state of the wait handles and returns immediately.

AbandonedMutexExceptionは .NET Framework バージョン2.0 の新バージョンです。AbandonedMutexException is new in the .NET Framework version 2.0. 以前のバージョンではWaitAll 、ミューテックスtrueが破棄されると、メソッドはを返します。In previous versions, the WaitAll method returns true when a mutex is abandoned. 多くの場合、放棄ミューテックスは深刻なコーディングエラーを示しています。An abandoned mutex often indicates a serious coding error. システム全体のミューテックスの場合は、アプリケーションが突然 (たとえば、Windows タスクマネージャーを使用して) 終了したことを示している可能性があります。In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). 例外には、デバッグに役立つ情報が含まれています。The exception contains information useful for debugging.

待機が終了すると、メソッドはを返します。これは、すべてのハンドルがシグナル状態になるか、タイムアウトが発生することを意味します。WaitAllThe WaitAll method returns when the wait terminates, which means either all the handles are signaled or a time-out occurs. 実装によっては、64を超えるハンドルが渡さNotSupportedExceptionれると、がスローされます。On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. 配列に重複が含まれている場合、呼び出しは失敗します。If the array contains duplicates, the call will fail.

注意

メソッドWaitAllは、があるSTAThreadAttributeスレッドではサポートされていません。The WaitAll method is not supported on threads that have STAThreadAttribute.

timeout最大値はInt32.MaxValueです。The maximum value for timeout is Int32.MaxValue.

コンテキストの終了に関する注意事項Notes on Exiting the Context

既定exitContext以外のマネージコンテキスト内からWaitAllメソッドが呼び出されない限り、パラメーターは無効です。The exitContext parameter has no effect unless the WaitAll method is called from inside a nondefault managed context. これは、スレッドがからContextBoundObject派生したクラスのインスタンスの呼び出し内にある場合に発生する可能性があります。This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. からContextBoundObject派生ContextBoundObjectしていないクラスのメソッドを現在実行している場合でも、が現在のアプリケーションドメインのスタック上にある場合は、既定以外のコンテキストにすることができます。 StringEven if you are currently executing a method on a class that is not derived from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

コードが既定以外のコンテキストで実行されてtrueいるexitContext場合、にを指定すると、スレッドはWaitAllメソッドを実行する前に、既定以外のマネージコンテキスト (つまり、既定のコンテキストに遷移する) を終了します。When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAll method. メソッドのWaitAll呼び出しが完了した後、元の既定以外のコンテキストに戻ります。It returns to the original nondefault context after the call to the WaitAll method completes.

これは、コンテキストバインドクラスにがあるSynchronizationAttribute場合に便利です。This can be useful when the context-bound class has SynchronizationAttribute. その場合、クラスのメンバーへのすべての呼び出しが自動的に同期され、同期ドメインがクラスのコード本文全体になります。In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. メンバーの呼び出し履歴内のコードがWaitAllメソッドを呼び出し、にexitContexttrue指定した場合、スレッドは同期ドメインを終了します。これにより、オブジェクトの任意のメンバーへの呼び出しでブロックされているスレッドを続行できます。If code in the call stack of a member calls the WaitAll method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. メソッドからWaitAll制御が戻ったとき、呼び出しを行ったスレッドは、同期ドメインの再入力を待機する必要があります。When the WaitAll method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean) WaitAll(WaitHandle[], Int32, Boolean)

指定した配列内のすべての要素がシグナルを受信するまで待機します。Int32 値を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

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

パラメーター

waitHandles
WaitHandle[]

現在のインスタンスが待機する対象のオブジェクトを格納している WaitHandle 配列。A WaitHandle array containing the objects for which the current instance will wait. この配列には、同一オブジェクトに対する複数の参照 (重複) を含めることはできません。This array cannot contain multiple references to the same object (duplicates).

millisecondsTimeout
Int32 Int32 Int32 Int32

待機するミリ秒数。無制限に待機する場合は Infinite (-1)。The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

exitContext
Boolean Boolean Boolean Boolean

待機する前にコンテキストの同期ドメインを終了し (同期されたコンテキスト内にいる場合)、後で再取得する場合は、true。それ以外の場合は falsetrue to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合はtrue、それ以外の場合は falsetrue when every element in waitHandles has received a signal; otherwise, false.

例外

waitHandles パラメーターが null です。The waitHandles parameter is null.

または-or- waitHandles 配列内の 1 つ以上のオブジェクトが null です。One or more of the objects in the waitHandles array is null.

- または --or- waitHandles は要素を持たない配列で、.NET Framework のバージョンが 2.0 以降です。waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

waitHandles 配列に、重複する要素が含まれています。The waitHandles array contains elements that are duplicates.

waitHandles のオブジェクトの数が、システムで許可されている範囲を超えています。The number of objects in waitHandles is greater than the system permits.

または-or- STAThreadAttribute 属性は、現在のスレッドのスレッド プロシージャに適用されており、waitHandles には複数の要素が含まれています。The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles は要素を持たない配列で、.NET Framework のバージョンが 1.0 または 1.1 です。waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。The wait completed because a thread exited without releasing a mutex. Windows 98 または Windows Millennium Edition では、この例外はスローされません。This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles 配列には、別のアプリケーション ドメインのWaitHandle の透過プロキシが含まれます。The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

次のコード例では、スレッドプールを使用して、ファイルのグループに対して非同期的に作成および書き込みを行う方法を示します。The following code example shows how to use the thread pool to asynchronously create and write to a group of files. 各書き込み操作は、作業項目としてキューに登録され、完了時に通知されます。Each write operation is queued as a work item and signals when it is finished. メインスレッドは、すべての項目がシグナル状態になるのを待機してから終了します。The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
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();
      }

   }

};

int 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.
   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." );
   }
}

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
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

注釈

millisecondsTimeout 0 の場合、メソッドはブロックしません。If millisecondsTimeout is zero, the method does not block. 待機ハンドルの状態をテストし、すぐに制御を戻します。It tests the state of the wait handles and returns immediately.

AbandonedMutexExceptionは .NET Framework バージョン2.0 の新バージョンです。AbandonedMutexException is new in the .NET Framework version 2.0. 以前のバージョンではWaitAll 、ミューテックスtrueが破棄されると、メソッドはを返します。In previous versions, the WaitAll method returns true when a mutex is abandoned. 多くの場合、放棄ミューテックスは深刻なコーディングエラーを示しています。An abandoned mutex often indicates a serious coding error. システム全体のミューテックスの場合は、アプリケーションが突然 (たとえば、Windows タスクマネージャーを使用して) 終了したことを示している可能性があります。In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). 例外には、デバッグに役立つ情報が含まれています。The exception contains information useful for debugging.

このWaitAllメソッドは、待機が終了したときにを返します。これは、すべてのハンドルがシグナル状態になったか、タイムアウトが発生したかを示します。The WaitAll method returns when the wait terminates, which means either when all the handles are signaled or when time-out occurs. 実装によっては、64を超えるハンドルが渡さNotSupportedExceptionれると、がスローされます。On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. 配列に重複がある場合、呼び出しはでDuplicateWaitObjectException失敗します。If there are duplicates in the array, the call fails with a DuplicateWaitObjectException.

注意

メソッドWaitAllは、があるSTAThreadAttributeスレッドではサポートされていません。The WaitAll method is not supported on threads that have STAThreadAttribute.

コンテキストの終了に関する注意事項Notes on Exiting the Context

既定exitContext以外のマネージコンテキスト内からWaitAllメソッドが呼び出されない限り、パラメーターは無効です。The exitContext parameter has no effect unless the WaitAll method is called from inside a nondefault managed context. これは、スレッドがからContextBoundObject派生したクラスのインスタンスの呼び出し内にある場合に発生する可能性があります。This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. からContextBoundObject派生ContextBoundObjectしていないクラスのメソッドを現在実行している場合でも、が現在のアプリケーションドメインのスタック上にある場合は、既定以外のコンテキストにすることができます。 StringEven if you are currently executing a method on a class that is not derived from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

コードが既定以外のコンテキストで実行されてtrueいるexitContext場合、にを指定すると、スレッドはWaitAllメソッドを実行する前に、既定以外のマネージコンテキスト (つまり、既定のコンテキストに遷移する) を終了します。When your code is executing in a nondefault context, specifying true for exitContext causes the thread to exit the nondefault managed context (that is, to transition to the default context) before executing the WaitAll method. スレッドは、メソッドのWaitAll呼び出しが完了した後、元の既定以外のコンテキストに戻ります。The thread returns to the original nondefault context after the call to the WaitAll method completes.

これは、コンテキストバインドクラスにSynchronizationAttribute属性がある場合に便利です。This can be useful when the context-bound class has the SynchronizationAttribute attribute. その場合、クラスのメンバーへのすべての呼び出しが自動的に同期され、同期ドメインがクラスのコード本文全体になります。In that case, all calls to members of the class are automatically synchronized, and the synchronization domain is the entire body of code for the class. メンバーの呼び出し履歴内のコードがWaitAllメソッドを呼び出し、にexitContexttrue指定した場合、スレッドは同期ドメインを終了します。これにより、オブジェクトの任意のメンバーへの呼び出しでブロックされているスレッドを続行できます。If code in the call stack of a member calls the WaitAll method and specifies true for exitContext, the thread exits the synchronization domain, allowing a thread that is blocked on a call to any member of the object to proceed. メソッドからWaitAll制御が戻ったとき、呼び出しを行ったスレッドは、同期ドメインの再入力を待機する必要があります。When the WaitAll method returns, the thread that made the call must wait to reenter the synchronization domain.

WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan) WaitAll(WaitHandle[], TimeSpan)

TimeSpan 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

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

パラメーター

waitHandles
WaitHandle[]

現在のインスタンスが待機する対象のオブジェクトを格納している WaitHandle 配列。A WaitHandle array containing the objects for which the current instance will wait. この配列には、同一オブジェクトに対する複数の参照を含めることはできません。This array cannot contain multiple references to the same object.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

待機するミリ秒数を表す TimeSpan。無制限に待機する場合は、-1 ミリ秒を表す TimeSpanA TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合はtrue、それ以外の場合は falsetrue when every element in waitHandles has received a signal; otherwise, false.

例外

waitHandles パラメーターが null です。The waitHandles parameter is null.

- または --or- waitHandles 配列内の 1 つ以上のオブジェクトが null です。One or more of the objects in the waitHandles array is null.

または-or- waitHandles は、要素を持たない配列です。waitHandles is an array with no elements.

Windows ストア アプリ用 .NET またはポータブル クラス ライブラリでは、基本クラスの例外である ArgumentException を代わりにキャッチします。In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

waitHandles 配列に、重複する要素が含まれています。The waitHandles array contains elements that are duplicates.

waitHandles のオブジェクトの数が、システムで許可されている範囲を超えています。The number of objects in waitHandles is greater than the system permits.

または-or- STAThreadAttribute 属性は、現在のスレッドのスレッド プロシージャに適用されており、waitHandles には複数の要素が含まれています。The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - または --or- timeoutMaxValue より大きくなっています。timeout is greater than MaxValue.

スレッドがミューテックスを解放せずに終了したため、待機が終了しました。The wait terminated because a thread exited without releasing a mutex. Windows 98 または Windows Millennium Edition では、この例外はスローされません。This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles 配列には、別のアプリケーション ドメインのWaitHandle の透過プロキシが含まれます。The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

注釈

timeout 0 の場合、メソッドはブロックしません。If timeout is zero, the method does not block. 待機ハンドルの状態をテストし、すぐに制御を戻します。It tests the state of the wait handles and returns immediately.

待機が終了すると、メソッドはを返します。これは、すべてのハンドルがシグナル状態になるか、タイムアウトが発生することを意味します。WaitAllThe WaitAll method returns when the wait terminates, which means either all the handles are signaled or a time-out occurs. 実装によっては、64を超えるハンドルが渡さNotSupportedExceptionれると、がスローされます。On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. 配列に重複が含まれている場合、呼び出しは失敗します。If the array contains duplicates, the call will fail.

注意

メソッドWaitAllは、があるSTAThreadAttributeスレッドではサポートされていません。The WaitAll method is not supported on threads that have STAThreadAttribute.

timeout最大値はInt32.MaxValueです。The maximum value for timeout is Int32.MaxValue.

このメソッドオーバーロードの呼び出しは、 WaitAll(WaitHandle[], TimeSpan, Boolean)オーバーロードを呼び出し、にexitContextfalse指定することと同じです。Calling this method overload is the same as calling the WaitAll(WaitHandle[], TimeSpan, Boolean) overload and specifying false for exitContext.

WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32) WaitAll(WaitHandle[], Int32)

Int32 値を使用して時間間隔を指定し、指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

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

パラメーター

waitHandles
WaitHandle[]

現在のインスタンスが待機する対象のオブジェクトを格納している WaitHandle 配列。A WaitHandle array containing the objects for which the current instance will wait. この配列には、同一オブジェクトに対する複数の参照 (重複) を含めることはできません。This array cannot contain multiple references to the same object (duplicates).

millisecondsTimeout
Int32 Int32 Int32 Int32

待機するミリ秒数。無制限に待機する場合は Infinite (-1)。The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合はtrue、それ以外の場合は falsetrue when every element in waitHandles has received a signal; otherwise, false.

例外

waitHandles パラメーターが null です。The waitHandles parameter is null.

- または --or- waitHandles 配列内の 1 つ以上のオブジェクトが null です。One or more of the objects in the waitHandles array is null.

または-or- waitHandles は、要素を持たない配列です。waitHandles is an array with no elements.

Windows ストア アプリ用 .NET またはポータブル クラス ライブラリでは、基本クラスの例外である ArgumentException を代わりにキャッチします。In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

waitHandles 配列に、重複する要素が含まれています。The waitHandles array contains elements that are duplicates.

waitHandles のオブジェクトの数が、システムで許可されている範囲を超えています。The number of objects in waitHandles is greater than the system permits.

または-or- STAThreadAttribute 属性は、現在のスレッドのスレッド プロシージャに適用されており、waitHandles には複数の要素が含まれています。The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。The wait completed because a thread exited without releasing a mutex. Windows 98 または Windows Millennium Edition では、この例外はスローされません。This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles 配列には、別のアプリケーション ドメインのWaitHandle の透過プロキシが含まれます。The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

注釈

millisecondsTimeout 0 の場合、メソッドはブロックしません。If millisecondsTimeout is zero, the method does not block. 待機ハンドルの状態をテストし、すぐに制御を戻します。It tests the state of the wait handles and returns immediately.

このWaitAllメソッドは、待機が終了したときにを返します。これは、すべてのハンドルがシグナル状態になったか、タイムアウトが発生したかを示します。The WaitAll method returns when the wait terminates, which means either when all the handles are signaled or when time-out occurs. 実装によっては、64を超えるハンドルが渡さNotSupportedExceptionれると、がスローされます。On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. 配列に重複がある場合、呼び出しはでDuplicateWaitObjectException失敗します。If there are duplicates in the array, the call fails with a DuplicateWaitObjectException.

注意

メソッドWaitAllは、があるSTAThreadAttributeスレッドではサポートされていません。The WaitAll method is not supported on threads that have STAThreadAttribute.

このメソッドオーバーロードの呼び出しは、 WaitAll(WaitHandle[], Int32, Boolean)オーバーロードを呼び出し、にexitContextfalse指定することと同じです。Calling this method overload is the same as calling the WaitAll(WaitHandle[], Int32, Boolean) overload and specifying false for exitContext.

WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[]) WaitAll(WaitHandle[])

指定した配列内のすべての要素がシグナルを受信するまで待機します。Waits for all the elements in the specified array to receive a signal.

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

パラメーター

waitHandles
WaitHandle[]

現在のインスタンスが待機する対象のオブジェクトを格納している WaitHandle 配列。A WaitHandle array containing the objects for which the current instance will wait. この配列には、同一オブジェクトに対する複数の参照を含めることはできません。This array cannot contain multiple references to the same object.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合は true。それ以外の場合は、待機を続けます。true when every element in waitHandles has received a signal; otherwise the method never returns.

例外

waitHandles パラメーターが null です。The waitHandles parameter is null. - または --or- waitHandles 配列内の 1 つ以上のオブジェクトが null です。One or more of the objects in the waitHandles array are null.

または-or- waitHandles は要素を持たない配列で、.NET Framework のバージョンが 2.0 以降です。waitHandles is an array with no elements and the .NET Framework version is 2.0 or later.

Windows ストア アプリ用 .NET またはポータブル クラス ライブラリでは、基本クラスの例外である ArgumentException を代わりにキャッチします。In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, ArgumentException, instead.

waitHandles 配列に、重複する要素が含まれています。The waitHandles array contains elements that are duplicates.

waitHandles のオブジェクトの数が、システムで許可されている範囲を超えています。The number of objects in waitHandles is greater than the system permits.

または-or- STAThreadAttribute 属性は、現在のスレッドのスレッド プロシージャに適用されており、waitHandles には複数の要素が含まれています。The STAThreadAttribute attribute is applied to the thread procedure for the current thread, and waitHandles contains more than one element.

waitHandles は要素を持たない配列で、.NET Framework のバージョンが 1.0 または 1.1 です。waitHandles is an array with no elements and the .NET Framework version is 1.0 or 1.1.

スレッドがミューテックスを解放せずに終了したため、待機が終了しました。The wait terminated because a thread exited without releasing a mutex. Windows 98 または Windows Millennium Edition では、この例外はスローされません。This exception is not thrown on Windows 98 or Windows Millennium Edition.

waitHandles 配列には、別のアプリケーション ドメインのWaitHandle の透過プロキシが含まれます。The waitHandles array contains a transparent proxy for a WaitHandle in another application domain.

次のコード例では、スレッドプールを使用して、ファイルのグループに対して非同期的に作成および書き込みを行う方法を示します。The following code example shows how to use the thread pool to asynchronously create and write to a group of files. 各書き込み操作は、作業項目としてキューに登録され、完了時に通知されます。Each write operation is queued as a work item and signals when it is finished. メインスレッドは、すべての項目がシグナル状態になるのを待機してから終了します。The main thread waits for all the items to signal and then exits.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

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." );
}

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
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

注釈

AbandonedMutexExceptionは .NET Framework バージョン2.0 の新バージョンです。AbandonedMutexException is new in the .NET Framework version 2.0. 以前のバージョンではWaitAll 、ミューテックスtrueが破棄されると、メソッドはを返します。In previous versions, the WaitAll method returns true when a mutex is abandoned. 多くの場合、放棄ミューテックスは深刻なコーディングエラーを示しています。An abandoned mutex often indicates a serious coding error. システム全体のミューテックスの場合は、アプリケーションが突然 (たとえば、Windows タスクマネージャーを使用して) 終了したことを示している可能性があります。In the case of a system-wide mutex, it might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager). 例外には、デバッグに役立つ情報が含まれています。The exception contains information useful for debugging.

すべてWaitAllのハンドルがシグナル状態になると、メソッドはを返します。The WaitAll method returns when all the handles are signaled. 実装によっては、64を超えるハンドルが渡さNotSupportedExceptionれると、がスローされます。On some implementations, if more than 64 handles are passed, a NotSupportedException is thrown. 配列に重複が含まれている場合、呼び出しDuplicateWaitObjectExceptionはで失敗します。If the array contains duplicates, the call fails with a DuplicateWaitObjectException.

注意

メソッドWaitAllは、があるSTAThreadAttributeスレッドではサポートされていません。The WaitAll method is not supported on threads that have STAThreadAttribute.

このWaitAll(WaitHandle[], Int32, Boolean)メソッドのmillisecondsTimeout true Timeout.Infiniteオーバーロードを呼び出すことは、メソッドのオーバーロードを呼び出し、およびに対して-1(または)を指定することと同じです。exitContextCalling this method overload is equivalent to calling the WaitAll(WaitHandle[], Int32, Boolean) method overload and specifying -1 (or Timeout.Infinite) for millisecondsTimeout and true for exitContext.

適用対象