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 ミリ秒を表す TimeSpan A 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。それ以外の場合は false true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合は true、それ以外の場合は false true 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 version 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 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.

最大値timeoutInt32.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と同様に、 String、既定以外のコンテキストであることができる場合、ContextBoundObjectが現在のアプリケーション ドメインで、スタック上にします。Even 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.

既定以外のコンテキストでコードを実行しているときに指定するtrueexitContextが原因で、既定以外の管理コンテキストを終了するスレッド (つまり、既定のコンテキストへの移行) 実行する前に、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メソッドを指定してtrueexitContextスレッドが続行する、オブジェクトのすべてのメンバーへの呼び出しでブロックされているスレッドを許可する、同期ドメインを終了します。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。それ以外の場合は false true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合はtrue、それ以外の場合は false true 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 version 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と同様に、 String、既定以外のコンテキストであることができる場合、ContextBoundObjectが現在のアプリケーション ドメインで、スタック上にします。Even 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.

既定以外のコンテキストでコードを実行しているときに指定するtrueexitContextが原因で、既定以外の管理コンテキストを終了するスレッド (つまり、既定のコンテキストへの移行) 実行する前に、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メソッドを指定してtrueexitContextスレッドが続行する、オブジェクトのすべてのメンバーへの呼び出しでブロックされているスレッドを許可する、同期ドメインを終了します。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 ミリ秒を表す TimeSpan A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds, to wait indefinitely.

戻り値

waitHandles 内のすべての要素がシグナルを受信した場合はtrue、それ以外の場合は false true 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.

WaitAll待機が終了するすべてのハンドルがシグナル状態になることを意味するか、タイムアウトが発生するときに、メソッドが返されます。The 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.

最大値timeoutInt32.MaxValueします。The maximum value for timeout is Int32.MaxValue.

呼び出しと同じには、このメソッドのオーバー ロードを呼び出し、WaitAll(WaitHandle[], TimeSpan, Boolean)オーバー ロードを指定してfalseexitContextします。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、それ以外の場合は false true 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)オーバー ロードを指定してfalseexitContextします。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 version 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)メソッドのオーバー ロードは、-1 を指定する (またはTimeout.Infinite) のmillisecondsTimeouttrueexitContextします。Calling 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.

適用対象