WaitHandle.WaitOne Methode

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool

Public Overridable Function WaitOne () As Boolean

Retouren

true als het huidige exemplaar een signaal ontvangt. Als het huidige exemplaar nooit wordt gesignaleerd, WaitOne() wordt nooit geretourneerd.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een wachtgreep gebruikt om te voorkomen dat een proces wordt beëindigd terwijl er wordt gewacht totdat een achtergrondthread is uitgevoerd.

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

Opmerkingen

AbandonedMutexException is nieuw in de .NET Framework-versie 2.0. In eerdere versies wordt de WaitOne methode geretourneerd true wanneer een mutex wordt verlaten. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De aanroeper van deze methode blokkeert voor onbepaalde tijd totdat het huidige exemplaar een signaal ontvangt. Gebruik deze methode om te blokkeren totdat een signaal van een WaitHandle andere thread wordt ontvangen, zoals wordt gegenereerd wanneer een asynchrone bewerking is voltooid. Zie de IAsyncResult interface voor meer informatie.

Het aanroepen van deze methodeoverbelasting komt overeen met het aanroepen van de overbelasting van de WaitOne(Int32, Boolean) methode en het opgeven van -1 of Timeout.Infinite voor de eerste parameter en false voor de tweede parameter.

Overschrijf deze methode om het gedrag van afgeleide klassen aan te passen.

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

Parameters

Retouren

true als het huidige exemplaar een signaal ontvangt; anders, false.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een wachtgreep gebruikt om te voorkomen dat een proces wordt beëindigd terwijl er wordt gewacht totdat een achtergrondthread is uitgevoerd.

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

Opmerkingen

Als millisecondsTimeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgreep getest en wordt onmiddellijk geretourneerd.

De aanroeper van deze methode blokkeert totdat het huidige exemplaar een signaal of een time-out ontvangt. Gebruik deze methode om te blokkeren totdat een signaal van een WaitHandle andere thread wordt ontvangen, zoals wordt gegenereerd wanneer een asynchrone bewerking is voltooid. Zie de IAsyncResult interface voor meer informatie.

Overschrijf deze methode om het gedrag van afgeleide klassen aan te passen.

Het aanroepen van deze methode-overbelasting is hetzelfde als het aanroepen van de WaitOne(Int32, Boolean) overbelasting en het opgeven voor falseexitContext.

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

Parameters

Retouren

true als het huidige exemplaar een signaal ontvangt; anders, false.

Uitzonderingen

Opmerkingen

Als timeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgreep getest en wordt onmiddellijk geretourneerd.

De aanroeper van deze methode blokkeert totdat het huidige exemplaar een signaal of een time-out ontvangt. Gebruik deze methode om te blokkeren totdat een signaal van een WaitHandle andere thread wordt ontvangen, zoals wordt gegenereerd wanneer een asynchrone bewerking is voltooid. Zie de IAsyncResult interface voor meer informatie.

Overschrijf deze methode om het gedrag van afgeleide klassen aan te passen.

De maximumwaarde voor timeout is Int32.MaxValue.

Het aanroepen van deze methode-overbelasting is hetzelfde als het aanroepen van de WaitOne(TimeSpan, Boolean) overbelasting en het opgeven voor falseexitContext.

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

Parameters

Retouren

true als het huidige exemplaar een signaal ontvangt; anders, false.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe de overbelasting van de WaitOne(Int32, Boolean) methode zich gedraagt wanneer deze wordt aangeroepen binnen een synchronisatiedomein. Eerst wacht een thread met exitContext ingesteld op false en blokkeert deze totdat de time-out voor de wachttijd verloopt. Een tweede thread wordt uitgevoerd nadat de eerste thread is beëindigd en wacht met exitContext ingesteld op true. De aanroep om de wachtgreep voor deze tweede thread te signaleren, wordt niet geblokkeerd en de thread wordt voltooid vóór de time-out van de wachttijd.

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

Opmerkingen

Als millisecondsTimeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgreep getest en wordt onmiddellijk geretourneerd.

Als een mutex wordt verlaten, wordt er een AbandonedMutexException gegooid. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De aanroeper van deze methode blokkeert totdat het huidige exemplaar een signaal of een time-out ontvangt. Gebruik deze methode om te blokkeren totdat een signaal van een WaitHandle andere thread wordt ontvangen, zoals wordt gegenereerd wanneer een asynchrone bewerking is voltooid. Zie de IAsyncResult interface voor meer informatie.

Overschrijf deze methode om het gedrag van afgeleide klassen aan te passen.

De context afsluiten

