WaitHandle.WaitOne Metódus

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

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

Public Overridable Function WaitOne () As Boolean

Válaszok

true ha az aktuális példány jelet kap. Ha az aktuális példány soha nem lesz jelezve, WaitOne() soha nem tér vissza.

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet várakozási fogópontot használni, hogy a folyamat ne fejeződjön be, amíg egy háttérszál befejeződik.

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

Megjegyzések

AbandonedMutexException a .NET Framework 2.0-s verziójában új. A korábbi verziókban a WaitOne metódus a mutex elhagyásakor ad vissza true . Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A metódus hívója határozatlan ideig blokkolja, amíg az aktuális példány nem kap jelet. Ezzel a módszerrel blokkolhatja, amíg egy WaitHandle másik száltól nem kap jelet, például amikor egy aszinkron művelet befejeződik. További információ: IAsyncResult felület.

A metódus túlterhelésének meghívása egyenértékű a metódus túlterhelésének meghívásával, valamint a WaitOne(Int32, Boolean) -1 vagy Timeout.Infinite az első paraméter és false a második paraméter megadásával.

A metódus felülbírálása a származtatott osztályok viselkedésének testreszabásához.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

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

Paraméterek

Válaszok

trueha az aktuális példány jelet kap; egyéb esetben. false

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet várakozási fogópontot használni, hogy a folyamat ne fejeződjön be, amíg egy háttérszál befejeződik.

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

Megjegyzések

Ha millisecondsTimeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópont állapotát, és azonnal visszatér.

A metódus hívója addig blokkolja a hívót, amíg az aktuális példány nem kap jelet, vagy időtúllépés történik. Ezzel a módszerrel blokkolhatja, amíg egy WaitHandle másik száltól nem kap jelet, például amikor egy aszinkron művelet befejeződik. További információ: IAsyncResult felület.

A metódus felülbírálása a származtatott osztályok viselkedésének testreszabásához.

A metódus túlterhelésének meghívása ugyanaz, mint a WaitOne(Int32, Boolean) túlterhelés meghívása falseexitContext és a túlterhelés megadása.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

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

Paraméterek

Válaszok

trueha az aktuális példány jelet kap; egyéb esetben. false

Kivételek

Megjegyzések

Ha timeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópont állapotát, és azonnal visszatér.

A metódus hívója addig blokkolja a hívót, amíg az aktuális példány nem kap jelet, vagy időtúllépés történik. Ezzel a módszerrel blokkolhatja, amíg egy WaitHandle másik száltól nem kap jelet, például amikor egy aszinkron művelet befejeződik. További információ: IAsyncResult felület.

A metódus felülbírálása a származtatott osztályok viselkedésének testreszabásához.

A maximális érték az timeout .Int32.MaxValue

A metódus túlterhelésének meghívása ugyanaz, mint a WaitOne(TimeSpan, Boolean) túlterhelés meghívása falseexitContext és a túlterhelés megadása.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

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

Paraméterek

Válaszok

trueha az aktuális példány jelet kap; egyéb esetben. false

Kivételek

Példák

Az alábbi példa bemutatja, hogyan viselkedik a WaitOne(Int32, Boolean) metódus túlterhelése, amikor egy szinkronizálási tartományon belül hívják meg. Először egy szál a várakozási exitContext időkorlát lejáratáig várakozikfalse, és letiltja azt. A második szál az első szál leállása után fut, és a exitContext következőre van állítva true: . A második szál várakozási fogópontjának jelzésére szolgáló hívás nincs blokkolva, és a szál a várakozási időkorlát előtt befejeződik.

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

Megjegyzések

Ha millisecondsTimeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópont állapotát, és azonnal visszatér.

Ha egy mutex elhagyatott, egy AbandonedMutexException dobni. Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A metódus hívója addig blokkolja a hívót, amíg az aktuális példány nem kap jelet, vagy időtúllépés történik. Ezzel a módszerrel blokkolhatja, amíg egy WaitHandle másik száltól nem kap jelet, például amikor egy aszinkron művelet befejeződik. További információ: IAsyncResult felület.

A metódus felülbírálása a származtatott osztályok viselkedésének testreszabásához.

Kilépés a környezetből

A exitContext paraméternek nincs hatása, hacsak ezt a metódust nem egy nem megbízható felügyelt környezetből hívja meg. A felügyelt környezet nem lehet hibás, ha a szál egy, a forrásból ContextBoundObjectszármaztatott osztály egy példányának hívásán belül van. Még akkor is, ha egy olyan osztályon hajt végre metódust, amely nem származik ContextBoundObjectpéldául Stringabból, akkor is lehet nem megfelelő környezetben, ha egy ContextBoundObject az aktuális alkalmazástartományban található a veremen.

Ha a kód nem megfelelő környezetben fut, a metódus végrehajtása előtt meg kell adnia trueexitContext , hogy a szál kilép-e a nemdefault felügyelt környezetből (vagyis áttér az alapértelmezett környezetre). A szál a metódus hívásának befejeződése után visszatér az eredeti nem megfelelő környezethez.

A környezetből való kilépés akkor lehet hasznos, ha a környezethez kötött osztály rendelkezik az SynchronizationAttribute attribútummal. Ebben az esetben a rendszer automatikusan szinkronizálja az osztály tagjaihoz intézett összes hívást, és a szinkronizálási tartomány az osztály kódjának teljes törzse. Ha egy tag hívási vermében lévő kód meghívja ezt a metódust, és megadja trueexitContextazt, a szál kilép a szinkronizálási tartományból, ami lehetővé teszi, hogy az objektum bármely tagjára irányuló hívás során blokkolt szál folytassa a műveletet. Amikor ez a metódus visszatér, a hívást kezdeményező szálnak várnia kell a szinkronizálási tartomány újraküldésére.

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

Forrás:

WaitHandle.cs

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

Paraméterek

Válaszok

trueha az aktuális példány jelet kap; egyéb esetben. false

Kivételek

Példák

Az alábbi példakód bemutatja, hogyan lehet várakozási fogópontot használni, hogy a folyamat ne fejeződjön be, amíg egy háttérszál befejeződik.

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

Megjegyzések

Ha timeout nulla, a metódus nem blokkolja a elemet. Teszteli a várakozási fogópont állapotát, és azonnal visszatér.

Ha egy mutex elhagyatott, egy AbandonedMutexException dobni. Az elhagyott mutex gyakran komoly kódolási hibát jelez. Rendszerszintű mutex esetén azt jelezheti, hogy egy alkalmazás hirtelen leállt (például Windows Task Manager használatával). A kivétel a hibakereséshez hasznos információkat tartalmaz.

A metódus hívója addig blokkolja a hívót, amíg az aktuális példány nem kap jelet, vagy időtúllépés történik. Ezzel a módszerrel blokkolhatja, amíg egy WaitHandle másik száltól nem kap jelet, például amikor egy aszinkron művelet befejeződik. További információ: IAsyncResult felület.

A metódus felülbírálása a származtatott osztályok viselkedésének testreszabásához.

A maximális érték az timeout .Int32.MaxValue

Kilépés a környezetből

A exitContext paraméternek nincs hatása, hacsak ezt a metódust nem egy nem megbízható felügyelt környezetből hívja meg. A felügyelt környezet nem lehet hibás, ha a szál egy, a forrásból ContextBoundObjectszármaztatott osztály egy példányának hívásán belül van. Még akkor is, ha egy olyan osztályon hajt végre metódust, amely nem származik ContextBoundObjectpéldául Stringabból, akkor is lehet nem megfelelő környezetben, ha egy ContextBoundObject az aktuális alkalmazástartományban található a veremen.

Ha a kód nem megfelelő környezetben fut, a metódus végrehajtása előtt meg kell adnia trueexitContext , hogy a szál kilép-e a nemdefault felügyelt környezetből (vagyis áttér az alapértelmezett környezetre). A szál a metódus hívásának befejeződése után visszatér az eredeti nem megfelelő környezethez.

A környezetből való kilépés akkor lehet hasznos, ha a környezethez kötött osztály rendelkezik az SynchronizationAttribute attribútummal. Ebben az esetben a rendszer automatikusan szinkronizálja az osztály tagjaihoz intézett összes hívást, és a szinkronizálási tartomány az osztály kódjának teljes törzse. Ha egy tag hívási vermében lévő kód meghívja ezt a metódust, és megadja trueexitContextazt, a szál kilép a szinkronizálási tartományból, ami lehetővé teszi, hogy az objektum bármely tagjára irányuló hívás során blokkolt szál folytassa a műveletet. Amikor ez a metódus visszatér, a hívást kezdeményező szálnak várnia kell a szinkronizálási tartomány újraküldésére.