Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

WaitOrTimerCallback-Delegat

Aktualisiert: November 2007

Stellt eine Methode dar, die aufgerufen werden soll, wenn ein Signal an ein WaitHandle gesendet wird oder dessen Timeout überschritten ist.

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

[ComVisibleAttribute(true)]
public delegate void WaitOrTimerCallback(
	Object state,
	bool timedOut
)
/** @delegate */
/** @attribute ComVisibleAttribute(true) */
public delegate void WaitOrTimerCallback(
	Object state,
	boolean timedOut
)
JScript unterstützt keine Delegaten.

Parameter

state
Typ: System.Object
Ein Objekt mit den Informationen, die von der Rückrufmethode bei jeder Ausführung verwendet werden.
timedOut
Typ: System.Boolean
true, wenn das Timeout für WaitHandle überschritten ist, false, wenn ein Signal gesendet wurde.

WaitOrTimerCallback stellt eine Rückrufmethode dar, die ausgeführt werden soll, wenn das Timeout für ein registriertes WaitHandle überschritten ist oder ein Signal an dieses gesendet wird. Erstellen Sie den Delegaten, indem Sie die Rückrufmethode an den WaitOrTimerCallback-Konstruktor übergeben. Die Methode muss über die hier dargestellte Signatur verfügen.

Erstellen Sie das registrierte WaitHandle, indem Sie den WaitOrTimerCallback-Delegaten und ein WaitHandle an ThreadPool.RegisterWaitForSingleObject übergeben. Die Rückrufmethode wird bei jedem Timeout des WaitHandle oder bei jedem Senden eines Signals an dieses ausgeführt.

vb#
asx62c66.alert_note(de-de,VS.90).gifHinweis:

Benutzer von Visual Basic können den WaitOrTimerCallback-Konstruktor auslassen und stattdessen beim Übergeben der Rückrufmethode an RegisterWaitForSingleObject den AddressOf-Operator verwenden. Visual Basic ruft automatisch den richtigen Delegatkonstruktor auf.

Wenn Sie Informationen an die Rückrufmethode übergeben möchten, erstellen Sie ein Objekt mit den erforderlichen Informationen und übergeben es beim Erstellen des registrierten WaitHandles an RegisterWaitForSingleObject. Bei jeder Ausführung der Rückrufmethode enthält der state-Parameter dieses Objekt.

Weitere Informationen über die Verwendung von Rückrufmethoden zum Synchronisieren von Threadpoolthreads finden Sie unter Verwalteter Threadpool.

Im folgenden Beispiel wird veranschaulicht, wie mit dem WaitOrTimerCallback-Delegaten eine Rückrufmethode dargestellt wird, die bei der Signalisierung eines WaitHandles ausgeführt wird.

Das Beispiel zeigt außerdem, wie die RegisterWaitForSingleObject-Methode verwendet wird, um eine angegebene Rückrufmethode auszuführen, sobald ein angegebenes WaitHandle signalisiert wird. In diesem Beispiel ist die Rückrufmethode WaitProc, und das WaitHandle ist ein AutoResetEvent.

Im Beispiel wird eine TaskInfo-Klasse definiert, um die an den Rückruf übergebenen Informationen bei der Ausführung zu speichern. Im Beispiel wird ein TaskInfo-Objekt erstellt. Dem Objekt werden einige Zeichenfolgendaten zugewiesen. Das RegisteredWaitHandle, das von der RegisterWaitForSingleObject-Methode zurückgegeben wird, wird dem Handle-Feld des TaskInfo-Objekts zugewiesen, sodass die Rückrufmethode auf das RegisteredWaitHandle zugreifen kann.

Zusätzlich zum TaskInfo-Objekt gibt der Aufruf der RegisterWaitForSingleObject-Methode das AutoResetEvent, auf das die Aufgabe warten soll, einen WaitOrTimerCallback-Delegaten, der die WaitProc-Rückrufmethode darstellt, ein Timeoutintervall von einer Sekunde sowie mehrere Rückrufe an.

Sobald der Hauptthread das AutoResetEvent durch einen Aufruf seiner Set-Methode signalisiert, wird der WaitOrTimerCallback-Delegat aufgerufen. Die WaitProc-Methode testet RegisteredWaitHandle, um zu bestimmen, ob ein Timeout aufgetreten ist. Wenn der Rückruf aufgerufen wurde, weil das WaitHandle signalisiert wurde, hebt die WaitProc-Methode die Registrierung von RegisteredWaitHandle auf und stoppt so weitere Rückrufe. Im Fall eines Timeouts wartet die Aufgabe weiter. Die WaitProc-Methode endet und gibt eine Meldung in der Konsole aus.

using System;
using System.Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public class TaskInfo {
    public RegisteredWaitHandle Handle = null;
    public string OtherInfo = "default";
}

public class Example {
    public static void Main(string[] args) {
        // The main thread uses AutoResetEvent to signal the
        // registered wait handle, which executes the callback
        // method.
        AutoResetEvent ev = new AutoResetEvent(false);

        TaskInfo ti = new TaskInfo();
        ti.OtherInfo = "First task";
        // The TaskInfo for the task includes the registered wait
        // handle returned by RegisterWaitForSingleObject.  This
        // allows the wait to be terminated when the object has
        // been signaled once (see WaitProc).
        ti.Handle = ThreadPool.RegisterWaitForSingleObject(
            ev,
            new WaitOrTimerCallback(WaitProc),
            ti,
            1000,
            false
        );

        // The main thread waits three seconds, to demonstrate the
        // time-outs on the queued thread, and then signals.
        Thread.Sleep(3100);
        Console.WriteLine("Main thread signals.");
        ev.Set();

        // The main thread sleeps, which should give the callback
        // method time to execute.  If you comment out this line, the
        // program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000);
        // If you start a thread yourself, you can wait for it to end
        // by calling Thread.Join.  This option is not available with 
        // thread pool threads.
    }

    // The callback method executes when the registered wait times out,
    // or when the WaitHandle (in this case AutoResetEvent) is signaled.
    // WaitProc unregisters the WaitHandle the first time the event is 
    // signaled.
    public static void WaitProc(object state, bool timedOut) {
        // The state object must be cast to the correct type, because the
        // signature of the WaitOrTimerCallback delegate specifies type
        // Object.
        TaskInfo ti = (TaskInfo) state;

        string cause = "TIMED OUT";
        if (!timedOut) {
            cause = "SIGNALED";
            // If the callback method executes because the WaitHandle is
            // signaled, stop future execution of the callback method
            // by unregistering the WaitHandle.
            if (ti.Handle != null)
                ti.Handle.Unregister(null);
        } 

        Console.WriteLine("WaitProc( {0} ) executes on thread {1}; cause = {2}.",
            ti.OtherInfo, 
            Thread.CurrentThread.GetHashCode().ToString(), 
            cause
        );
    }
}


import System.*;
import System.Threading.*;
import System.Threading.Thread;

// TaskInfo contains data that will be passed to the callback
// method.
public class TaskInfo
{
    public RegisteredWaitHandle handle = null;
    public String otherInfo = "default";
} //TaskInfo

public class Example
{
    public static void main(String[] args)
    {
        // The main thread uses AutoResetEvent to signal the
        // registered wait Handle, which executes the callback
        // method.
        AutoResetEvent ev = new AutoResetEvent(false);
        TaskInfo ti = new TaskInfo();

        ti.otherInfo = "First task";

        // The TaskInfo for the task includes the registered wait
        // Handle returned by RegisterWaitForSingleObject.  This
        // allows the wait to be terminated when the object has
        // been signaled once (see WaitProc).
        ti.handle = ThreadPool.RegisterWaitForSingleObject(ev, 
            new WaitOrTimerCallback(WaitProc), ti, 1000, false);

        // The main thread waits three seconds, to demonstrate the
        // time-outs on the queued thread, and then signals.
        Thread.Sleep(3100);
        Console.WriteLine("Main thread signals.");
        ev.Set();

        // The main thread sleeps, which should give the callback
        // method time to execute.  If you comment out this line, the
        // program usually ends before the ThreadPool thread can execute.
        Thread.Sleep(1000);
        // If you start a thread yourself, you can wait for it to end
        // by calling Thread.Join.  This option is not available with 
        // thread pool threads.
    } //main

    // The callback method executes when the registered wait times out,
    // or when the WaitHandle (in this case AutoResetEvent) is signaled.
    // WaitProc unregisters the WaitHandle the first time the event is 
    // signaled.
    public static void WaitProc(Object state, boolean timedOut)
    {
        // The state object must be cast to the correct type, because the
        // signature of the WaitOrTimerCallback delegate specifies type
        // Object.
        TaskInfo ti = ((TaskInfo)(state));
        String cause = "TIMED OUT";

        if (!(timedOut)) {
            cause = "SIGNALED";

            // If the callback method executes because the WaitHandle is
            // signaled, stop future execution of the callback method
            // by unregistering the WaitHandle.
            if (ti.handle != null) {
                ti.handle.Unregister(null);
            }
        }

        Console.WriteLine("WaitProc( {0} ) executes " 
            + "on thread {1}; cause = {2}.",
            ti.otherInfo, 
            String.valueOf(Thread.get_CurrentThread().GetHashCode()),cause);
    } //WaitProc
} //Example


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0
Anzeigen: