DispatcherQueue

Önemli Noktalar

  • Windows Uygulama SDK'sı'daki DispatcherQueue sınıfı, iş parçacığı görevlerinin seri bir şekilde yürütüldiği öncelikli bir kuyruğu yönetir.
  • Arka plan iş parçacıklarının DispatcherQueue’nun iş parçacığında kod çalıştırmasına olanak tanır (örneğin, iş parçacığına bağımlı nesnelerin bulunduğu UI iş parçacığında).
  • Sınıf, isteğe bağlı ileti döngüleriyle kusursuz biçimde bütünleşir. Örneğin, iç içe ileti döngülerinin ortak Win32 deyimini destekler.
  • AppWindow sınıfı DispatcherQueue ile tümleşir; belirli bir iş parçacığı için DispatcherQueue kapatılırken AppWindow örnekleri otomatik olarak yok edilir.
  • Zaman aşımı süresi dolduğunda çağrılan bir temsilciyi kaydetmek için bir araç sağlar.
  • Bileşenlere bir ileti döngüsünün çıkmak üzere olduğunu bildiren olaylar sağlar ve isteğe bağlı olarak, bekleyen işler tamamlanana kadar bu kapatma işlemini erteleyebilir. Bu, DispatcherQueue kullanan ancak ileti döngüsünü sahiplenmeyen bileşenlerin, döngü sonlanırken iş parçacığında temizlik yapabilmesini sağlar.
  • DispatcherQueue bir iş parçacığı singleton'dır (bunlardan en fazla biri belirli bir iş parçacığında çalışıyor olabilir). Varsayılan olarak, bir iş parçacığında DispatcherQueue yoktur.
  • İş parçacığı sahibi, iş parçacığı için DispatcherQueue'yu başlatmak üzere bir DispatcherQueueController oluşturabilir. Bu noktada, herhangi bir kod iş parçacığının DispatcherQueue öğesine erişebilir; ancak dispatcherQueueController'ın sahibi DispatcherQueueController.ShutdownQueue yöntemine erişebilir. Bu yöntem DispatcherQueue'yi boşaltıp ShutdownStarting ve ShutdownCompleted olaylarını tetikler.
  • En dıştaki ileti döngüsünün sahibi bir DispatcherQueue örneği oluşturmalıdır. Yalnızca bir iş parçacığının en dıştaki ileti döngüsünü çalıştırmaktan sorumlu kod, ileti işlemenin ne zaman tamamlandığını ve DispatcherQueue'yu kapatmak için uygun zamanın ne zaman olduğunu bilir. Bu, DispatcherQueue kullanan bileşenlerin iş parçacığının ileti döngüsüne sahip olmadığı sürece DispatcherQueue oluşturmaması gerektiği anlamına gelir.

Bakımsız

Bir iş parçacığı olay döngüsünden çıktıktan sonra DispatcherQueue'sini kapatmalıdır. Bunun yapılması ShutdownStarting ve ShutdownCompleted olaylarını yükseltir ve daha fazla sıralamayı devre dışı bırakmadan önce bekleyen son sıralanmış öğeleri boşaltir.

  • DispatcherQueue'ye ait ileti döngüsüyle ayrılmış bir iş parçacığında çalışan dispatcherQueue'yi kapatmak için DispatcherQueueController.ShutdownQueueAsync yöntemini çağırın.
  • Uygulamanın rastgele bir ileti döngüsüne (örneğin, XAML Adaları) sahip olduğu senaryolar için zaman uyumlu DispatcherQueueController.ShutdownQueue yöntemini çağırın. Bu yöntem kapatma olaylarını tetikler ve çağıran iş parçacığında DispatcherQueue'yu eşzamanlı olarak boşaltır.

DispatcherQueueController.ShutdownQueueAsync veya DispatcherQueueController.ShutdownQueue çağrısı yaptığınızda, oluşturulan olayların sırası aşağıdaki gibidir:

  • Kapatma başlatılıyor. Uygulamalar tarafından işlenmek üzere tasarlanmıştır.
  • FrameworkShutdownStarting. İşleyecek çerçeveler için tasarlanmıştır.
  • FrameworkShutdownCompleted. İşleyecek çerçeveler için tasarlanmıştır.
  • ShutdownCompleted. Uygulamalar tarafından işlenmek üzere tasarlanmıştır.

Olaylar, düzenli kapatmanın yapılabilmesi için uygulama/çerçeve kategorilerine ayrılır. Başka bir deyişle, uygulama kapatmayı çerçeve kapatma olaylarından önce açıkça yükselterek, uygulama kapandıkça bir çerçeve bileşeninin kullanılamaz durumda olması tehlikesi yoktur.

namespace winrt 
{
    using namespace Microsoft::UI::Dispatching;
}

