Gewusst wie: Aktivieren und Verwenden einer Windows-Runtime-Komponente mit WRL

Artikel
10/12/2023

In diesem Dokument wird gezeigt, wie Sie die Windows-Runtime C++-Vorlagenbibliothek (WRL) zum Initialisieren der Windows-Runtime und zum Aktivieren und Verwenden einer Windows-Runtime Komponente verwenden.

Um eine Komponente zu verwenden, müssen Sie einen Schnittstellenzeiger auf den Typ abrufen, der von der Komponente implementiert wird. Und da die zugrunde liegende Technologie des Windows-Runtime das Component Object Model (COM) ist, müssen Sie COM-Regeln befolgen, um eine Instanz des Typs zu Standard. Beispielsweise müssen Sie die Referenzanzahl Standard beibehalten, die bestimmt, wann der Typ aus dem Arbeitsspeicher gelöscht wird.

Um die Verwendung der Windows-Runtime zu vereinfachen, stellt Windows-Runtime C++-Vorlagenbibliothek die intelligente Zeigervorlage ComPtr <T> bereit, die automatisch die Verweiszählung durchführt. Wenn Sie eine Variable deklarieren, geben Sie ComPtr<den Schnittstellennamenbezeichner> an. Um auf einen Schnittstellenmember zuzugreifen, wenden Sie den Pfeilmemberzugriffsoperator (->) auf den Bezeichner an.

Wichtig

Wenn Sie eine Schnittstellenfunktion aufrufen, testen Sie immer den HRESULT-Rückgabewert.

Aktivieren und Verwenden einer Windows Runtime-Komponente

In den folgenden Schritten wird die Windows::Foundation::IUriRuntimeClass Schnittstelle verwendet, um zu veranschaulichen, wie eine Aktivierungsfactory für eine Windows-Runtime Komponente erstellt, eine Instanz dieser Komponente erstellt und ein Eigenschaftswert abgerufen wird. Außerdem wird gezeigt, wie die Windows-Runtime initialisiert wird. Im Folgenden finden Sie das vollständige Beispiel.

Wichtig

Obwohl Sie in der Regel die Windows-Runtime C++-Vorlagenbibliothek in einer Universelle Windows-Plattform (UWP)-App verwenden, wird in diesem Beispiel eine Konsolen-App zur Veranschaulichung verwendet. Funktionen wie z wprintf_s . B. sind in einer UWP-App nicht verfügbar. Weitere Informationen zu den Typen und Funktionen, die Sie in einer UWP-App verwenden können, finden Sie unter CRT-Funktionen, die in Universelle Windows-Plattform Apps und Win32 und COM für UWP-Apps nicht unterstützt werden.

So aktivieren und verwenden Sie eine Windows Runtime-Komponente

#includeSchließen Sie alle erforderlichen Windows-Runtime, Windows-Runtime C++-Vorlagenbibliothek oder C++-Standardbibliotheksheader ein.
```
#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;
```
Es wird empfohlen, den Code mithilfe der using namespace-Direktive in der CPP-Datei verständlicher zu gestalten.
Initialisieren Sie den Thread, in dem die App ausgeführt wird. Jede App muss ihren Thread und ihr Threadingmodell initialisieren. In diesem Beispiel wird die Microsoft::WRL::Wrappers::RoInitializeWrapper-Klasse verwendet, um die Windows-Runtime zu initialisieren und RO_INIT_MULTITHREADED als Threadmodell angibt. Die RoInitializeWrapper-Klasse ruft Windows::Foundation::Initialize auf, wenn sie erstellt, und Windows::Foundation::Uninitialize, wenn sie zerstört wird.
```
// Initialize the Windows Runtime.
RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
if (FAILED(initialize))
{
    return PrintError(__LINE__, initialize);
}
```
In der zweiten Anweisung gibt der RoInitializeWrapper::HRESULT-Operator den HRESULT von dem Aufruf an Windows::Foundation::Initialize.
Erstellen Sie eine Aktivierungsfactory für die ABI::Windows::Foundation::IUriRuntimeClassFactory Schnittstelle.
```
// 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);
}
```
Die Windows-Runtime verwendet vollqualifizierte Namen, um Typen zu identifizieren. Der RuntimeClass_Windows_Foundation_Uri Parameter ist eine Zeichenfolge, die vom Windows-Runtime bereitgestellt wird und den erforderlichen Laufzeitklassennamen enthält.
Initialisieren Sie eine Microsoft::WRL::Wrappers::HString-Variable , die den URI "https://www.microsoft.com"darstellt.
```
// Create a string that represents a URI.
HString uriHString;
hr = uriHString.Set(L"http://www.microsoft.com");
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}
```
Im Windows-Runtime weisen Sie keinen Speicher für eine Zeichenfolge zu, die vom Windows-Runtime verwendet wird. Stattdessen erstellt der Windows-Runtime eine Kopie der Zeichenfolge in einem Puffer, der von ihr Standard enthält und für Vorgänge verwendet wird, und gibt dann einen Handle an den von ihr erstellten Puffer zurück.

Erstellen Sie mit der IUriRuntimeClassFactory::CreateUri-Factorymethode ein ABI::Windows::Foundation::IUriRuntimeClass-Objekt.

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

Rufen Sie die IUriRuntimeClass::get_Domain-Methode auf, um den Wert der Domain-Eigenschaft abzurufen.

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

Drucken Sie den Domänennamen an die Konsole, und kehren Sie zurück. Alle ComPtr- und RAII-Objekte verlassen den Bereich und werden automatisch freigegeben.
```
// 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.
```
Die WindowsGetStringRawBuffer-Funktion ruft die zugrunde liegende Unicode-Form der URI-Zeichenfolge ab.

Im Folgenden sehen Sie das vollständige Beispiel:

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

Kompilieren des Codes

Um den Code zu kompilieren, kopieren Sie ihn, und fügen Sie ihn dann in ein Visual Studio-Projekt ein, oder fügen Sie ihn in eine Datei ein, die benannt wrl-consume-component.cpp ist, und führen Sie dann den folgenden Befehl in einem Visual Studio-Eingabeaufforderungsfenster aus.

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

Siehe auch

C++-Vorlagenbibliothek für Windows-Runtime (WRL)