Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

WaitHandle.WaitOne-Methode: (Int32, Boolean)

 

Veröffentlicht: Oktober 2016

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.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

public virtual bool WaitOne(
	int millisecondsTimeout,
	bool exitContext
)

Parameter

millisecondsTimeout
Type: System.Int32

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

exitContext
Type: System.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.

Rückgabewert

Type: System.Boolean

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

Exception Condition
ObjectDisposedException

Die aktuelle Instanz wurde bereits verworfen.

ArgumentOutOfRangeException

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

AbandonedMutexException

Der Wartevorgang wird abgeschlossen, weil ein Thread beendet wurde, ohne ein Mutex freizugeben. Diese Ausnahme wird unter Windows 98 oder Windows Millennium Edition nicht ausgelöst.

InvalidOperationException

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

Wenn millisecondsTimeout NULL ist, wird die Methode wird nicht blockiert. Er überprüft den Status des Wait-Handle und kehrt sofort zurück.

AbandonedMutexExceptionist neu in .NET Framework, Version 2.0. In früheren Versionen der WaitOne -Methode zurückkehrt true Wenn ein Mutex abgebrochen wird. Ein abgebrochenes Mutex weist häufig einen schwerwiegenden Fehler im Code. Im Fall einer systemweiten Mutex kann dies darauf hinweisen, dass eine Anwendung plötzlich beendet wurde (z. B. mithilfe von Windows Task-Manager). Die Ausnahme enthält Informationen zum Debuggen nützlich.

Der Aufrufer diese Methode blockiert, bis die aktuelle Instanz ein Signal oder eines Timeouts empfängt auftritt. Mit dieser Methode können Sie blockieren, bis eine WaitHandle aus einem anderen Thread ein Signal empfängt, wie z. B. wird generiert, wenn ein asynchroner Vorgang abgeschlossen ist. Weitere Informationen finden Sie unter der IAsyncResult-Schnittstelle.

Überschreiben Sie diese Methode zum Anpassen des Verhaltens von abgeleiteten Klassen.

Die exitContext Parameter hat keine Auswirkungen, es sei denn, die WaitOne Methode aus, in einem nicht standardmäßigen verwalteten Kontext aufgerufen wird. Dies kann geschehen, wenn der Thread in einem Aufruf mit einer Instanz einer Klasse abgeleitet ist ContextBoundObject. Selbst wenn derzeit eine Methode einer Klasse ausgeführt werden, die nicht von abgeleitet ist ContextBoundObject, z. B. String, Sie kann in einem nicht standardmäßigen Kontext Wenn eine ContextBoundObject befindet sich auf dem Stapel in der aktuellen Anwendungsdomäne.

Beim Code in einem nicht standardmäßigen Kontext und ausgeführt wird die Angabe true für exitContext bewirkt, dass der Thread den nicht standardmäßigen verwalteten Kontext zu beenden (d. h. für den Übergang in den Standardkontext) vor dem Ausführen der WaitOne Methode. Der Thread zurück in den ursprünglich nicht standardmäßige nach dem Aufruf der WaitOne Methode abgeschlossen wird.

Dies kann nützlich sein, wenn die kontextgebundene-Klasse verfügt über SynchronizationAttribute. In diesem Fall werden alle Aufrufe von Membern der Klasse werden automatisch synchronisiert, und die Synchronisierungsdomäne ist der gesamte Text der Code für die Klasse. Wenn Code in der Aufrufliste eines Members Ruft die WaitOne Methode und gibt an, true für exitContext, der Thread beendet wird, die Synchronisierungsdomäne ermöglicht einen Thread, der bei einem Aufruf auf einen Member des Objekts zu fortfahren blockiert wird. Wenn die WaitOne Methode zurückgegeben wird, der Thread, der der Aufruf muss warten, um die Synchronisierungsdomäne.

Das folgende Beispiel zeigt wie die WaitOne(Int32, Boolean) methodenüberladung verhält sich, wenn sie innerhalb einer Synchronisierungsdomäne aufgerufen wird. Zunächst wartet ein Thread mit exitContext festgelegt false und blockiert, bis das Zeitlimit abgelaufen ist. Ein zweiter Thread ausgeführt wird, nachdem der erste Thread beendet und wartet mit exitContext festgelegt true. Der Aufruf von signalisieren das Wait-Handle für diesen zweiten Thread wird nicht blockiert, und der Thread abgeschlossen ist, bevor das Wartetimeout.

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

.NET Framework
Verfügbar seit 1.1
Zurück zum Anfang
Anzeigen: