共用方式為

如何：使用 WRL 完成非同步作業

  • 發行項

本文件將示範如何使用 Windows 執行階段 C++ 樣板庫 (WRL) 啟動非同步作業和執行工作，當作業完成時。

這個文件顯示兩個範例。 第一個範例會啟動非同步計時器並等候計時器逾時。 在此範例中，在您建立計時器物件時，您會指定非同步動作。 第二個範例會執行背景工作執行緒。 這個範例示範如何使用傳回 IAsyncInfo 介面的 Windows 執行階段 方法一起使用。 因為它可讓它們指定事件處理常式處理非同步作業的結果， 回呼 函式是兩個範例中重要的一部分。

如需建立元件的執行個體並擷取屬性值的更基本的範例，請參閱 如何：利用 WRL 啟動與使用 Windows 執行階段元件。

提示

這些範例會使用 Lambda 運算式定義回呼。您也可以使用函式物件 (functors)，函式指標或 std::function 物件。如需 C++ Lambda 運算式的詳細資訊，請參閱 在 C++ 中使用 lambda 運算式。

範例:使用計時器。

下列步驟會啟動非同步計時器並等候計時器逾時。 完整的程式碼範例如下所示。

警告

雖然您可以在 Windows 市集 應用程式通常會使用 WRL ，這個範例使用圖的主控台應用程式。例如 wprintf_s 函式無法從 Windows 市集 應用程式使用。如需您可以在 Windows 市集 應用程式中使用的型別和函式的詳細資訊，請參閱 CRT 函式不支援使用 /ZW 和 Win32 和 COM Windows 市集應用程式的。

  1. 包含 (#include) 所有必要的 Windows 執行階段、 WRL或 Standard C++ 程式庫的標頭。

    #include <Windows.Foundation.h>
#include <Windows.System.Threading.h>
#include <wrl/event.h>
#include <stdio.h>
#include <Objbase.h>

using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::System::Threading;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

    Windows.System.Threading.h 宣告時必須使用非同步計時器的型別。

    建議您利用您的 .cpp 檔中的 using namespace 指示詞讓程式碼更容易讀取。

  2. 初始化 Windows 執行階段。

    // Initialize the Windows Runtime.
RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
if (FAILED(initialize))
{
    return PrintError(__LINE__, initialize);
}

  3. 建立介面 ABI::Windows::System::Threading::IThreadPoolTimer 的啟動 Factory。

    // Get the activation factory for the IThreadPoolTimer interface.
ComPtr<IThreadPoolTimerStatics> timerFactory;
HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPoolTimer).Get(), &timerFactory);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

    Windows 執行階段 使用完整名稱以識別型別。 RuntimeClass_Windows_System_Threading_ThreadPoolTimer 參數是由 Windows 執行階段 提供和包含所需的執行階段類別名稱的字串。

  4. 建立同步處理計時器回呼至主應用程式的 事件 物件。

    // Create an event that is set after the timer callback completes. We later use this event to wait for the timer to complete. 
// This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
Event timerCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
hr = timerCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}
    注意事項注意事項

    這個事件僅供示範使用，且僅為主控台應用程式的一部分。這個範例會使用事件可確保非同步作業已完成，在應用程式結束之前。在大部分的應用程式，您通常不會等候非同步作業完成。

  5. 建立會在兩秒後過期的 IThreadPoolTimer 物件。 使用 Callback 函式建立事件處理常式( ABI::Windows::System::Threading::ITimerElapsedHandler 物件)。

    // Create a timer that prints a message after 2 seconds.

TimeSpan delay;
delay.Duration = 20000000; // 2 seconds.

auto callback = Callback<ITimerElapsedHandler>([&timerCompleted](IThreadPoolTimer* timer) -> HRESULT
{
    wprintf_s(L"Timer fired.\n");

    TimeSpan delay;
    HRESULT hr = timer->get_Delay(&delay);
    if (SUCCEEDED(hr))
    {
        wprintf_s(L"Timer duration: %2.2f seconds.\n", delay.Duration / 10000000.0);
    }

    // Set the completion event and return.
    SetEvent(timerCompleted.Get());
    return hr;
});
hr = callback ? S_OK : E_OUTOFMEMORY;
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

ComPtr<IThreadPoolTimer> timer;
hr = timerFactory->CreateTimer(callback.Get(), delay, &timer);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

  6. 將訊息列印至主控台並等候計時器回呼完成。 所有 ComPtr 和 RAII 物件離開範圍並自動釋放。

    // Print a message and wait for the timer callback to complete.
wprintf_s(L"Timer started.\nWaiting for timer...\n");

