Comment : activer et utiliser un composant Windows Runtime Component à l'aide de WRL

Ce document montre comment utiliser la bibliothèque de modèles C++ Windows Runtime pour initialiser Windows Runtime et comment activer et utiliser un composant Windows Runtime.

Pour utiliser un composant, vous devez acquérir un pointeur d’interface vers le type implémenté par le composant. Et étant donné que la technologie sous-jacente de Windows Runtime est le modèle objet de composant (COM), vous devez suivre les règles COM pour gérer une instance du type. Par exemple, vous devez conserver le nombre de références qui détermine quand le type est supprimé de la mémoire.

Pour simplifier l’utilisation de Windows Runtime, la bibliothèque de modèles C++ Windows Runtime fournit le modèle de pointeur intelligent, ComPtr<T>, qui effectue automatiquement le comptage des références. Lorsque vous déclarez une variable, spécifiez ComPtr<l’identificateur de nom> d’interface. Pour accéder à un membre d’interface, appliquez l’opérateur d’accès aux membres de flèche (->) à l’identificateur.

Activation et utilisation d’un composant Windows Runtime

Les étapes suivantes utilisent l’interface Windows::Foundation::IUriRuntimeClass pour montrer comment créer une fabrique d’activation pour un composant Windows Runtime, créer une instance de ce composant et récupérer une valeur de propriété. Ils montrent également comment initialiser Windows Runtime. L’exemple complet suit.

Pour activer et utiliser un composant Windows Runtime

1. Incluez (#include) tous les en-têtes de bibliothèque de modèles Windows Runtime, C++ C++ standard requis.

   #include <Windows.Foundation.h>
   #include <wrl\wrappers\corewrappers.h>
   #include <wrl\client.h>
   #include <stdio.h>
   
   using namespace ABI::Windows::Foundation;
   using namespace Microsoft::WRL;
   using namespace Microsoft::WRL::Wrappers;
   

   Nous vous recommandons d'utiliser la directive using namespace dans votre fichier .cpp pour rendre le code plus lisible.

2. Initialisez le thread dans lequel l’application s’exécute. Chaque application doit initialiser son modèle thread et threading. Cet exemple utilise la classe Microsoft ::WRL ::Wrappers ::RoInitializeWrapper pour initialiser Windows Runtime et spécifie RO_INIT_MULTITHREADED comme modèle de thread. La RoInitializeWrapper classe appelle Windows::Foundation::Initialize à la construction, et Windows::Foundation::Uninitialize quand elle est détruite.

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

   Dans la deuxième instruction, l’opérateur RoInitializeWrapper ::HRESULT retourne l’appel à .Windows::Foundation::InitializeHRESULT

3. Créez une fabrique d’activation pour l’interfaceABI::Windows::Foundation::IUriRuntimeClassFactory.

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

   Windows Runtime utilise des noms complets pour identifier les types. Le RuntimeClass_Windows_Foundation_Uri paramètre est une chaîne fournie par Windows Runtime et contient le nom de classe runtime requis.

4. Initialisez une variable Microsoft ::WRL ::Wrappers ::HString qui représente l’URI "https://www.microsoft.com".

   // Create a string that represents a URI.
   HString uriHString;
   hr = uriHString.Set(L"http://www.microsoft.com");
   if (FAILED(hr))
   {
       return PrintError(__LINE__, hr);
   }
   

   Dans Windows Runtime, vous n’allouez pas de mémoire pour une chaîne que Windows Runtime utilisera. Au lieu de cela, Windows Runtime crée une copie de votre chaîne dans une mémoire tampon qu’elle gère et utilise pour les opérations, puis retourne un handle à la mémoire tampon qu’elle a créée.

5. Utilisez la IUriRuntimeClassFactory::CreateUri méthode de fabrique pour créer un ABI::Windows::Foundation::IUriRuntimeClass objet.

   // Create the IUriRuntimeClass object.
   ComPtr<IUriRuntimeClass> uri;
   hr = uriFactory->CreateUri(uriHString.Get(), &uri);
   if (FAILED(hr))
   {
       return PrintError(__LINE__, hr);
   }
   

6. Appelez la IUriRuntimeClass::get_Domain méthode pour récupérer la valeur de la Domain propriété.

   // Get the domain part of the URI.
   HString domainName;
   hr = uri->get_Domain(domainName.GetAddressOf());
   if (FAILED(hr))
   {
       return PrintError(__LINE__, hr);
   }
   

7. Imprimez le nom de domaine dans la console et revenez. Tous les objets ComPtr et RAII quittent la portée et sont libérés automatiquement.

   // Print the domain name and return.
   wprintf_s(L"Domain name: %s\n", domainName.GetRawBuffer(nullptr));
   
   // All smart pointers and RAII objects go out of scope here.
   

   La fonction WindowsGetStringRawBuffer récupère la forme Unicode sous-jacente de la chaîne d’URI.

Voici l’exemple complet :

// wrl-consume-component.cpp
// compile with: runtimeobject.lib
#include <Windows.Foundation.h>
#include <wrl\wrappers\corewrappers.h>
#include <wrl\client.h>
#include <stdio.h>

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()
{
    // Initialize the Windows Runtime.
    RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
    if (FAILED(initialize))
    {
        return PrintError(__LINE__, initialize);
    }

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

    // Create a string that represents a URI.
    HString uriHString;
    hr = uriHString.Set(L"http://www.microsoft.com");
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create the IUriRuntimeClass object.
    ComPtr<IUriRuntimeClass> uri;
    hr = uriFactory->CreateUri(uriHString.Get(), &uri);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Get the domain part of the URI.
    HString domainName;
    hr = uri->get_Domain(domainName.GetAddressOf());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Print the domain name and return.
    wprintf_s(L"Domain name: %s\n", domainName.GetRawBuffer(nullptr));

    // All smart pointers and RAII objects go out of scope here.
}
/*
Output:
Domain name: microsoft.com
*/

Compilation du code

Pour compiler le code, copiez-le, collez-le dans un projet Visual Studio ou collez-le dans un fichier nommé wrl-consume-component.cpp , puis exécutez la commande suivante dans une fenêtre d’invite de commandes Visual Studio.

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

Voir aussi

Bibliothèque de modèles C++ Windows Runtime (WRL)