// App runs its own custom message loop.
void RunCustomMessageLoop()
{
    // Create a DispatcherQueue.
    auto dispatcherQueueController{winrt::DispatcherQueueController::CreateOnCurrentThread()};

    // Run a custom message loop. Runs until the message loop owner decides to stop.
    MSG msg;
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!ContentPreTranslateMessage(&msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    // Run down the DispatcherQueue. This single call also runs down the system DispatcherQueue
    // if one was created via EnsureSystemDispatcherQueue:
    // 1. Raises DispatcherQueue.ShutdownStarting event.
    // 2. Drains remaining items in the DispatcherQueue, waits for deferrals.
    // 3. Raises DispatcherQueue.FrameworkShutdownStarting event.
    // 4. Drains remaining items in the DispatcherQueue, waits for deferrals.
    // 5. Disables further enqueuing.
    // 6. Raises the DispatcherQueue.FrameworkShutdownCompleted event.
    // 7. Raises the DispatcherQueue.ShutdownCompleted event.    

    dispatcherQueueController.ShutdownQueue();
}

En dıştaki ve özyinelemeli ileti döngüleri

DispatcherQueue özel ileti döngülerini destekler. Ancak özelleştirme gerektirmeyen basit uygulamalar için varsayılan bir uygulama sağlarız. Bu, geliştiricilerin yükünü ortadan kaldırır ve tutarlı bir şekilde doğru davranışın sağlanmasına yardımcı olur.

namespace winrt 
{
    using namespace Microsoft::UI::Dispatching;
}

// Simple app; doesn't need a custom message loop.
void RunMessageLoop()
{
    // Create a DispatcherQueue.
    auto dispatcherQueueController{winrt::DispatcherQueueController::CreateOnCurrentThread()};

    // Runs a message loop until a call to DispatcherQueue.EnqueueEventLoopExit or PostQuitMessage.
    dispatcherQueueController.DispatcherQueue().RunEventLoop();

    // Run down the DispatcherQueue. 
    dispatcherQueueController.ShutdownQueue();
}

// May be called while receiving a message.
void RunNestedLoop(winrt::DispatcherQueue dispatcherQueue)
{
    // Runs a message loop until a call to DispatcherQueue.EnqueueEventLoopExit or PostQuitMessage.
    dispatcherQueue.RunEventLoop();
}

// Called to break out of the message loop, returning from the RunEventLoop call lower down the
// stack.
void EndMessageLoop(winrt::DispatcherQueue dispatcherQueue)
{
    // Alternatively, calling Win32's PostQuitMessage has the same effect.
    dispatcherQueue.EnqueueEventLoopExit();
}

Sistem dağıtıcı yönetimi

Bazı Windows Uygulama SDK'sı bileşenleri (örneğin MicaController), sırayla iş parçacığında çalışan bir sistem DispatcherQueue'su (Windows.System.DispatcherQueue) gerektiren sistem bileşenlerine bağlıdır.

Bu gibi durumlarda, bir sistem DispatcherQueue bağımlılığına sahip bileşen EnsureSystemDispatcherQueue yöntemini çağırır ve uygulamanızın bir sistem DispatcherQueue'sini yönetmesini engeller.

Bu yöntem çağrıldığında, Windows Uygulama SDK'sı DispatcherQueue, sistem DispatcherQueue'sunun yaşam döngüsünü otomatik olarak yönetir ve Windows Uygulama SDK'sı DispatcherQueue ile birlikte sistem DispatcherQueue'sunu kapatır. Bileşenler hem Windows Uygulama SDK'sı hem de sistem DispatcherQueue kapatma olaylarını kullanarak ileti döngüsü çıktıktan sonra düzgün temizleme gerçekleştirebilir.

namespace winrt 
{
    using namespace Microsoft::UI::Composition::SystemBackdrops;
    using namespace Microsoft::UI::Dispatching;
}

// The Windows App SDK component calls this during its startup.
void MicaControllerInitialize(winrt::DispatcherQueue dispatcherQueue)
{
    dispatcherQueue.EnsureSystemDispatcherQueue();

    // If the component needs the system DispatcherQueue explicitly, it can now grab it off the thread.
    winrt::Windows::System::DispatcherQueue systemDispatcherQueue =
        winrt::Windows::System::DispatcherQueue::GetForCurrentThread();
}

void AppInitialize()
{
    // App doesn't need to concern itself with the system DispatcherQueue dependency.
    auto micaController = winrt::MicaController();
}

AppWindow entegrasyonu

AppWindow sınıfı, DispatcherQueue ile tümleştirildiğinden, DispatcherQueueController.ShutdownQueueAsync veya DispatcherQueueController.ShutdownQueue yöntemi çağrıldığında AppWindow nesnelerinin otomatik olarak yok edilebilmesini sağlayan işlevlere sahiptir.

Ayrıca, çağıranların AppWindow ile ilişkilendirilmiş DispatcherQueue'yu almasını sağlayan bir AppWindow özelliği de vardır; bu da onu Composition ve Input ad alanlarındaki diğer nesnelerle uyumlu hâle getirir.

AppWindow'un DispatcherQueue'yu tanıması için bunu açıkça etkinleştirmeniz gerekir.

namespace winrt 
{
    using namespace Microsoft::UI::Dispatching;
    using namespace Microsoft::UI::Windowing;
}

void Main()
{
    // Create a Windows App SDK DispatcherQueue.
    auto dispatcherQueueController{winrt::DispatcherQueueController::CreateOnCurrentThread()};

    auto appWindow = AppWindow::Create(nullptr, 0, dispatcherQueueController.DispatcherQueue());

    // Since we associated the DispatcherQueue above with the AppWindow, we're able to retrieve it 
    // as a property. If we were to not associate a dispatcher, this property would be null.
    ASSERT(appWindow.DispatcherQueue() == dispatcherQueueController.DispatcherQueue());

    // Runs a message loop until a call to DispatcherQueue.EnqueueEventLoopExit or PostQuitMessage.
    dispatcherQueueController.DispatcherQueue().RunEventLoop();

    // Rundown the Windows App SDK DispatcherQueue. While this call is in progress, the AppWindow.Destroyed
    // event will be raised since the AppWindow instance is associated with the DispatcherQueue.
    dispatcherQueueController.ShutdownQueue();
}

Ayrıca bakınız

  • Last updated on