// Wait for the timer to complete.
WaitForSingleObjectEx(timerCompleted.Get(), INFINITE, FALSE);
// All smart pointers and RAII objects go out of scope here.

這裡有個完整範例:

// wrl-consume-async.cpp
// compile with: runtimeobject.lib
#include <Windows.Foundation.h>
#include <Windows.System.Threading.h>
#include <wrl/event.h>
#include <stdio.h>
#include <Objbase.h>

using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::System::Threading;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

// Prints an error string for the provided source code line and HRESULT
// value and returns the HRESULT value as an int.
int PrintError(unsigned int line, HRESULT hr)
{
    wprintf_s(L"ERROR: Line:%d HRESULT: 0x%X\n", line, hr);
    return hr;
}

int wmain()
{
    // Initialize the Windows Runtime.
    RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
    if (FAILED(initialize))
    {
        return PrintError(__LINE__, initialize);
    }

    // Get the activation factory for the IThreadPoolTimer interface.
    ComPtr<IThreadPoolTimerStatics> timerFactory;
    HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPoolTimer).Get(), &timerFactory);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create an event that is set after the timer callback completes. We later use this event to wait for the timer to complete. 
    // This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
    Event timerCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
    hr = timerCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create a timer that prints a message after 2 seconds.

    TimeSpan delay;
    delay.Duration = 20000000; // 2 seconds.

    auto callback = Callback<ITimerElapsedHandler>([&timerCompleted](IThreadPoolTimer* timer) -> HRESULT
    {
        wprintf_s(L"Timer fired.\n");

        TimeSpan delay;
        HRESULT hr = timer->get_Delay(&delay);
        if (SUCCEEDED(hr))
        {
            wprintf_s(L"Timer duration: %2.2f seconds.\n", delay.Duration / 10000000.0);
        }

        // Set the completion event and return.
        SetEvent(timerCompleted.Get());
        return hr;
    });
    hr = callback ? S_OK : E_OUTOFMEMORY;
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    ComPtr<IThreadPoolTimer> timer;
    hr = timerFactory->CreateTimer(callback.Get(), delay, &timer);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Print a message and wait for the timer callback to complete.
    wprintf_s(L"Timer started.\nWaiting for timer...\n");

    // Wait for the timer to complete.
    WaitForSingleObjectEx(timerCompleted.Get(), INFINITE, FALSE);
    // All smart pointers and RAII objects go out of scope here.
}
/*
Output:
Timer started.
Waiting for timer...
Timer fired.
Timer duration: 2.00 seconds.
*/

Hh973451.collapse_all(zh-tw,VS.110).gif編譯程式碼

若要編譯程式碼，請複製並貼到 Visual Studio 專案或貼在名為 wrl-consume-async.cpp 然後在 Visual Studio 命令提示字元視窗中執行下列命令的檔案。

cl.exe wrl-consume-async.cpp runtimeobject.lib

範例:使用背景執行緒。

下列步驟會啟動背景工作執行緒並定義由該執行緒執行的動作。 完整的程式碼範例如下所示。

提示

這個範例示範如何使用 ABI::Windows::Foundation::IAsyncAction 介面。您可以將該樣式套用至任何實作介面的 IAsyncInfo: IAsyncAction、 IAsyncActionWithProgress、 IAsyncOperation和 IAsyncOperationWithProgress。

  1. 包含 (#include) 所有必要的 Windows 執行階段、 WRL或 Standard C++ 程式庫的標頭。

    #include <Windows.Foundation.h>
#include <Windows.System.Threading.h>
#include <wrl/event.h>
#include <stdio.h>
#include <Objbase.h>

using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::System::Threading;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

    Windows.System.Threading.h 宣告時必須使用背景工作執行緒的型別。

    建議您利用您的 .cpp 檔中的 using namespace 指示詞讓程式碼更容易讀取。

  2. 初始化 Windows 執行階段。

    // Initialize the Windows Runtime.
RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
if (FAILED(initialize))
{
    return PrintError(__LINE__, initialize);
}

  3. 建立介面 ABI::Windows::System::Threading::IThreadPoolStatics 的啟動 Factory。

    // Get the activation factory for the IThreadPoolStatics interface.
ComPtr<IThreadPoolStatics> threadPool;
HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPool).Get(), &threadPool);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

  4. 建立同步處理背景工作執行緒完成繫結至主應用程式的 事件 物件。

        // Create an event that is set after the timer callback completes. We later use this event to wait for the timer to complete. 
    // This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
    Event threadCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
    hr = threadCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }
    注意事項注意事項

    這個事件僅供示範使用，且僅為主控台應用程式的一部分。這個範例會使用事件可確保非同步作業已完成，在應用程式結束之前。在大部分的應用程式，您通常不會等候非同步作業完成。

  5. 呼叫方法 IThreadPoolStatics::RunAsync 建立背景工作執行緒。 使用 Callback 函式定義這個動作。

    wprintf_s(L"Starting thread...\n");

// Create a thread that computes prime numbers.
ComPtr<IAsyncAction> asyncAction;
hr = threadPool->RunAsync(Callback<IWorkItemHandler>([&threadCompleted](IAsyncAction* asyncAction) -> HRESULT
{
    // Print a message.
    const unsigned int start = 0;
    const unsigned int end = 100000;
    unsigned int primeCount = 0;
    for (int n = start; n < end; n++)
    {
        if (IsPrime(n))
        {
            primeCount++;
        }
    }

    wprintf_s(L"There are %u prime numbers from %u to %u.\n", primeCount, start, end);

    // Set the completion event and return.
    SetEvent(threadCompleted.Get());
    return S_OK;

}).Get(), &asyncAction);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

    IsPrime 函式在後面的完整範例中所定義。

  6. 將訊息列印至主控台並等候執行緒完成。 所有 ComPtr 和 RAII 物件離開範圍並自動釋放。

    // Print a message and wait for the thread to complete.
wprintf_s(L"Waiting for thread...\n");

// Wait for the thread to complete.
WaitForSingleObjectEx(threadCompleted.Get(), INFINITE, FALSE);

wprintf_s(L"Finished.\n");

// All smart pointers and RAII objects go out of scope here.

這裡有個完整範例:

// wrl-consume-asyncOp.cpp
// compile with: runtimeobject.lib 
#include <Windows.Foundation.h>
#include <Windows.System.Threading.h>
#include <wrl/event.h>
#include <stdio.h>
#include <Objbase.h>

using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::System::Threading;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

// Prints an error string for the provided source code line and HRESULT
// value and returns the HRESULT value as an int.
int PrintError(unsigned int line, HRESULT hr)
{
    wprintf_s(L"ERROR: Line:%d HRESULT: 0x%X\n", line, hr);
    return hr;
}

// Determines whether the input value is prime.
bool IsPrime(int n)
{
    if (n < 2)
    {
        return false;
    }
    for (int i = 2; i < n; ++i)
    {
        if ((n % i) == 0)
        {
            return false;
        }
    }
    return true;
}

int wmain()
{
    // Initialize the Windows Runtime.
    RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
    if (FAILED(initialize))
    {
        return PrintError(__LINE__, initialize);
    }

    // Get the activation factory for the IThreadPoolStatics interface.
    ComPtr<IThreadPoolStatics> threadPool;
    HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_System_Threading_ThreadPool).Get(), &threadPool);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create an event that is set after the timer callback completes. We later use this event to wait for the timer to complete. 
    // This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
    Event threadCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
    hr = threadCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }


    wprintf_s(L"Starting thread...\n");

    // Create a thread that computes prime numbers.
    ComPtr<IAsyncAction> asyncAction;
    hr = threadPool->RunAsync(Callback<IWorkItemHandler>([&threadCompleted](IAsyncAction* asyncAction) -> HRESULT
    {
        // Print a message.
        const unsigned int start = 0;
        const unsigned int end = 100000;
        unsigned int primeCount = 0;
        for (int n = start; n < end; n++)
        {
            if (IsPrime(n))
            {
                primeCount++;
            }
        }

        wprintf_s(L"There are %u prime numbers from %u to %u.\n", primeCount, start, end);

        // Set the completion event and return.
        SetEvent(threadCompleted.Get());
        return S_OK;

    }).Get(), &asyncAction);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Print a message and wait for the thread to complete.
    wprintf_s(L"Waiting for thread...\n");

    // Wait for the thread to complete.
    WaitForSingleObjectEx(threadCompleted.Get(), INFINITE, FALSE);

    wprintf_s(L"Finished.\n");

    // All smart pointers and RAII objects go out of scope here.
}
/*
Output:
Starting thread...
Waiting for thread...
There are 9592 prime numbers from 0 to 100000.
Finished.
*/

Hh973451.collapse_all(zh-tw,VS.110).gif編譯程式碼

若要編譯程式碼，請複製並貼到 Visual Studio 專案或貼在名為 wrl-consume-asyncOp.cpp 然後在 Visual Studio 命令提示字元視窗中執行下列命令的檔案。

cl.exe wrl-consume-asyncOp.cpp runtimeobject.lib

請參閱

概念

Windows Runtime C++ Template Library (WRL)