Munkaelem beküldése időzítő használatával

Fontos API-k

Megtudhatja, hogyan hozhat létre olyan munkaelemet, amely egy időzítő leteltét követően fut.

Egyszeri időzítő létrehozása

A CreateTimer metódussal időzítőt hozhat létre a munkaelemhez. Adjon meg egy lambdát, amely elvégzi a munkát, és a késleltetési paraméterrel adja meg, hogy a szálkészlet mennyi ideig várjon, mielőtt hozzárendelheti a munkaelemet egy elérhető szálhoz. A késleltetés a TimeSpan-struktúra használatával van megadva.

Note

WinUI 3-alkalmazásokban a Microsoft.UI.Dispatching.DispatcherQueue elemben található DispatcherQueue.TryEnqueue használatával érheti el a felhasználói felület szálát, és megjelenítheti a munkaelem előrehaladását. A részletekért tekintse meg a DispatcherQueue áttekintését.

Az alábbi példa egy három perc alatt futó munkaelemet hoz létre:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (source) =>
    {
        //
        // TODO: Work
        //
        
        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
            CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

            });

    }, delay);

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([this](ThreadPoolTimer^ source)
        {
            //
            // TODO: Work
            //
            
            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([this]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                    ExampleUIUpdateMethod("Timer completed.");

                }));

        }), delay);

Befejezéskezelő megadása

Szükség esetén kezelje a munkaelem megszakítását és befejezését egy TimerDestroyedHandler használatával. Használja a CreateTimer túlterhelést egy további lambda megadásához. Ez az időzítő megszakításakor vagy a munkaelem befejeződésekor fut.

Az alábbi példa létrehoz egy időzítőt, amely elküldi a munkaelemet, és metódust hív meg a munkaelem befejezésekor vagy az időzítő megszakításakor:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
bool completed = false;

ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (source) =>
    {
        //
        // TODO: Work
        //

        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
                CoreDispatcherPriority.High,
                () =>
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                });

        completed = true;
    },
    delay,
    (source) =>
    {
        //
        // TODO: Handle work cancellation/completion.
        //


        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
            CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

                if (completed)
                {
                    // Timer completed.
                }
                else
                {
                    // Timer cancelled.
                }

            });
    });

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

completed = false;

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Work
            //

            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                }));

            completed = true;

        }),
        delay,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle work cancellation/completion.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // Update the UI thread by using the UI core dispatcher.
                    //

                    if (completed)
                    {
                        // Timer completed.
                    }
                    else
                    {
                        // Timer cancelled.
                    }

                }));
        }));

Az időzítő megszakítása

Ha az időzítő továbbra is visszaszámol, de a munkaelemre már nincs szükség, válassza a Mégse parancsot. Az időzítő le lett állítva, és a munkaelem nem kerül elküldésre a szálkészletbe.

DelayTimer.Cancel();

DelayTimer->Cancel();

Remarks

Windows alkalmazásoknak kerülnie kell a Thread.Sleep-t, mert blokkolja a hívó szálat, ami miatt a felhasználói felület nem válaszol, ha a felhasználói felület szálra van meghívva. Ehelyett a ThreadPoolTimer használatával létrehozhat egy munkaelemet, és ez késlelteti a munkaelem által végzett feladatot a felhasználói felületi szál blokkolása nélkül.

A munkaelemeket, az időzített munkaelemeket és az ismétlődő munkaelemeket bemutató teljes kódmintáért lásd a szálkészlet mintát. A kódmintát eredetileg Windows 8.1 írták, de a kód újra felhasználható Windows 10.

Az ismétlődő időzítőkről további információt az Időszakos munkaelem létrehozása című témakörben talál.

  • Last updated on