Procedura: gestire eventi mediante WRL

Articolo
02/19/2013

In questo documento viene illustrato come utilizzare Libreria di modelli di Windows Runtime C++ (WRL) per sottoscrivere e gestire gli eventi di Windows Runtime oggetto.

Per un esempio più semplice che crea un'istanza del componente e recupera il valore della proprietà, vedere Procedura: attivare e utilizzare un componente Windows Runtime mediante WRL.

Sottoscrivendo su e gestire eventi

I passaggi seguenti avviano un oggetto di ABI::Windows::System::Threading::IDeviceWatcher i gestori eventi di utilizzo da monitorare l'avanzamento.L'interfaccia di IDeviceWatcher consente di enumerare i dispositivi in modo asincrono, o in background e ricevere la notifica quando i controlli vengono aggiunti, rimossi, o vengono modificati.La funzione di Callback rappresenta una parte importante di questo esempio perché consente di specificare i gestori eventi che elaborano i risultati di un'operazione in background.Di seguito viene fornito l'esempio completo.

Attenzione
Sebbene in genere utilizzato WRL in un'applicazione di Windows Store, questo esempio un'applicazione console per completezza.Funzioni come wprintf_s non sono disponibili da un'applicazione di Windows Store.Per ulteriori informazioni sui tipi e le funzioni che è possibile utilizzare in un'applicazione di Windows Store, vedere Funzioni CRT non supportate con /ZW e Win32 e COM per le applicazioni di archivio di Windows.

Sebbene in genere utilizzato WRL in un'applicazione di Windows Store, questo esempio un'applicazione console per completezza.Funzioni come wprintf_s non sono disponibili da un'applicazione di Windows Store.Per ulteriori informazioni sui tipi e le funzioni che è possibile utilizzare in un'applicazione di Windows Store, vedere Funzioni CRT non supportate con /ZW e Win32 e COM per le applicazioni di archivio di Windows.

Importare ()#includequalsiasi Windows Runtimeobbligatorio, WRL, o intestazioni standard di C++.
```
#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 dichiara i tipi necessari per enumerare i dispositivi.

Si consiglia di utilizzare la direttiva di using namespace nel file CPP per rendere il codice più leggibile.

Dichiarare le variabili locali per l'applicazione.In questo esempio viene utilizzato il numero dei dispositivi e dei token enumerati di registrazione che consentono più avanti per annullare la sottoscrizione agli eventi.

// 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;

Inizializzare Windows Runtime.

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

Creare un oggetto di Evento che sincronizza il completamento del processo di enumerazione all'applicazione principale.

// 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));
hr = threadCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

[!NOTA]

Questo evento è solo a scopo dimostrativo come parte di un'applicazione console.In questo esempio viene utilizzato l'evento per garantire che un'operazione async prima di completare la chiusura dell'applicazione.Nella maggior parte delle applicazioni, in genere non si attende le operazioni async per completare.

Creare una factory di attivazione per l'interfaccia di IDeviceWatcher.

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

I nomi completi di utilizzo di Windows Runtime per identificare i tipi.Il parametro di RuntimeClass_Windows_Devices_Enumeration_DeviceInformation è una stringa fornita da Windows Runtime e contiene il nome di classe di runtime richiesto.

Creare l'oggetto di IDeviceWatcher.

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

Utilizzare la funzione di Callback per sottoscrivere a Added, a EnumerationCompleteded eventi di Stopped.

// 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);
}

Il gestore eventi di Added incrementa il conteggio dei dispositivi enumerati.Interrompe il processo di enumerazione dopo dieci dispositivi si trovano.

Il gestore eventi di Stopped rimuovere i gestori eventi e imposta l'evento di completamento.

Il gestore eventi di EnumerationCompleted interrompe il processo di enumerazione.Gestiamo questo evento nel caso siano meno che dieci dispositivi.

Suggerimento
Questo esempio utilizza un'espressione lambda per definire i callback.È anche possibile utilizzare oggetti funzione (functors), puntatori a funzione, oggetti o di std::function.Per ulteriori informazioni sulle espressioni lambda, vedere Espressioni lambda in C++.

Avviare il processo di enumerazione.

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

Attendere il processo di enumerazione per completare e stampare un messaggio.Qualsiasi ComPtr e gli oggetti RAII consentono all'ambito e vengono eliminati automaticamente.

// 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.

Di seguito è riportato l'esempio completo:

// 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));
    hr = threadCompleted.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;
    HRESULT 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.
*/

Compilazione del codice

Per compilare il codice, copiarlo e quindi incollarlo in un progetto di Visual Studio, oppure incollarlo in un file denominato wrl-consume-events.cpp quindi viene eseguito il comando seguente in una finestra del prompt dei comandi di Visual Studio.

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

Vedere anche

Concetti

Libreria di modelli di Windows Runtime C++ (WRL)

Condividi tramite

Procedura: gestire eventi mediante WRL

Sottoscrivendo su e gestire eventi

Compilazione del codice

Vedere anche

Concetti

Risorse aggiuntive