Porady: wykonywanie operacji asynchronicznych z użyciem biblioteki WRL
W tym dokumencie pokazano, jak używać biblioteki szablonów języka środowisko wykonawcze systemu Windows C++ (WRL) do uruchamiania operacji asynchronicznych i wykonywania pracy po zakończeniu operacji.
Ten dokument zawiera dwa przykłady. Pierwszy przykład uruchamia asynchroniczny czasomierz i czeka na wygaśnięcie czasomierza. W tym przykładzie określasz akcję asynchroniczną podczas tworzenia obiektu czasomierza. W drugim przykładzie jest uruchamiany wątek procesu roboczego w tle. W tym przykładzie pokazano, jak pracować z metodą środowisko wykonawcze systemu Windows zwracającą IAsyncInfo
interfejs. Funkcja wywołania zwrotnego jest ważną częścią obu przykładów, ponieważ umożliwia im określenie procedury obsługi zdarzeń w celu przetworzenia wyników operacji asynchronicznych.
Aby uzyskać bardziej podstawowy przykład, który tworzy wystąpienie składnika i pobiera wartość właściwości, zobacz Jak aktywować i używać składnika środowisko wykonawcze systemu Windows.
Napiwek
W tych przykładach użyto wyrażeń lambda do zdefiniowania wywołań zwrotnych. Można również używać obiektów funkcji (functors), wskaźników funkcji lub obiektów std::function . Aby uzyskać więcej informacji na temat wyrażeń lambda języka C++, zobacz Wyrażenia lambda.
Przykład: praca z czasomierzem
Poniższe kroki powodują uruchomienie czasomierza asynchronicznego i oczekiwanie na wygaśnięcie czasomierza. Poniższy kompletny przykład.
Ostrzeżenie
Chociaż zazwyczaj używasz biblioteki szablonów języka C++ środowisko wykonawcze systemu Windows w aplikacji platformy platforma uniwersalna systemu Windows (UWP), w tym przykładzie użyto aplikacji konsolowej na potrzeby ilustracji. Funkcje, takie jak wprintf_s
nie są dostępne w aplikacji platformy UNIWERSALNEJ systemu Windows. Aby uzyskać więcej informacji na temat typów i funkcji, których można używać w aplikacji platformy UNIWERSALNEJ systemu Windows, zobacz Funkcje CRT nieobsługiwane w aplikacjach platforma uniwersalna systemu Windows i Win32 i COM dla aplikacji platformy UWP.
Uwzględnij (
#include
) wszystkie wymagane środowisko wykonawcze systemu Windows, bibliotekę szablonów języka C++ środowisko wykonawcze systemu Windows lub nagłówki standardowej biblioteki języka 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
deklaruje typy wymagane do używania asynchronicznego czasomierza.Zalecamy użycie
using namespace
dyrektywy w pliku cpp, aby kod był bardziej czytelny.Zainicjuj środowisko wykonawcze systemu Windows.
// Initialize the Windows Runtime. RoInitializeWrapper initialize(RO_INIT_MULTITHREADED); if (FAILED(initialize)) { return PrintError(__LINE__, initialize); }
Utwórz fabrykę aktywacji dla interfejsu
ABI::Windows::System::Threading::IThreadPoolTimer
.// 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); }
Środowisko wykonawcze systemu Windows używa w pełni kwalifikowanych nazw do identyfikowania typów. Parametr
RuntimeClass_Windows_System_Threading_ThreadPoolTimer
jest ciągiem dostarczonym przez środowisko wykonawcze systemu Windows i zawiera wymaganą nazwę klasy środowiska uruchomieniowego.Utwórz obiekt zdarzenia, który synchronizuje wywołanie zwrotne czasomierza z główną aplikacją.
// 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); }
Uwaga
To zdarzenie jest przeznaczone tylko dla pokazu w ramach aplikacji konsolowej. W tym przykładzie użyto zdarzenia , aby upewnić się, że operacja asynchronizuja się przed zakończeniem działania aplikacji. W większości aplikacji zwykle nie czekasz na ukończenie operacji asynchronicznych.
IThreadPoolTimer
Utwórz obiekt, który wygaśnie po dwóch sekundach.Callback
Użyj funkcji , aby utworzyć procedurę obsługi zdarzeń (ABI::Windows::System::Threading::ITimerElapsedHandler
obiekt).// 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); }
Wydrukuj komunikat do konsoli i poczekaj na zakończenie wywołania zwrotnego czasomierza. Wszystkie
ComPtr
obiekty RAII opuszczają zakres i są zwalniane automatycznie.// 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.
Oto kompletny przykład:
// 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.
*/
Kompilowanie kodu
Aby skompilować kod, skopiuj go, a następnie wklej go w projekcie programu Visual Studio lub wklej go w pliku o nazwie wrl-consume-async.cpp
, a następnie uruchom następujące polecenie w oknie wiersza polecenia programu Visual Studio.
cl.exe wrl-consume-async.cpp runtimeobject.lib
Przykład: praca z wątkiem w tle
Poniższe kroki rozpoczynają wątek procesu roboczego i definiują akcję wykonywaną przez ten wątek. Poniższy kompletny przykład.
Napiwek
W tym przykładzie pokazano, jak pracować z interfejsem ABI::Windows::Foundation::IAsyncAction
. Ten wzorzec można zastosować do dowolnego interfejsu, który implementuje IAsyncInfo
: IAsyncAction
, , IAsyncActionWithProgress
IAsyncOperation
i IAsyncOperationWithProgress
.
Uwzględnij (
#include
) wszystkie wymagane środowisko wykonawcze systemu Windows, bibliotekę szablonów języka C++ środowisko wykonawcze systemu Windows lub nagłówki standardowej biblioteki języka 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 deklaruje typy wymagane do korzystania z wątku roboczego.
Zalecamy użycie
using namespace
dyrektywy w pliku cpp, aby kod był bardziej czytelny.Zainicjuj środowisko wykonawcze systemu Windows.
// Initialize the Windows Runtime. RoInitializeWrapper initialize(RO_INIT_MULTITHREADED); if (FAILED(initialize)) { return PrintError(__LINE__, initialize); }
Utwórz fabrykę aktywacji dla interfejsu
ABI::Windows::System::Threading::IThreadPoolStatics
.// 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); }
Utwórz obiekt zdarzenia, który synchronizuje ukończenie wątku roboczego z główną aplikacją.
// 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); }
Uwaga
To zdarzenie jest przeznaczone tylko dla pokazu w ramach aplikacji konsolowej. W tym przykładzie użyto zdarzenia , aby upewnić się, że operacja asynchronizuja się przed zakończeniem działania aplikacji. W większości aplikacji zwykle nie czekasz na ukończenie operacji asynchronicznych.
Wywołaj metodę ,
IThreadPoolStatics::RunAsync
aby utworzyć wątek procesu roboczego.Callback
Użyj funkcji , aby zdefiniować akcję.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); }
Funkcja jest zdefiniowana
IsPrime
w pełnym przykładzie, który następuje poniżej.Wydrukuj komunikat do konsoli i poczekaj na zakończenie wątku. Wszystkie
ComPtr
obiekty RAII opuszczają zakres i są zwalniane automatycznie.// 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.
Oto kompletny przykład:
// 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.
*/
Kompilowanie kodu
Aby skompilować kod, skopiuj go, a następnie wklej go w projekcie programu Visual Studio lub wklej go w pliku o nazwie wrl-consume-asyncOp.cpp
, a następnie uruchom następujące polecenie w oknie wiersza polecenia programu Visual Studio.
cl.exe wrl-consume-asyncOp.cpp runtimeobject.lib
Zobacz też
Biblioteka szablonów języka C++ środowiska uruchomieniowego systemu Windows (WRL)
Opinia
https://aka.ms/ContentUserFeedback.
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź:Prześlij i wyświetl opinię dla