WaitHandle.WaitOne Methode

Definition

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.

Überlädt

WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.

WaitOne(Int32)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird.

WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.

WaitOne(Int32, Boolean)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

WaitOne(TimeSpan, Boolean)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.

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

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt. Wenn die aktuelle Instanz kein Signal erhält, wird WaitOne() nicht beendet.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie ein Wartehandle verwenden, um das Beenden eines Prozesses zu hindern, während er auf den Abschluss der Ausführung eines Hintergrundthreads wartet.

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

Hinweise

AbandonedMutexExceptionist neu in .NET Framework Version 2.0. In früheren Versionen gibt die WaitOne Methode zurück true , wenn ein Mutex abgebrochen wird. Ein aufgegebener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Bei einem systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen nützlich sind.

Der Aufrufer dieser Methode blockiert unbegrenzt, bis der aktuelle instance ein Signal empfängt. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle Signal von einem anderen Thread empfängt, z. B. beim Abschluss eines asynchronen Vorgangs. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Das Aufrufen dieser Methodenüberladung entspricht dem Aufrufen der WaitOne(Int32, Boolean) Methodenüberladung und dem Angeben von -1 oder Timeout.Infinite für den ersten Parameter und false für den zweiten Parameter.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.

Gilt für:

WaitOne(Int32)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird.

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

Parameter

millisecondsTimeout
Int32

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie ein Wartehandle verwenden, um das Beenden eines Prozesses zu hindern, während er auf den Abschluss der Ausführung eines Hintergrundthreads wartet.

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

Hinweise

Wenn millisecondsTimeout null ist, wird die -Methode nicht blockiert. Er testet den Zustand des Wartehandles und gibt sofort zurück.

Der Aufrufer dieser Methode blockiert, bis der aktuelle instance ein Signal empfängt oder ein Timeout auftritt. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle Signal von einem anderen Thread empfängt, z. B. beim Abschluss eines asynchronen Vorgangs. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.

Das Aufrufen dieser Methodenüberladung ist identisch mit dem Aufrufen der WaitOne(Int32, Boolean) Überladung und angeben false für exitContext.

Gilt für:

WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.

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

Parameter

timeout
TimeSpan

Eine TimeSpan-Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine TimeSpan-Struktur, die -1 Millisekunden zum unendlichen Warten angibt.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.

- oder -

timeout ist größer als Int32.MaxValue.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.

Hinweise

Wenn timeout null ist, wird die -Methode nicht blockiert. Er testet den Zustand des Wartehandles und gibt sofort zurück.

Der Aufrufer dieser Methode blockiert, bis der aktuelle instance ein Signal empfängt oder ein Timeout auftritt. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle Signal von einem anderen Thread empfängt, z. B. beim Abschluss eines asynchronen Vorgangs. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.

Der Maximalwert für timeout ist Int32.MaxValue.

Das Aufrufen dieser Methodenüberladung ist identisch mit dem Aufrufen der WaitOne(TimeSpan, Boolean) Überladung und angeben false für exitContext.

Gilt für:

WaitOne(Int32, Boolean)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

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

Parameter

millisecondsTimeout
Int32

Die Anzahl von Millisekunden, die gewartet wird, oder Infinite (-1) für Warten ohne Timeout.

exitContext
Boolean

true, um die Synchronisierungsdomäne für den Kontext vor dem Wartevorgang (sofern in einem synchronisierten Kontext) zu verlassen und diese anschließend erneut abzurufen, andernfalls false.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.

Beispiele

Das folgende Beispiel zeigt, wie sich die WaitOne(Int32, Boolean) Methodenüberladung verhält, wenn sie innerhalb einer Synchronisierungsdomäne aufgerufen wird. Zunächst wartet ein Thread mit exitContext festgelegt auf und blockiert, false bis das Wartezeittimeout abläuft. Ein zweiter Thread wird ausgeführt, nachdem der erste Thread beendet wurde, und wartet mit exitContext festgelegt auf true. Der Aufruf zum Signalisieren des Wartehandles für diesen zweiten Thread wird nicht blockiert, und der Thread wird vor dem Wartezeittimeout abgeschlossen.

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

Hinweise

Wenn millisecondsTimeout null ist, wird die -Methode nicht blockiert. Er testet den Zustand des Wartehandles und gibt sofort zurück.

Wenn ein Mutex verlassen wird, wird ein AbandonedMutexException ausgelöst. Ein aufgegebener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Bei einem systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen nützlich sind.

Der Aufrufer dieser Methode blockiert, bis der aktuelle instance ein Signal empfängt oder ein Timeout auftritt. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle Signal von einem anderen Thread empfängt, z. B. beim Abschluss eines asynchronen Vorgangs. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.

Beenden des Kontexts

Der exitContext -Parameter hat keine Auswirkung, es sei denn, diese Methode wird aus einem nicht standardmäßig verwalteten Kontext aufgerufen. Der verwaltete Kontext kann nicht standardmäßig sein, wenn sich Ihr Thread in einem Aufruf eines instance einer klasse befindet, die von ContextBoundObjectabgeleitet wird. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObjectabgeleitet ist, wie String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in Ihrem Stapel in der aktuellen Anwendungsdomäne befindet.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe true von für exitContext , dass der Thread den nicht standardmäßig verwalteten Kontext beendet (d. h. zum Übergang in den Standardkontext), bevor diese Methode ausgeführt wird. Der Thread kehrt zum ursprünglichen nicht standardmäßigen Kontext zurück, nachdem der Aufruf dieser Methode abgeschlossen wurde.

Das Beenden des Kontexts kann nützlich sein, wenn die kontextgebundene Klasse über das SynchronizationAttribute -Attribut verfügt. In diesem Fall werden alle Aufrufe von Membern der -Klasse automatisch synchronisiert, und die Synchronisierungsdomäne ist der gesamte Codetext der Klasse. Wenn Code im Aufrufstapel eines Members diese Methode aufruft und für exitContextangibttrue, beendet der Thread die Synchronisierungsdomäne, sodass ein Thread, der bei einem Aufruf eines beliebigen Elements des -Objekts blockiert wird, fortfahren kann. Wenn diese Methode zurückgibt, muss der Thread, der den Aufruf ausgeführt hat, warten, um wieder in die Synchronisierungsdomäne zu wechseln.

Gilt für:

WaitOne(TimeSpan, Boolean)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

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

Parameter

timeout
TimeSpan

Eine TimeSpan-Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine TimeSpan-Struktur, die -1 Millisekunden zum unendlichen Warten angibt.

exitContext
Boolean

true, um die Synchronisierungsdomäne für den Kontext vor dem Wartevorgang (sofern in einem synchronisierten Kontext) zu verlassen und diese anschließend erneut abzurufen, andernfalls false.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.

- oder -

timeout ist größer als Int32.MaxValue.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie ein Wartehandle verwenden, um das Beenden eines Prozesses zu hindern, während er auf den Abschluss der Ausführung eines Hintergrundthreads wartet.

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

Hinweise

Wenn timeout null ist, wird die -Methode nicht blockiert. Er testet den Status des Wartehandles und gibt sofort zurück.

Wenn ein Mutex abgebrochen wird, wird ein AbandonedMutexException ausgelöst. Ein verlassener Mutex weist häufig auf einen schwerwiegenden Codierungsfehler hin. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. B. mithilfe des Windows Task-Managers). Die Ausnahme enthält Informationen, die für das Debuggen nützlich sind.

Der Aufrufer dieser Methode blockiert, bis der aktuelle instance ein Signal empfängt oder ein Timeout auftritt. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. B. generiert wird, wenn ein asynchroner Vorgang abgeschlossen ist. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.

Der Maximalwert für timeout ist Int32.MaxValue.

Beenden des Kontexts

Der exitContext Parameter hat keine Auswirkung, es sei denn, diese Methode wird aus einem nicht standardmäßig verwalteten Kontext aufgerufen. Der verwaltete Kontext kann nicht standardmäßig sein, wenn sich Ihr Thread innerhalb eines Aufrufs einer instance einer von ContextBoundObjectabgeleiteten Klasse befindet. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObjectabgeleitet ist, wie String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in Der aktuellen Anwendungsdomäne in Ihrem Stapel befindet.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe true von für exitContext , dass der Thread den verwalteten Nicht-Standardkontext (d. h. den Übergang in den Standardkontext) verlässt, bevor diese Methode ausgeführt wird. Der Thread kehrt zum ursprünglichen Nicht-Standardkontext zurück, nachdem der Aufruf dieser Methode abgeschlossen ist.

Das Beenden des Kontexts kann nützlich sein, wenn die kontextgebundene Klasse über das SynchronizationAttribute -Attribut verfügt. In diesem Fall werden alle Aufrufe von Membern der -Klasse automatisch synchronisiert, und die Synchronisierungsdomäne ist der gesamte Codetext für die Klasse. Wenn Code in der Aufrufliste eines Members diese Methode aufruft und für exitContextangibttrue, verlässt der Thread die Synchronisierungsdomäne. Dadurch kann ein Thread, der bei einem Aufruf eines beliebigen Elements des Objekts blockiert wird, fortgesetzt werden. Wenn diese Methode zurückgibt, muss der Thread, der den Aufruf ausgeführt hat, warten, bis die Synchronisierungsdomäne erneut aufgerufen wird.

Gilt für: