Nasıl Yapılır: WRL Kullanarak Olayları İşleme

Makale
10/12/2023

Bu belgede, bir Windows Çalışma Zamanı nesnesine abone olmak ve olayları işlemek için Windows Çalışma Zamanı C++ Şablon Kitaplığı'nın (WRL) nasıl kullanılacağı gösterilmektedir.

Bu bileşenin bir örneğini oluşturan ve bir özellik değeri alan daha temel bir örnek için bkz. Nasıl yapılır: Windows Çalışma Zamanı Bileşenini Etkinleştirme ve Kullanma.

Olaylara Abone Olma ve Olayları İşleme

Aşağıdaki adımlar bir ABI::Windows::System::Threading::IDeviceWatcher nesneyi başlatır ve ilerleme durumunu izlemek için olay işleyicilerini kullanır. Arabirim IDeviceWatcher , cihazları zaman uyumsuz olarak veya arka planda listelemenizi ve cihazlar eklendiğinde, kaldırıldığında veya değiştirildiğinde bildirim almanızı sağlar. Geri Çağırma işlevi, arka plan işleminin sonuçlarını işleyen olay işleyicilerini belirtmesine olanak sağladığından bu örneğin önemli bir parçasıdır. Tam örnek aşağıda verilmiştir.

Uyarı

Genellikle bir Evrensel Windows Platformu uygulamasında Windows Çalışma Zamanı C++ Şablon Kitaplığı'nı kullansanız da, bu örnekte çizim için bir konsol uygulaması kullanılır. gibi wprintf_s işlevler Evrensel Windows Platformu bir uygulamada kullanılamaz. bir Evrensel Windows Platformu uygulamasında kullanabileceğiniz türler ve işlevler hakkında daha fazla bilgi için bkz. Evrensel Windows Platformu uygulamalarında desteklenmeyen CRT işlevleri ve UWP uygulamaları için Win32 ve COM.

Gerekli tüm Windows Çalışma Zamanı, Windows Çalışma Zamanı C++ Şablon Kitaplığı veya C++ Standart Kitaplığı üst bilgilerini ekleyin (#include).
```
#include <Windows.Devices.Enumeration.h>
#include <wrl/event.h>
#include <stdio.h>

using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
```
Windows.Devices.Enumeration.h cihazları listelemek için gereken türleri bildirir.

Kodu daha okunabilir hale getirmek için .cpp dosyanızdaki yönergesini kullanmanızı using namespace öneririz.

Uygulama için yerel değişkenleri bildirin. Bu örnek, daha sonra olay aboneliğini kaldırmasını sağlayan numaralandırılmış cihazların ve kayıt belirteçlerinin sayısını tutar.

// Counts the number of enumerated devices.
unsigned int deviceCount = 0;

// Event registration tokens that enable us to later unsubscribe from events.
EventRegistrationToken addedToken;
EventRegistrationToken stoppedToken;
EventRegistrationToken enumCompletedToken;

Windows Çalışma Zamanı başlatın.

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

Numaralandırma işleminin tamamlanmasını ana uygulamayla eşitleyen bir Event nesnesi oluşturun.

// Create an event that is set after device enumeration 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 enumerationCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
HRESULT hr = enumerationCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Not

Bu olay yalnızca bir konsol uygulamasının parçası olarak gösterim amaçlıdır. Bu örnekte, uygulamadan çıkmadan önce zaman uyumsuz bir işlemin tamamlandığından emin olmak için olayı kullanılır. Çoğu uygulamada genellikle zaman uyumsuz işlemlerin tamamlanmasını beklemezsiniz.

Arabirim için IDeviceWatcher bir etkinleştirme fabrikası oluşturun.
```
// Get the activation factory for the IDeviceWatcher interface.
ComPtr<IDeviceInformationStatics> watcherFactory;
hr = ABI::Windows::Foundation::GetActivationFactory(HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation).Get(), &watcherFactory);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}
```
Windows Çalışma Zamanı türleri tanımlamak için tam adlar kullanır. RuntimeClass_Windows_Devices_Enumeration_DeviceInformation parametresi, Windows Çalışma Zamanı tarafından sağlanan ve gerekli çalışma zamanı sınıf adını içeren bir dizedir.

IDeviceWatcher Nesnesini oluşturun.

// Create a IDeviceWatcher object from the factory.
ComPtr<IDeviceWatcher> watcher;
hr = watcherFactory->CreateWatcher(&watcher);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Callback, EnumerationCompletedve Stopped olaylarına abone olmak için Addedişlevini kullanın.

// Subscribe to the Added event.
hr = watcher->add_Added(Callback<AddedHandler>([&deviceCount](IDeviceWatcher* watcher, IDeviceInformation*) -> HRESULT
{
    // Print a message and increment the device count.
    // When we reach 10 devices, stop enumerating devices.
    wprintf_s(L"Added device...\n");
    deviceCount++;
    if (deviceCount == 10)
    {
        return watcher->Stop();
    }
    return S_OK;

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

hr = watcher->add_Stopped(Callback<StoppedHandler>([=, &enumerationCompleted](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
{
    wprintf_s(L"Device enumeration stopped.\nRemoving event handlers...");

    // Unsubscribe from the events. This is shown for demonstration.
    // The need to remove event handlers depends on the requirements of 
    // your app. For instance, if you only need to handle an event for 
    // a short period of time, you might remove the event handler when you
    // no longer need it. If you handle an event for the duration of the app,
    // you might not need to explicitly remove it.
    HRESULT hr1 = watcher->remove_Added(addedToken);
    HRESULT hr2 = watcher->remove_Stopped(stoppedToken);
    HRESULT hr3 = watcher->remove_EnumerationCompleted(enumCompletedToken);

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

    return FAILED(hr1) ? hr1 : FAILED(hr2) ? hr2 : hr3;

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

// Subscribe to the EnumerationCompleted event.
hr = watcher->add_EnumerationCompleted(Callback<EnumerationCompletedHandler>([](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
{
    wprintf_s(L"Enumeration completed.\n");

    return watcher->Stop();

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

Olay Added işleyicisi, numaralandırılmış cihazların sayısını artırır. On cihaz bulunduktan sonra numaralandırma işlemini durdurur.

Olay işleyicisi Stopped olay işleyicilerini kaldırır ve tamamlanma olayını ayarlar.

Olay EnumerationCompleted işleyicisi numaralandırma işlemini durdurur. Bu olayı, ondan az cihaz olması durumunda ele alıyoruz.

İpucu

Bu örnekte, geri çağırmaları tanımlamak için lambda ifadesi kullanılır. İşlev nesnelerini (functors), işlev işaretçilerini veya std::function nesnelerini de kullanabilirsiniz. Lambda ifadeleri hakkında daha fazla bilgi için bkz . Lambda İfadeleri.

Numaralandırma işlemini başlatın.

wprintf_s(L"Starting device enumeration...\n");
hr = watcher->Start();
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Numaralandırma işleminin tamamlanmasını bekleyin ve ardından bir ileti yazdırın. Tüm ComPtr ve RAII nesneleri kapsamı bırakır ve otomatik olarak serbest bırakılır.

// Wait for the operation to complete.
WaitForSingleObjectEx(enumerationCompleted.Get(), INFINITE, FALSE);

wprintf_s(L"Enumerated %u devices.\n", deviceCount);

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

Tam örnek aşağıda verilmiştir:

// wrl-consume-events.cpp
// compile with: runtimeobject.lib
#include <Windows.Devices.Enumeration.h>
#include <wrl/event.h>
#include <stdio.h>

using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Foundation;
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()
{
    // Type define the event handler types to make the code more readable.
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_Windows__CDevices__CEnumeration__CDeviceInformation AddedHandler;
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_IInspectable EnumerationCompletedHandler;
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_IInspectable StoppedHandler;

    // Counts the number of enumerated devices.
    unsigned int deviceCount = 0;

    // Event registration tokens that enable us to later unsubscribe from events.
    EventRegistrationToken addedToken;
    EventRegistrationToken stoppedToken;
    EventRegistrationToken enumCompletedToken;

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

    // Create an event that is set after device enumeration 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 enumerationCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
    HRESULT hr = enumerationCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Get the activation factory for the IDeviceWatcher interface.
    ComPtr<IDeviceInformationStatics> watcherFactory;
    hr = ABI::Windows::Foundation::GetActivationFactory(HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation).Get(), &watcherFactory);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create a IDeviceWatcher object from the factory.
    ComPtr<IDeviceWatcher> watcher;
    hr = watcherFactory->CreateWatcher(&watcher);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Subscribe to the Added event.
    hr = watcher->add_Added(Callback<AddedHandler>([&deviceCount](IDeviceWatcher* watcher, IDeviceInformation*) -> HRESULT
    {
        // Print a message and increment the device count.
        // When we reach 10 devices, stop enumerating devices.
        wprintf_s(L"Added device...\n");
        deviceCount++;
        if (deviceCount == 10)
        {
            return watcher->Stop();
        }
        return S_OK;

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

    hr = watcher->add_Stopped(Callback<StoppedHandler>([=, &enumerationCompleted](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
    {
        wprintf_s(L"Device enumeration stopped.\nRemoving event handlers...");

        // Unsubscribe from the events. This is shown for demonstration.
        // The need to remove event handlers depends on the requirements of 
        // your app. For instance, if you only need to handle an event for 
        // a short period of time, you might remove the event handler when you
        // no longer need it. If you handle an event for the duration of the app,
        // you might not need to explicitly remove it.
        HRESULT hr1 = watcher->remove_Added(addedToken);
        HRESULT hr2 = watcher->remove_Stopped(stoppedToken);
        HRESULT hr3 = watcher->remove_EnumerationCompleted(enumCompletedToken);

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

        return FAILED(hr1) ? hr1 : FAILED(hr2) ? hr2 : hr3;

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

    // Subscribe to the EnumerationCompleted event.
    hr = watcher->add_EnumerationCompleted(Callback<EnumerationCompletedHandler>([](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
    {
        wprintf_s(L"Enumeration completed.\n");

        return watcher->Stop();

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

    wprintf_s(L"Starting device enumeration...\n");
    hr = watcher->Start();
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Wait for the operation to complete.
    WaitForSingleObjectEx(enumerationCompleted.Get(), INFINITE, FALSE);

    wprintf_s(L"Enumerated %u devices.\n", deviceCount);

    // All smart pointers and RAII objects go out of scope here.
}
/*
Sample output:
Starting device enumeration...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Device enumeration stopped.
Removing event handlers...
Enumerated 10 devices.
*/

Kod Derleniyor

Kodu derlemek için kopyalayın ve visual studio projesine yapıştırın veya adlı wrl-consume-events.cpp bir dosyaya yapıştırın ve ardından visual studio komut istemi penceresinde aşağıdaki komutu çalıştırın.

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

Ayrıca bkz.

Windows Çalışma Zamanı C++ Şablon Kitaplığı (WRL)

Aracılığıyla paylaş

Nasıl Yapılır: WRL Kullanarak Olayları İşleme

Olaylara Abone Olma ve Olayları İşleme

Kod Derleniyor

Ayrıca bkz.

Geri Bildirim

Ek kaynaklar