WaitOrTimerCallback Delegat

Definicja

Przestrzeń nazw:

System.Threading

Zestaw:

System.Threading.ThreadPool.dll

Reprezentuje metodę, która ma być wywoływana, gdy WaitHandle element jest zasygnalizowany lub upłynął limit czasu.

public delegate void WaitOrTimerCallback(System::Object ^ state, bool timedOut);

public delegate void WaitOrTimerCallback(object? state, bool timedOut);

type WaitOrTimerCallback = delegate of obj * bool -> unit

Public Delegate Sub WaitOrTimerCallback(state As Object, timedOut As Boolean)

Parametry

state

Object

Obiekt zawierający informacje, które mają być używane przez metodę wywołania zwrotnego za każdym razem, gdy jest wykonywany.

timedOut

Boolean

true WaitHandle jeśli upłynął limit czasu; false jeśli został zasygnalizowany.

Przykłady

W poniższym przykładzie pokazano, jak używać delegata WaitOrTimerCallback do reprezentowania metody wywołania zwrotnego wykonywanej po zasygnalizowanym dojściu oczekiwania.

W przykładzie pokazano również, jak za pomocą RegisterWaitForSingleObject metody wykonać określoną metodę wywołania zwrotnego po zasygnalizowanej określonej dojściu oczekiwania. W tym przykładzie metoda wywołania zwrotnego to WaitProc , a uchwyt oczekiwania to AutoResetEvent.

W przykładzie zdefiniowano klasę TaskInfo do przechowywania informacji przekazywanych do wywołania zwrotnego podczas wykonywania. W przykładzie tworzony jest TaskInfo obiekt i przypisuje mu dane ciągu. Obiekt RegisteredWaitHandle zwracany przez RegisterWaitForSingleObject metodę jest przypisywany do Handle pola TaskInfo obiektu, dzięki czemu metoda wywołania zwrotnego ma dostęp do obiektu RegisteredWaitHandle.

Oprócz TaskInfo obiektu wywołanie RegisterWaitForSingleObject metody określa AutoResetEvent czas oczekiwania zadania, WaitOrTimerCallback delegata reprezentującego WaitProc metodę wywołania zwrotnego, jednorazowy interwał limitu czasu i wiele wywołań zwrotnych.

Gdy główny wątek sygnalizuje AutoResetEvent metodę WaitOrTimerCallback , Set delegat jest wywoływany. Metoda sprawdzaRegisteredWaitHandle, WaitProc czy wystąpiło przekroczenie limitu czasu. Jeśli wywołanie zwrotne zostało wywołane, ponieważ uchwyt oczekiwania został zasygnalizowany, WaitProc metoda wyrejestrowuje metodę RegisteredWaitHandle, zatrzymując dalsze wywołania zwrotne. W przypadku przekroczenia limitu czasu zadanie kontynuuje oczekiwanie. Metoda WaitProc kończy się drukowaniem komunikatu w konsoli programu .

using namespace System;
using namespace System::Threading;

// TaskInfo contains data that will be passed to the callback
// method.
public ref class TaskInfo
{
public:
   TaskInfo()
   {
      Handle = nullptr;
      OtherInfo = "default";
   }

   RegisteredWaitHandle^ Handle;
   String^ OtherInfo;
};

ref class Example
{
public:

   // 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.
   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 = static_cast<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 != nullptr )
                  ti->Handle->Unregister( nullptr );
      }

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

};

int main()
{
   
   // The main thread uses AutoResetEvent to signal the
   // registered wait handle, which executes the callback
   // method.
   AutoResetEvent^ ev = gcnew AutoResetEvent( false );
   TaskInfo^ ti = gcnew 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, gcnew WaitOrTimerCallback( Example::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.
   return 0;
}

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
        );
    }
}

Imports System.Threading

' TaskInfo contains data that will be passed to the callback
' method.
Public Class TaskInfo
    public Handle As RegisteredWaitHandle = Nothing
    public OtherInfo As String = "default"
End Class

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The main thread uses AutoResetEvent to signal the
        ' registered wait handle, which executes the callback
        ' method.
        Dim ev As New AutoResetEvent(false)

        Dim ti As 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(AddressOf WaitProc), _
            ti, _
            1000, _
            false _
        )

        ' The main thread waits about three seconds, to demonstrate 
        ' the time-outs on the queued task, 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.
    End Sub
   
    ' 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 Shared Sub WaitProc(state As Object, timedOut As Boolean)
        ' The state object must be cast to the correct type, because the
        ' signature of the WaitOrTimerCallback delegate specifies type
        ' Object.
        Dim ti As TaskInfo = CType(state, TaskInfo)

        Dim cause As String = "TIMED OUT"
        If Not timedOut Then
            cause = "SIGNALED"
            ' If the callback method executes because the WaitHandle is
            ' signaled, stop future execution of the callback method
            ' by unregistering the WaitHandle.
            If Not ti.Handle Is Nothing Then
                ti.Handle.Unregister(Nothing)
            End If
        End If 

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

Uwagi

WaitOrTimerCallback reprezentuje metodę wywołania zwrotnego, którą chcesz wykonać po przekroczeniu limitu czasu zarejestrowanego dojścia oczekiwania lub zasygnalizowanej. Utwórz delegata, przekazując metodę wywołania zwrotnego do konstruktora WaitOrTimerCallback . Metoda musi mieć podpis pokazany tutaj.

Utwórz zarejestrowany uchwyt oczekiwania, przekazując delegata WaitOrTimerCallback i element WaitHandle do ThreadPool.RegisterWaitForSingleObject. Metoda wywołania zwrotnego jest wykonywana za każdym razem, WaitHandle gdy limit czasu lub jest sygnalizowany.

Uwaga

Użytkownicy języka Visual Basic mogą pominąć WaitOrTimerCallback konstruktor i po prostu użyć AddressOf operatora podczas przekazywania metody wywołania zwrotnego do RegisterWaitForSingleObjectmetody . Program Visual Basic automatycznie wywołuje prawidłowy konstruktor delegata.

Jeśli chcesz przekazać informacje do metody wywołania zwrotnego, utwórz obiekt zawierający niezbędne informacje i przekaż go podczas RegisterWaitForSingleObject tworzenia zarejestrowanego dojścia oczekiwania. Za każdym razem, gdy metoda wywołania zwrotnego jest wykonywana state , parametr zawiera ten obiekt.

Aby uzyskać więcej informacji na temat używania metod wywołania zwrotnego do synchronizowania wątków puli wątków, zobacz Zarządzana pula wątków.

Metody rozszerzania

GetMethodInfo(Delegate)

Pobiera obiekt reprezentujący metodę reprezentowaną przez określonego delegata.

Zobacz też

• Wątki i wątkowość
• Zarządzana pula wątków