WaitHandle.WaitOne Methode

Definition

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.Blocks the current thread until the current WaitHandle receives a signal.

Überlädt

WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.Blocks the current thread until the current WaitHandle receives a signal.

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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.Blocks the current thread until the current WaitHandle receives a signal.

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.true if the current instance receives a signal. Wenn die aktuelle Instanz kein Signal erhält, wird WaitOne(Int32, Boolean) nicht beendet.If the current instance is never signaled, WaitOne(Int32, Boolean) never returns.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.The current instance has already been disposed.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The current instance is a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie ein Wait-Handle verwendet wird, um einen Prozess vom beenden beizubehalten, während er darauf wartet, dass ein Hintergrund Thread die Ausführung beendet.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

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

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitOne-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitOne method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Der Aufrufer dieser Methode blockiert unbegrenzt, bis die aktuelle Instanz ein Signal empfängt.The caller of this method blocks indefinitely until the current instance receives a signal. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. b. wird generiert, wenn ein asynchroner Vorgang abgeschlossen wird.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.For more information, see the IAsyncResult interface.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der WaitOne(Int32, Boolean)-Methoden Überladung und der Angabe von "-1" oder Timeout.Infinite für den ersten Parameter und false für den zweiten Parameter.Calling this method overload is equivalent to calling the WaitOne(Int32, Boolean) method overload and specifying -1 or Timeout.Infinite for the first parameter and false for the second parameter.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.Override this method to customize the behavior of derived classes.

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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

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.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.true if the current instance receives a signal; otherwise, false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.The current instance has already been disposed.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The current instance is a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie ein Wait-Handle verwendet wird, um einen Prozess vom beenden beizubehalten, während er darauf wartet, dass ein Hintergrund Thread die Ausführung beendet.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

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 0 (null) ist, wird die-Methode nicht blockiert.If millisecondsTimeout is zero, the method does not block. Es testet den Zustand des Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handle and returns immediately.

Der Aufrufer dieser Methode blockiert, bis die aktuelle Instanz ein Signal empfängt oder ein Timeout auftritt.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. b. wird generiert, wenn ein asynchroner Vorgang abgeschlossen wird.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.For more information, see the IAsyncResult interface.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.Override this method to customize the behavior of derived classes.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der Überladung WaitOne(Int32, Boolean) und der Angabe von false für exitContext.Calling this method overload is the same as calling the WaitOne(Int32, Boolean) overload and specifying false for exitContext.

WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

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.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.true if the current instance receives a signal; otherwise, false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.The current instance has already been disposed.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - oder --or- timeout ist größer als MaxValue.timeout is greater than MaxValue.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The current instance is a transparent proxy for a WaitHandle in another application domain.

Hinweise

Wenn timeout 0 (null) ist, wird die-Methode nicht blockiert.If timeout is zero, the method does not block. Es testet den Zustand des Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handle and returns immediately.

Der Aufrufer dieser Methode blockiert, bis die aktuelle Instanz ein Signal empfängt oder ein Timeout auftritt.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. b. wird generiert, wenn ein asynchroner Vorgang abgeschlossen wird.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.For more information, see the IAsyncResult interface.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.Override this method to customize the behavior of derived classes.

Der Höchstwert für timeout ist Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Das Aufrufen dieser Methoden Überladung entspricht dem Aufrufen der Überladung WaitOne(TimeSpan, Boolean) und der Angabe von false für exitContext.Calling this method overload is the same as calling the WaitOne(TimeSpan, Boolean) overload and specifying false for exitContext.

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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

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.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

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.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.true if the current instance receives a signal; otherwise, false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.The current instance has already been disposed.

millisecondsTimeout ist eine negative Zahl, jedoch nicht -1, was einen unbeschränkten Timeout darstellt.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The current instance is a transparent proxy for a WaitHandle in another application domain.

Beispiele

Das folgende Beispiel zeigt, wie sich die WaitOne(Int32, Boolean)-Methoden Überladung verhält, wenn Sie innerhalb einer Synchronisierungs Domäne aufgerufen wird.The following example shows how the WaitOne(Int32, Boolean) method overload behaves when it is called within a synchronization domain. Zuerst wartet ein Thread, dass exitContext auf false festgelegt ist, und blockiert, bis das warte Timeout abläuft.First, a thread waits with exitContext set to false and blocks until the wait timeout expires. Ein zweiter Thread wird ausgeführt, nachdem der erste Thread beendet wurde, und wartet, bis exitContext auf true festgelegt ist.A second thread executes after the first thread terminates and waits with exitContext set to true. Der-Befehl, der das Wait-Handle für diesen zweiten Thread signalisiert, wird nicht blockiert, und der Thread wird vor dem warte Timeout abgeschlossen.The call to signal the wait handle for this second thread is not blocked, and the thread completes before the wait timeout.

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(vbNewLine + "Wait and signal INSIDE synchronization domain:" + vbNewLine)
        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(vbNewLine + "Wait and signal OUTSIDE synchronization domain:" + vbNewLine)
        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 0 (null) ist, wird die-Methode nicht blockiert.If millisecondsTimeout is zero, the method does not block. Es testet den Zustand des Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handle and returns immediately.

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitOne-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitOne method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Der Aufrufer dieser Methode blockiert, bis die aktuelle Instanz ein Signal empfängt oder ein Timeout auftritt.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. b. wird generiert, wenn ein asynchroner Vorgang abgeschlossen wird.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.For more information, see the IAsyncResult interface.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.Override this method to customize the behavior of derived classes.

Hinweise zum Beenden des KontextsNotes on Exiting the Context

Der exitContext-Parameter hat keine Auswirkung, es sei denn, die WaitOne-Methode wird von einem nicht standardmäßigen verwalteten Kontext aus aufgerufen.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Dies kann vorkommen, wenn sich der Thread innerhalb eines Aufrufes einer Instanz einer Klasse befindet, die von ContextBoundObject abgeleitet ist.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject abgeleitet ist, z. b. String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in der aktuellen Anwendungsdomäne auf dem Stapel befindet.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe von true für exitContext, dass der Thread den nicht standardmäßigen verwalteten Kontext (d. h. den Übergang zum Standardkontext) beendet, bevor die WaitOne-Methode ausgeführt wird.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 WaitOne method. Der Thread kehrt in den ursprünglichen nicht standardmäßigen Kontext zurück, nachdem der aufzurufende WaitOne-Methode abgeschlossen wurde.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Dies kann nützlich sein, wenn die Kontext gebundene Klasse SynchronizationAttribute hat.This can be useful when the context-bound class has SynchronizationAttribute. In diesem Fall werden alle Aufrufe an Member der-Klasse automatisch synchronisiert, und die Synchronisierungs Domäne ist der gesamte Code Körper für die-Klasse.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. Wenn Code in der Aufruf Stapel eines Members die WaitOne-Methode aufruft und true für exitContext angibt, beendet der Thread die Synchronisierungs Domäne, sodass ein Thread, der bei einem Aufruf von einem beliebigen Member des Objekts blockiert ist, fortgesetzt werden kann.If code in the call stack of a member calls the WaitOne 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. Wenn die WaitOne-Methode zurückgibt, muss der Thread, der den-Befehl erstellt hat, warten, bis die Synchronisierungs Domäne erneut eingegeben wird.When the WaitOne method returns, the thread that made the call must wait to reenter the synchronization domain.

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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

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.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

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.true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, false.

Gibt zurück

true, wenn die aktuelle Instanz ein Signal empfängt, andernfalls false.true if the current instance receives a signal; otherwise, false.

Ausnahmen

Die aktuelle Instanz wurde bereits verworfen.The current instance has already been disposed.

timeout ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - oder --or- timeout ist größer als MaxValue.timeout is greater than MaxValue.

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben.The wait completed because a thread exited without releasing a mutex. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.This exception is not thrown on Windows 98 or Windows Millennium Edition.

Die aktuelle Instanz ist ein transparenter Proxy für ein WaitHandle in einer anderen Anwendungsdomäne.The current instance is a transparent proxy for a WaitHandle in another application domain.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie ein Wait-Handle verwendet wird, um einen Prozess vom beenden beizubehalten, während er darauf wartet, dass ein Hintergrund Thread die Ausführung beendet.The following code example shows how to use a wait handle to keep a process from terminating while it waits for a background thread to finish executing.

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 0 (null) ist, wird die-Methode nicht blockiert.If timeout is zero, the method does not block. Es testet den Zustand des Wait-Handles und wird sofort zurückgegeben.It tests the state of the wait handle and returns immediately.

