WaitHandle.WaitOne メソッド

  • リファレンス

定義

名前空間:
System.Threading
アセンブリ:
System.Runtime.dll
アセンブリ:
netstandard.dll
アセンブリ:
mscorlib.dll

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。

オーバーロード

WaitOne()

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。
WaitOne(Int32)

32 ビット符号付き整数を使用して時間間隔をミリ秒単位で指定し、現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。
WaitOne(TimeSpan)

TimeSpan を使用して時間間隔を指定し、現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。
WaitOne(Int32, Boolean)

現在の WaitHandle がシグナルを受信するまで現在のスレッドをブロックします。時間間隔を指定するために 32 ビット符号付き整数を使用し、待機の前でも同期ドメインを終了するかどうかを指定します。
WaitOne(TimeSpan, Boolean)

現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。TimeSpan を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。

WaitOne()

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。

public:
 virtual bool WaitOne();
public virtual bool WaitOne ();
abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool
Public Overridable Function WaitOne () As Boolean

戻り値

Boolean

現在のインスタンスがシグナルを受け取った場合は true。 現在のインスタンスがシグナルを受け取らない場合は、WaitOne() はシグナルを受け取るまで待機を続けます。

例外

ObjectDisposedException

現在のインスタンスは既に破棄されています。

AbandonedMutexException

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

InvalidOperationException

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

例

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が終了するまで待機している間にプロセスが終了するのを維持する方法を示しています。

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   autoEvent->WaitOne(  );
   Console::WriteLine( "Work method signaled.\nMain ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        autoEvent.WaitOne()
        Console.WriteLine("Work method signaled.")
        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

注釈

AbandonedMutexExceptionは、.NET Framework バージョン 2.0 の新機能です。 以前のバージョンでは、 メソッド WaitOne はミューテックス true が破棄された場合に を返します。 破棄されたミューテックスは、多くの場合、重大なコーディング エラーを示します。 システム全体のミューテックスの場合、アプリケーションが突然終了した可能性があります (たとえば、Windows タスク マネージャー を使用して)。 例外には、デバッグに役立つ情報が含まれている。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するまで無期限にブロックします。 非同期操作の完了時に など、 が別のスレッドからシグナルを受信するまでブロックするには、このメソッド WaitHandle を使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

このメソッド オーバーロードの呼び出しは、メソッド オーバーロードを呼び出し、-1 を指定するか、最初のパラメーターに を指定し、2 番目のパラメーター WaitOne(Int32, Boolean) Timeout.Infinite false にを指定するのと同じです。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

適用対象

WaitOne(Int32)

32 ビット符号付き整数を使用して時間間隔をミリ秒単位で指定し、現在の WaitHandle がシグナルを受信するまで、現在のスレッドをブロックします。

public:
 virtual bool WaitOne(int millisecondsTimeout);
public virtual bool WaitOne (int millisecondsTimeout);
abstract member WaitOne : int -> bool
override this.WaitOne : int -> bool
Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

パラメーター

millisecondsTimeout
Int32

待機するミリ秒数。無制限に待機する場合は Infinite (-1)。

戻り値

Boolean

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false。

例外

ObjectDisposedException

現在のインスタンスは既に破棄されています。

ArgumentOutOfRangeException

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。

AbandonedMutexException

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

InvalidOperationException

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

例

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が終了するまで待機している間にプロセスが終了するのを維持する方法を示しています。

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( 1000 ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(1000) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

注釈

が millisecondsTimeout 0 の場合、 メソッドはブロックしない。 待機ハンドルの状態をテストし、すぐにを返します。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、またはタイム アウトが発生するまでブロックします。 非同期操作の完了時に など、 が別のスレッドからシグナルを受信するまでブロックするには、このメソッド WaitHandle を使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

このメソッド オーバーロードの呼び出しは、 オーバーロードを呼び出 WaitOne(Int32, Boolean) し、 に を指定する場合と同 false じです exitContext 。

適用対象

WaitOne(TimeSpan)

TimeSpan を使用して時間間隔を指定し、現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。

public:
 virtual bool WaitOne(TimeSpan timeout);
public virtual bool WaitOne (TimeSpan timeout);
abstract member WaitOne : TimeSpan -> bool
override this.WaitOne : TimeSpan -> bool
Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

パラメーター

timeout
TimeSpan

待機するミリ秒数を表す TimeSpan。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan。

戻り値

Boolean

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false。

例外

ObjectDisposedException

現在のインスタンスは既に破棄されています。

ArgumentOutOfRangeException

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。 または timeout が MaxValue より大きくなっています。

AbandonedMutexException

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

InvalidOperationException

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

注釈

が timeout 0 の場合、 メソッドはブロックしない。 待機ハンドルの状態をテストし、すぐにを返します。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、またはタイム アウトが発生するまでブロックします。 非同期操作の完了時に など、 が別のスレッドからシグナルを受信するまでブロックするには、このメソッド WaitHandle を使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

の最大値は timeout です Int32.MaxValue 。

このメソッド オーバーロードの呼び出しは、 オーバーロードを呼び出 WaitOne(TimeSpan, Boolean) し、 に を指定する場合と同 false じです exitContext 。

適用対象

WaitOne(Int32, Boolean)

現在の WaitHandle がシグナルを受信するまで現在のスレッドをブロックします。時間間隔を指定するために 32 ビット符号付き整数を使用し、待機の前でも同期ドメインを終了するかどうかを指定します。

public:
 virtual bool WaitOne(int millisecondsTimeout, bool exitContext);
public virtual bool WaitOne (int millisecondsTimeout, bool exitContext);
abstract member WaitOne : int * bool -> bool
override this.WaitOne : int * bool -> bool
Public Overridable Function WaitOne (millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

パラメーター

millisecondsTimeout
Int32

待機するミリ秒数。無制限に待機する場合は Infinite (-1)。

exitContext
Boolean

待機する前にコンテキストの同期ドメインを終了し (同期されたコンテキスト内にいる場合)、後で再取得する場合は、true。それ以外の場合は false。

戻り値

Boolean

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false。

例外

ObjectDisposedException

現在のインスタンスは既に破棄されています。

ArgumentOutOfRangeException

millisecondsTimeout は無限のタイムアウトを表す -1 以外の負の数です。

AbandonedMutexException

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

InvalidOperationException

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

例

次の例は、同期ドメイン内で呼び出された WaitOne(Int32, Boolean) 場合のメソッド オーバーロードの動作を示しています。 最初に、スレッドは を に exitContext 設定して待機し、待機 false タイムアウトが期限切れになるまでブロックします。 2 番目のスレッドは、最初のスレッドが終了した後に実行され、 が に設定された exitContext で待機します true 。 この 2 番目のスレッドの待機ハンドルを示す呼び出しはブロックされません。スレッドは待機タイムアウトの前に完了します。

using namespace System;
using namespace System::Threading;
using namespace System::Runtime::Remoting::Contexts;

[Synchronization(true)]
public ref class SyncingClass : ContextBoundObject
{
private:
    EventWaitHandle^ waitHandle;

public:
    SyncingClass()
    {
         waitHandle =
            gcnew EventWaitHandle(false, EventResetMode::ManualReset);
    }

    void Signal()
    {
        Console::WriteLine("Thread[{0:d4}]: Signalling...", Thread::CurrentThread->GetHashCode());
        waitHandle->Set();
    }

    void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle->Reset();
        Console::WriteLine("Thread[{0:d4}]: Waiting...", Thread::CurrentThread->GetHashCode());
        signalled = waitHandle->WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console::WriteLine("Thread[{0:d4}]: Wait released!!!", Thread::CurrentThread->GetHashCode());
        }
        else
        {
            Console::WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread::CurrentThread->GetHashCode());
        }
    }
};

public ref class TestSyncDomainWait
{
public:
    static void Main()
    {
        SyncingClass^ syncClass = gcnew SyncingClass();

        Thread^ runWaiter;

        Console::WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitKeepContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass->Signal();
        runWaiter->Join();

        Console::WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = gcnew Thread(gcnew ParameterizedThreadStart(&TestSyncDomainWait::RunWaitLeaveContext));
        runWaiter->Start(syncClass);
        Thread::Sleep(1000);
        Console::WriteLine("Thread[{0:d4}]: Signal...", Thread::CurrentThread->GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass->Signal();
        runWaiter->Join();
    }

    static void RunWaitKeepContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(false);
    }

    static void RunWaitLeaveContext(Object^ parm)
    {
        ((SyncingClass^)parm)->DoWait(true);
    }
};

int main()
{
    TestSyncDomainWait::Main();
}
// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

Imports System.Threading
Imports System.Runtime.Remoting.Contexts

<Synchronization(true)>
Public Class SyncingClass
    Inherits ContextBoundObject
    
    Private waitHandle As EventWaitHandle

    Public Sub New()
         waitHandle = New EventWaitHandle(false, EventResetMode.ManualReset)
    End Sub

    Public Sub Signal()
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode())
        waitHandle.Set()
    End Sub

    Public Sub DoWait(leaveContext As Boolean)
        Dim signalled As Boolean

        waitHandle.Reset()
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode())
        signalled = waitHandle.WaitOne(3000, leaveContext)
        If signalled Then
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode())
        Else
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode())
        End If
    End Sub
End Class

Public Class TestSyncDomainWait
    Public Shared Sub Main()
        Dim syncClass As New SyncingClass()

        Dim runWaiter As Thread

        Console.WriteLine(Environment.NewLine + "Wait and signal INSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitKeepContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal()
        runWaiter.Join()

        Console.WriteLine(Environment.NewLine + "Wait and signal OUTSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitLeaveContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal is unblocked and will set the wait handle to
        ' release the waiting thread.
        syncClass.Signal()
        runWaiter.Join()
    End Sub

    Public Shared Sub RunWaitKeepContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(False)
    End Sub

    Public Shared Sub RunWaitLeaveContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(True)
    End Sub
End Class

' The output for the example program will be similar to the following:
'
' Wait and signal INSIDE synchronization domain:
'
' Thread[0004]: Waiting...
' Thread[0001]: Signal...
' Thread[0004]: Wait timeout!!!
' Thread[0001]: Signalling...
'
' Wait and signal OUTSIDE synchronization domain:
'
' Thread[0006]: Waiting...
' Thread[0001]: Signal...
' Thread[0001]: Signalling...
' Thread[0006]: Wait released!!!

注釈

が millisecondsTimeout 0 の場合、 メソッドはブロックしない。 待機ハンドルの状態をテストし、すぐにを返します。

AbandonedMutexExceptionは、.NET Framework バージョン 2.0 の新機能です。 以前のバージョンでは、 メソッド WaitOne はミューテックス true が破棄された場合に を返します。 破棄されたミューテックスは、多くの場合、重大なコーディング エラーを示します。 システム全体のミューテックスの場合は、アプリケーションが突然終了された場合 (たとえば、システム全体のミューテックスを使用して) Windows タスク マネージャー。 例外には、デバッグに役立つ情報が含まれている。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、またはタイム アウトが発生するまでブロックします。 非同期操作の完了時に など、 が別のスレッドからシグナルを受信するまでブロックするには、このメソッド WaitHandle を使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

コンテキストの終了に関する注意事項

既定以外のマネージド コンテキスト内から メソッドが呼び出されていない限り、 パラメーター exitContext WaitOne は効果がありません。 これは、スレッドが から派生したクラスのインスタンスの呼び出し内にある場合に発生する可能性があります ContextBoundObject 。 など、 から派生していないクラスでメソッドを現在実行している場合でも、 が現在のアプリケーション ドメイン内のスタック上にある場合は、既定以外のコンテキストに入る ContextBoundObject String ContextBoundObject 可能性があります。

コードが既定以外のコンテキストで実行されている場合、 を指定すると、スレッドはメソッドを実行する前に既定以外のマネージド コンテキスト (つまり、既定のコンテキストに遷移 true exitContext する) を終了します。 WaitOne メソッドの呼び出しが完了すると、スレッドは元の既定以外のコンテキスト WaitOne に戻されます。

これは、コンテキスト バインド クラスに が含まれる場合に便利です SynchronizationAttribute 。 その場合、クラスのメンバーに対する呼び出しはすべて自動的に同期され、同期ドメインはクラスのコードの本体全体になります。 メンバーの呼び出し履歴内のコードが メソッドを呼び出し、 に を指定すると、スレッドは同期ドメインを終了し、オブジェクトの任意のメンバーへの呼び出しでブロックされているスレッドを続行できます。 WaitOne true exitContext メソッドが WaitOne 戻った場合、呼び出しを行ったスレッドは、同期ドメインへの再入力を待機する必要があります。

適用対象

WaitOne(TimeSpan, Boolean)

現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。TimeSpan を使用して時間間隔を指定し、待機の前でも同期ドメインを終了するかどうかを指定します。

public:
 virtual bool WaitOne(TimeSpan timeout, bool exitContext);
public virtual bool WaitOne (TimeSpan timeout, bool exitContext);
abstract member WaitOne : TimeSpan * bool -> bool
override this.WaitOne : TimeSpan * bool -> bool
Public Overridable Function WaitOne (timeout As TimeSpan, exitContext As Boolean) As Boolean

パラメーター

timeout
TimeSpan

待機するミリ秒数を表す TimeSpan。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan。

exitContext
Boolean

待機する前にコンテキストの同期ドメインを終了し (同期されたコンテキスト内にいる場合)、後で再取得する場合は、true。それ以外の場合は false。

戻り値

Boolean

現在のインスタンスがシグナルを受け取る場合は true。それ以外の場合は false。

例外

ObjectDisposedException

現在のインスタンスは既に破棄されています。

ArgumentOutOfRangeException

timeout は無限のタイムアウトを表す -1 ミリ秒以外の負の数です。 または timeout が MaxValue より大きくなっています。

AbandonedMutexException

スレッドがミューテックスを解放せずに終了したため、待機が完了しました。

InvalidOperationException

別のアプリケーション ドメインでは、現在のインスタンスは WaitHandle の透過プロキシです。

例

次のコード例は、待機ハンドルを使用して、バックグラウンド スレッドの実行が終了するまで待機している間にプロセスが終了するのを維持する方法を示しています。

using namespace System;
using namespace System::Threading;
ref class WaitOne
{
private:
   WaitOne(){}


public:
   static void WorkMethod( Object^ stateInfo )
   {
      Console::WriteLine( "Work starting." );
      
      // Simulate time spent working.
      Thread::Sleep( (gcnew Random)->Next( 100, 2000 ) );
      
      // Signal that work is finished.
      Console::WriteLine( "Work ending." );
      dynamic_cast<AutoResetEvent^>(stateInfo)->Set();
   }

};

int main()
{
   Console::WriteLine( "Main starting." );
   AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &WaitOne::WorkMethod ), autoEvent );
   
   // Wait for work method to signal.
   if ( autoEvent->WaitOne( TimeSpan(0,0,1), false ) )
   {
      Console::WriteLine( "Work method signaled." );
   }
   else
   {
      Console::WriteLine( "Timed out waiting for work "
      "method to signal." );
   }

   Console::WriteLine( "Main ending." );
}

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(New TimeSpan(0, 0, 1), False) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

注釈

が timeout 0 の場合、 メソッドはブロックしない。 待機ハンドルの状態をテストし、すぐにを返します。

AbandonedMutexExceptionは、.NET Framework バージョン 2.0 の新機能です。 以前のバージョンでは、 メソッド WaitOne はミューテックス true が破棄された場合に を返します。 破棄されたミューテックスは、多くの場合、重大なコーディング エラーを示します。 システム全体のミューテックスの場合は、アプリケーションが突然終了された場合 (たとえば、システム全体のミューテックスを使用して) Windows タスク マネージャー。 例外には、デバッグに役立つ情報が含まれている。

このメソッドの呼び出し元は、現在のインスタンスがシグナルを受信するか、またはタイム アウトが発生するまでブロックします。 非同期操作の完了時に など、 が別のスレッドからシグナルを受信するまでブロックするには、このメソッド WaitHandle を使用します。 詳細については、IAsyncResult インターフェイスのトピックを参照してください。

派生クラスの動作をカスタマイズするには、このメソッドをオーバーライドします。

の最大値は timeout です Int32.MaxValue 。

コンテキストの終了に関する注意事項

既定以外のマネージド コンテキスト内から メソッドが呼び出されていない限り、 パラメーター exitContext WaitOne は効果がありません。 これは、スレッドが から派生したクラスのインスタンスの呼び出し内にある場合に発生する可能性があります ContextBoundObject 。 など、 から派生していないクラスでメソッドを現在実行している場合でも、 が現在のアプリケーション ドメイン内のスタック上にある場合は、既定以外のコンテキストに入る ContextBoundObject String ContextBoundObject 可能性があります。

コードが既定以外のコンテキストで実行されている場合、 を指定すると、スレッドはメソッドを実行する前に既定以外のマネージド コンテキスト (つまり、既定のコンテキストに遷移 true exitContext する) を終了します。 WaitOne メソッドの呼び出しが完了すると、スレッドは元の既定以外のコンテキスト WaitOne に戻されます。

これは、コンテキスト バインド クラスに が含まれる場合に便利です SynchronizationAttribute 。 その場合、クラスのメンバーに対する呼び出しはすべて自動的に同期され、同期ドメインはクラスのコードの本体全体になります。 メンバーの呼び出し履歴内のコードが メソッドを呼び出し、 に を指定すると、スレッドは同期ドメインを終了し、オブジェクトの任意のメンバーへの呼び出しでブロックされているスレッドを続行できます。 WaitOne true exitContext メソッドが WaitOne 戻った場合、呼び出しを行ったスレッドは、同期ドメインへの再入力を待機する必要があります。

適用対象