De exitContext parameter heeft geen effect, tenzij deze methode wordt aangeroepen vanuit een niet-standaard beheerde context. De beheerde context kan niet-standaard zijn als uw thread zich in een aanroep bevindt naar een exemplaar van een klasse die is afgeleid van ContextBoundObject. Zelfs als u momenteel een methode uitvoert op een klasse die niet is afgeleid van ContextBoundObject, zoals String, kunt u zich in een niet-standaardcontext bevinden als een ContextBoundObject is op uw stack in het huidige toepassingsdomein.

Wanneer uw code wordt uitgevoerd in een niet-standaardcontext, geeft trueexitContext u aan dat de thread de niet-standaard beheerde context verlaat (dat wil gezegd, om over te stappen op de standaardcontext) voordat deze methode wordt uitgevoerd. De thread keert terug naar de oorspronkelijke niet-standaardcontext nadat de aanroep van deze methode is voltooid.

Het afsluiten van de context kan handig zijn wanneer de contextgebonden klasse het SynchronizationAttribute kenmerk heeft. In dat geval worden alle aanroepen naar leden van de klasse automatisch gesynchroniseerd en is het synchronisatiedomein de volledige hoofdtekst van de code voor de klasse. Als code in de aanroepstack van een lid deze methode aanroept en opgeeft trueexitContext, sluit de thread het synchronisatiedomein af, waardoor een thread die wordt geblokkeerd voor een aanroep naar een lid van het object, wordt voortgezet. Wanneer deze methode wordt geretourneerd, moet de thread die de aanroep heeft gedaan wachten om het synchronisatiedomein opnieuw in te voeren.

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

Parameters

Retouren

true als het huidige exemplaar een signaal ontvangt; anders, false.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een wachtgreep gebruikt om te voorkomen dat een proces wordt beëindigd terwijl er wordt gewacht totdat een achtergrondthread is uitgevoerd.

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

Opmerkingen

Als timeout nul is, wordt de methode niet geblokkeerd. Hiermee wordt de status van de wachtgreep getest en wordt onmiddellijk geretourneerd.

Als een mutex wordt verlaten, wordt er een AbandonedMutexException gegooid. Een verlaten mutex duidt vaak op een ernstige coderingsfout. In het geval van een systeembrede mutex kan dit erop wijzen dat een toepassing plotseling is beëindigd (bijvoorbeeld met behulp van Windows Taakbeheer). De uitzondering bevat informatie die nuttig is voor foutopsporing.

De aanroeper van deze methode blokkeert totdat het huidige exemplaar een signaal of een time-out ontvangt. Gebruik deze methode om te blokkeren totdat een signaal van een WaitHandle andere thread wordt ontvangen, zoals wordt gegenereerd wanneer een asynchrone bewerking is voltooid. Zie de IAsyncResult interface voor meer informatie.

Overschrijf deze methode om het gedrag van afgeleide klassen aan te passen.

De maximumwaarde voor timeout is Int32.MaxValue.

De context afsluiten

De exitContext parameter heeft geen effect, tenzij deze methode wordt aangeroepen vanuit een niet-standaard beheerde context. De beheerde context kan niet-standaard zijn als uw thread zich in een aanroep bevindt naar een exemplaar van een klasse die is afgeleid van ContextBoundObject. Zelfs als u momenteel een methode uitvoert op een klasse die niet is afgeleid van ContextBoundObject, zoals String, kunt u zich in een niet-standaardcontext bevinden als een ContextBoundObject is op uw stack in het huidige toepassingsdomein.

Wanneer uw code wordt uitgevoerd in een niet-standaardcontext, geeft trueexitContext u aan dat de thread de niet-standaard beheerde context verlaat (dat wil gezegd, om over te stappen op de standaardcontext) voordat deze methode wordt uitgevoerd. De thread keert terug naar de oorspronkelijke niet-standaardcontext nadat de aanroep van deze methode is voltooid.

Het afsluiten van de context kan handig zijn wanneer de contextgebonden klasse het SynchronizationAttribute kenmerk heeft. In dat geval worden alle aanroepen naar leden van de klasse automatisch gesynchroniseerd en is het synchronisatiedomein de volledige hoofdtekst van de code voor de klasse. Als code in de aanroepstack van een lid deze methode aanroept en opgeeft trueexitContext, sluit de thread het synchronisatiedomein af, waardoor een thread die wordt geblokkeerd voor een aanroep naar een lid van het object, wordt voortgezet. Wanneer deze methode wordt geretourneerd, moet de thread die de aanroep heeft gedaan wachten om het synchronisatiedomein opnieuw in te voeren.