AbandonedMutexException ist neu in .NET Framework Version 2,0.AbandonedMutexException is new in the .NET Framework version 2.0. In früheren Versionen gibt die WaitOne-Methode true zurück, wenn ein Mutex abgebrochen wird.In previous versions, the WaitOne method returns true when a mutex is abandoned. Ein abgebrochener Mutex zeigt häufig einen schwerwiegenden Codierungsfehler an.An abandoned mutex often indicates a serious coding error. Im Fall eines systemweiten Mutex kann dies darauf hindeuten, dass eine Anwendung abrupt beendet wurde (z. b. mithilfe des Windows Task-Managers).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). Die Ausnahme enthält Informationen, die beim Debuggen hilfreich sindThe exception contains information useful for debugging.

Der Aufrufer dieser Methode blockiert, bis die aktuelle Instanz ein Signal empfängt oder ein Timeout auftritt.The caller of this method blocks until the current instance receives a signal or a time-out occurs. Verwenden Sie diese Methode, um zu blockieren, bis ein WaitHandle ein Signal von einem anderen Thread empfängt, z. b. wird generiert, wenn ein asynchroner Vorgang abgeschlossen wird.Use this method to block until a WaitHandle receives a signal from another thread, such as is generated when an asynchronous operation completes. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.For more information, see the IAsyncResult interface.

Überschreiben Sie diese Methode, um das Verhalten abgeleiteter Klassen anzupassen.Override this method to customize the behavior of derived classes.

Der Höchstwert für timeout ist Int32.MaxValue.The maximum value for timeout is Int32.MaxValue.

Hinweise zum Beenden des KontextsNotes on Exiting the Context

Der exitContext-Parameter hat keine Auswirkung, es sei denn, die WaitOne-Methode wird von einem nicht standardmäßigen verwalteten Kontext aus aufgerufen.The exitContext parameter has no effect unless the WaitOne method is called from inside a nondefault managed context. Dies kann vorkommen, wenn sich der Thread innerhalb eines Aufrufes einer Instanz einer Klasse befindet, die von ContextBoundObject abgeleitet ist.This can happen if your thread is inside a call to an instance of a class derived from ContextBoundObject. Auch wenn Sie derzeit eine Methode für eine Klasse ausführen, die nicht von ContextBoundObject abgeleitet ist, z. b. String, können Sie sich in einem nicht standardmäßigen Kontext befinden, wenn sich ein ContextBoundObject in der aktuellen Anwendungsdomäne auf dem Stapel befindet.Even if you are currently executing a method on a class that does not derive from ContextBoundObject, like String, you can be in a nondefault context if a ContextBoundObject is on your stack in the current application domain.

Wenn Ihr Code in einem nicht standardmäßigen Kontext ausgeführt wird, bewirkt die Angabe von true für exitContext, dass der Thread den nicht standardmäßigen verwalteten Kontext (d. h. den Übergang zum Standardkontext) beendet, bevor die WaitOne-Methode ausgeführt wird.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 WaitOne method. Der Thread kehrt in den ursprünglichen nicht standardmäßigen Kontext zurück, nachdem der aufzurufende WaitOne-Methode abgeschlossen wurde.The thread returns to the original nondefault context after the call to the WaitOne method completes.

Dies kann nützlich sein, wenn die Kontext gebundene Klasse SynchronizationAttribute hat.This can be useful when the context-bound class has SynchronizationAttribute. In diesem Fall werden alle Aufrufe an Member der-Klasse automatisch synchronisiert, und die Synchronisierungs Domäne ist der gesamte Code Körper für die-Klasse.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. Wenn Code in der Aufruf Stapel eines Members die WaitOne-Methode aufruft und true für exitContext angibt, beendet der Thread die Synchronisierungs Domäne, sodass ein Thread, der bei einem Aufruf von einem beliebigen Member des Objekts blockiert ist, fortgesetzt werden kann.If code in the call stack of a member calls the WaitOne 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. Wenn die WaitOne-Methode zurückgibt, muss der Thread, der den-Befehl erstellt hat, warten, bis die Synchronisierungs Domäne erneut eingegeben wird.When the WaitOne method returns, the thread that made the call must wait to reenter the synchronization domain.

Gilt für: