Freigeben über

Implementieren eines Feedanbieters in einer Win32-App (C++/WinRT)

Hinweis

Einige Informationen beziehen sich auf Vorabversionen, die vor der kommerziellen Freigabe grundlegend geändert werden können. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Dieser Artikel führt Sie durch die Erstellung eines einfachen Feedanbieters, der einen Feed-Inhalts-URI registriert und die Schnittstelle IFeedProvider implementiert. Die Methoden dieser Schnittstelle werden vom Widgets Board aufgerufen, um benutzerdefinierte Abfrage-Zeichenkettenparameter anzufordern, in der Regel zur Unterstützung von Authentifizierungsszenarien. Feedanbieter können einen einzelnen Feed oder mehrere Feeds unterstützen.

Informationen zum Implementieren eines Feedanbieters mithilfe von C++/WinRT finden Sie unter Implementieren eines Feedanbieters in einer C# Windows-App (C++/WinRT).

Voraussetzungen

  • Auf Ihrem Gerät muss der Entwicklermodus aktiviert sein. Weitere Informationen finden Sie unter "Einstellungen für Entwickler".
  • Visual Studio 2022 oder höher, mit der Workload für die UWP-Entwicklung. Stellen Sie sicher, dass Sie die Komponente für C++ (v143) aus der optionalen Dropdownliste hinzufügen.

Erstellen einer neuen Win32-Konsolen-App in C++/WinRT

Erstellen Sie in Visual Studio ein neues Projekt. Legen Sie im Dialogfeld Neues Projekt erstellen den Sprachfilter auf „C++“ und den Plattformfilter auf „Windows“ fest, und wählen Sie dann die Projektvorlage „Windows-Konsolenanwendung (C++/WinRT)“ aus. Nennen Sie das neue Projekt „ExampleFeedProvider“. Stellen Sie sicher, dass Platzieren Sie die Lösung und das Projekt im selben Verzeichnis deaktiviert ist. Wenn Sie dazu aufgefordert werden, legen Sie die Windows-Version für die App auf Version 10.022631.2787 oder höher fest.

Hinzufügen von Verweisen auf die NuGet-Pakete des Windows App SDK und der Windows-Implementierungsbibliothek

In diesem Beispiel wird das neueste stabile NuGet-Paket der Windows App SDK verwendet. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf Verweise, und wählen Sie NuGet-Pakete verwalten... aus. Wählen Sie im NuGet-Paket-Manager die Registerkarte Durchsuchen aus, und suchen Sie nach „Microsoft.WindowsAppSDK“. Wählen Sie in der Dropdownliste Version die neueste stabile Version aus, und klicken Sie dann auf Installieren.

In diesem Beispiel wird auch das NuGet-Paket der Windows-Implementierungsbibliothek verwendet. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf Verweise, und wählen Sie NuGet-Pakete verwalten... aus. Wählen Sie im NuGet-Paket-Manager die Registerkarte Durchsuchen aus, und suchen Sie nach „Microsoft.Windows.ImplementationLibrary“. Wählen Sie in der Dropdownliste Version die neueste Version aus, und klicken Sie dann auf Installieren.

Fügen Sie in der vorkompilierten Headerdatei „pch.h“ die folgenden include-Anweisungen hinzu.

//pch.h 
#pragma once
#include <wil/cppwinrt.h>
#include <wil/resource.h>
...
#include <winrt/Microsoft.Windows.Widgets.Providers.h>

Hinweis

Sie müssen zuerst den wil/cppwinrt.h-Header vor allen WinRT-Headern angeben.

Um das Herunterfahren der Feedanbieter-App ordnungsgemäß zu behandeln, wird eine benutzerdefinierte Implementierung von winrt::get_module_lock benötigt. Die in der Datei „main.cpp“ definierte SignalLocalServerShutdown-Methode wird vorab deklariert, und ein Ereignis wird festgelegt, das signalisiert, dass die App beendet werden soll. Fügen Sie der Datei „pch.h“ direkt unterhalb der #pragma once-Direktive vor den anderen include-Anweisungen den folgenden Code hinzu.

//pch.h
#include <stdint.h>
#include <combaseapi.h>

// In .exe local servers the class object must not contribute to the module ref count, and use
// winrt::no_module_lock, the other objects must and this is the hook into the C++ WinRT ref counting system
// that enables this.
void SignalLocalServerShutdown();

namespace winrt
{
    inline auto get_module_lock() noexcept
    {
        struct service_lock
        {
            uint32_t operator++() noexcept
            {
                return ::CoAddRefServerProcess();
            }

            uint32_t operator--() noexcept
            {
                const auto ref = ::CoReleaseServerProcess();

                if (ref == 0)
                {
                    SignalLocalServerShutdown();
                }
                return ref;
            }
        };

        return service_lock{};
    }
}


#define WINRT_CUSTOM_MODULE_LOCK

Hinzufügen einer FeedProvider-Klasse zur Handhabung von Feedvorgängen

Klicken Sie in Visual Studio im ExampleFeedProvider mit der rechten Maustaste auf das Projekt , und wählen Sie Hinzufügen -> Klasse aus. Nennen Sie die Klasse im Dialogfeld Klasse hinzufügen „FeedProvider“, und klicken Sie dann auf Hinzufügen.

Deklarieren einer Klasse, die die IFeedProvider-Schnittstelle implementiert

Die IFeedProvider-Schnittstelle definiert Methoden, die das Widget Board aufruft, um Vorgänge mit dem Feedanbieter zu initiieren. Ersetzen Sie die leere Klassendefinition in der Datei „FeedProvider.h“ durch den folgenden Code. Dieser Code deklariert eine Struktur, die die IFeedProvider-Schnittstelle implementiert, sowie Prototypen für die Schnittstellenmethoden.

// FeedProvider.h
#pragma once
struct FeedProvider : winrt::implements<FeedProvider, winrt::Microsoft::Windows::Widgets::Feeds::Providers::IFeedProvider>
{
    FeedProvider() {}

    /* IFeedrovider required functions that need to be implemented */
    void OnFeedProviderEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderEnabledArgs args);
    void OnFeedProviderDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderDisabledArgs args);
    void OnFeedEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedEnabledArgs args);
    void OnFeedDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedDisabledArgs args);
    void OnCustomQueryParametersRequested(winrt::Microsoft::Windows::Widgets::Feeds::Providers::CustomQueryParametersRequestedArgs args);
    /* IFeedProvider required functions that need to be implemented */

};

Implementieren der IFeedProvider-Methoden

In den nächsten Abschnitten werden die Methoden der IFeedProvider-Schnittstelle implementiert. Bevor Sie sich mit den Schnittstellenmethoden vertraut machen, fügen Sie die folgenden Zeilen nach den include-Anweisungen zu FeedProvider.cpp hinzu, um die Feedanbieter-APIs in den winrt-Namespace zu pullen und den Zugriff auf die Karte zuzulassen, die im vorherigen Schritt deklariert wurde.

Hinweis

Objekte, die an die Rückrufmethoden der IFeedProvider-Schnittstelle übergeben werden, sind nur innerhalb des Rückrufs gültig. Sie sollten keine Verweise auf diese Objekte speichern, da ihr Verhalten außerhalb des Kontexts des Rückrufs nicht definiert ist.

// WidgetProvider.cpp
namespace winrt
{
    using namespace Microsoft::Windows::Widgets::Feeds::Providers;
}

OnFeedProviderEnabled

Die OnFeedProviderEnabled-Methode wird aufgerufen, wenn ein mit dem Anbieter verknüpfter Feed vom Widgets Board-Host erstellt wird. In der Implementierung dieser Methode generieren Sie eine Abfragezeichenkette mit den Parametern, die an die URL übergeben werden, die den Feed-Inhalt bereitstellt, einschließlich aller erforderlichen Authentifizierungstoken. Erstellen Sie eine Instanz von CustomQueryParametersUpdateOptions, und übergeben Sie die FeedProviderDefinitionId aus den Ereignisargumenten, die den aktivierten Feed identifiziert, sowie die Abfragezeichenkette. Holen Sie sich den Standard-FeedManager und rufen Sie SetCustomQueryParameters auf, um die Abfragezeichenkettenparameter beim Widgets Board zu registrieren.

// FeedProvider.cs
void FeedProvider::OnFeedProviderEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderEnabledArgs args)
{
    std::wstringstream wstringstream;
wstringstream << args.FeedProviderDefinitionId().c_str() << L" feed provider was enabled." << std::endl;
    _putws(wstringstream.str().c_str());

    auto updateOptions = winrt::CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId(), L"param1&param2");
    winrt::FeedManager::GetDefault().SetCustomQueryParameters(updateOptions);
}

BeiDeaktiviertemFeedProvider

OnFeedProviderDisabled wird aufgerufen, wenn das Widgets Board alle Feeds für diesen Anbieter deaktiviert hat. Feedanbieter müssen keine Aktionen als Reaktion auf diesen Methodenaufruf ausführen. Der Methodenaufruf kann zu Telemetriezwecken oder zur Aktualisierung der Abfragezeichenkettenparameter oder zum Widerruf von Authentifizierungstoken verwendet werden, falls erforderlich. Wenn die App nur einen einzelnen Feedanbieter unterstützt oder alle von der App unterstützten Feedanbieter deaktiviert wurden, kann die App als Reaktion auf diesen Rückruf beendet werden.

// FeedProvider.cs

void FeedProvider::OnFeedProviderDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderDisabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedProviderDefinitionId().c_str() << L" feed provider was disabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

BeiFeedAktiviert, BeiFeedDeaktiviert

OnFeedEnabled und OnFeedDisabled werden vom Widgets Board aufgerufen, wenn ein Feed aktiviert oder deaktiviert ist. Feedanbieter müssen keine Aktionen als Reaktion auf diese Methodenaufrufe ausführen. Der Methodenaufruf kann zu Telemetriezwecken oder zur Aktualisierung der Abfragezeichenkettenparameter oder zum Widerruf von Authentifizierungstoken verwendet werden, falls erforderlich.

// FeedProvider.cs

void FeedProvider::OnFeedEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedEnabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedDefinitionId().c_str() << L" feed was enabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

// FeedProvider.cs

void FeedProvider::OnFeedDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedDisabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedDefinitionId().c_str() << L" feed was disabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

BeiAnforderungBenutzerdefinierterAbfrageparameter

OnCustomQueryParametersRequested wird ausgelöst, wenn das Widgets Board feststellt, dass die mit dem Feedanbieter verbundenen benutzerdefinierten Abfrageparameter aktualisiert werden müssen. Diese Methode kann beispielsweise ausgelöst werden, wenn der Vorgang zum Abrufen von Feedinhalten aus dem Remote-Webdienst fehlschlägt. Die FeedProviderDefinitionId-Eigenschaft der an diese Methode übergebenen CustomQueryParametersRequestedArgs gibt den Feed an, für den Abfragezeichenkettenparameter angefordert werden. Der Anbieter sollte die Abfragezeichenkette neu generieren und zurück an das Widgets Board übergeben, indem er SetCustomQueryParameters aufruft.

// FeedProvider.cs

void FeedProvider::OnCustomQueryParametersRequested(winrt::Microsoft::Windows::Widgets::Feeds::Providers::CustomQueryParametersRequestedArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << L"CustomQueryParameters were requested for " << args.FeedProviderDefinitionId().c_str() << std::endl;
    _putws(wstringstream.str().c_str());

    auto updateOptions = winrt::CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId(), L"param1&param2");
    winrt::FeedManager::GetDefault().SetCustomQueryParameters(updateOptions);
}

Registrieren einer Klassenfactory, die FeedProvider bei Bedarf instanziiert

Fügen Sie den Header, der die FeedProvider-Klasse definiert, zu den include-Anweisungen am Anfang der main.cpp-Datei Ihrer App hinzu. Hier wird auch mutex eingefügt.

// main.cpp
...
#include "FeedProvider.h"
#include <mutex>

Deklarieren Sie das Ereignis, das das Beenden der App auslöst, und die SignalLocalServerShutdown-Funktion, die das Ereignis festlegt. Fügen Sie den folgenden Code in die Datei „main.cpp“ ein.

// main.cpp
wil::unique_event g_shudownEvent(wil::EventOptions::None);

void SignalLocalServerShutdown()
{
    g_shudownEvent.SetEvent();
}

Als Nächstes müssen Sie eine CLSID erstellen, die verwendet wird, um Ihren Feedanbieter für die COM-Aktivierung zu identifizieren. Generieren Sie eine GUID in Visual Studio, indem Sie zu Tools -> GUID erstellen wechseln. Wählen Sie die Option „static const GUID =“ aus, klicken Sie auf Kopieren, und fügen Sie sie dann in main.cpp ein. Aktualisieren Sie die GUID-Definition mit der folgenden C++/WinRT-Syntax, und legen Sie den GUID-Variablennamen auf „feed_provider_clsid“ fest. Behalten Sie die kommentierte Version der GUID bei, da Sie dieses Format später beim Packen Ihrer App benötigen.

// main.cpp
...
// {80F4CB41-5758-4493-9180-4FB8D480E3F5}
static constexpr GUID feed_provider_clsid
{
    0x80f4cb41, 0x5758, 0x4493, { 0x91, 0x80, 0x4f, 0xb8, 0xd4, 0x80, 0xe3, 0xf5 }
};

Fügen Sie die folgende Klassenfactorydefinition zu main.cpp hinzu. Dabei handelt es sich hauptsächlich um Bausteincode, der nicht spezifisch für Feedanbieterimplementierungen bestimmt ist. Beachten Sie, dass CoWaitForMultipleObjects wartet, bis das Herunterfahren-Ereignis ausgelöst wird, bevor die App beendet wird.

// main.cpp
template <typename T>
struct SingletonClassFactory : winrt::implements<SingletonClassFactory<T>, IClassFactory>
{
    STDMETHODIMP CreateInstance(
        ::IUnknown* outer,
        GUID const& iid,
        void** result) noexcept final
    {
        *result = nullptr;

        std::unique_lock lock(mutex);

        if (outer)
        {
            return CLASS_E_NOAGGREGATION;
        }

        if (!instance)
        {
            instance = winrt::make<FeedProvider>();
        }

        return instance.as(iid, result);
    }

    STDMETHODIMP LockServer(BOOL) noexcept final
    {
        return S_OK;
    }

private:
    T instance{ nullptr };
    std::mutex mutex;
};

int main()
{
    winrt::init_apartment();
    wil::unique_com_class_object_cookie feedProviderFactory;
    auto factory = winrt::make<SingletonClassFactory<winrt::Microsoft::Windows::Widgets::Feeds::Providers::IFeedProvider>>();

    winrt::check_hresult(CoRegisterClassObject(
        feed_provider_clsid,
        factory.get(),
        CLSCTX_LOCAL_SERVER,
        REGCLS_MULTIPLEUSE,
        feedProviderFactory.put()));

    DWORD index{};
    HANDLE events[] = { g_shudownEvent.get() };
    winrt::check_hresult(CoWaitForMultipleObjects(CWMO_DISPATCH_CALLS | CWMO_DISPATCH_WINDOW_MESSAGES,
        INFINITE,
        static_cast<ULONG>(std::size(events)), events, &index));

    return 0;
}

Packen der Feedanbieter-App

Im aktuellen Release können nur gepackte Apps als Feedanbieter registriert werden. Die folgenden Schritte führen Sie durch den Vorgang zum Packen Ihrer App und zum Aktualisieren des App-Manifests, um Ihre App beim Betriebssystem als Feedanbieter zu registrieren.

Erstellen eines MSIX-Paketerstellungsprojekts

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihre Projektmappe, und wählen Sie Hinzufügen -> Neues Projekt... aus. Wählen Sie im Dialogfeld Neues Projekt hinzufügen die Vorlage „Paketerstellungsprojekt für Windows-Anwendungen“ aus, und klicken Sie auf Weiter. Legen Sie den Projektnamen auf „ExampleFeedProviderPackage“ fest, und klicken Sie auf Erstellen. Wenn Sie dazu aufgefordert werden, legen Sie die Zielversion auf Version 1809 oder höher fest, und klicken Sie auf OK. Klicken Sie als Nächstes mit der rechten Maustaste auf das Projekt „ExampleFeedProviderPackage“, und wählen Sie Hinzufügen –> Projektverweis aus. Wählen Sie das Projekt ExampleFeedProvider aus, und klicken Sie auf „OK“.

Hinzufügen eines Windows App SDK-Paketverweises zum Paketprojekt

Sie müssen dem MSIX-Paketprojekt einen Verweis auf das NuGet-Paket des Windows App SDK hinzufügen. Doppelklicken Sie im Projektmappen-Explorer auf das Projekt „ExampleFeedProviderPackage“, um die Datei „ExampleFeedProviderPackage.wapproj“ zu öffnen. Fügen Sie im Project-Element den folgenden XML-Code hinzu.

<!--ExampleFeedProviderPackage.wapproj-->
<ItemGroup>
    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.231116003-experimentalpr">
        <IncludeAssets>build</IncludeAssets>
    </PackageReference>  
</ItemGroup>

Hinweis

Stellen Sie sicher, dass die im PackageReference-Element angegebene Version mit der neuesten stabilen Version übereinstimmt, auf die Sie im vorherigen Schritt verwiesen haben.

Wenn die richtige Version des Windows App SDK bereits auf dem Computer installiert ist und Sie die SDK-Runtime nicht in Ihrem Paket bündeln möchten, können Sie die Paketabhängigkeit in der Datei „Package.appxmanifest“ für das Projekt „ExampleFeedProviderPackage“ angeben.

<!--Package.appxmanifest-->
...
<Dependencies>
...
    <PackageDependency Name="Microsoft.WindowsAppRuntime.1.5.233430000-experimental1" MinVersion="2000.638.7.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
...
</Dependencies>
...

Aktualisieren des Paketmanifests

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Datei Package.appxmanifest, und wählen Sie Code anzeigen aus, um die XML-Datei des Manifests zu öffnen. Als Nächstes müssen Sie einige Namespacedeklarationen für die verwendeten App-Paketerweiterungen hinzufügen. Fügen Sie dem Package-Element der obersten Ebene die folgenden Namespacedefinitionen hinzu.

<!-- Package.appmanifest -->
<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"

Erstellen Sie im Application-Element ein neues leeres Element namens Extensions. Stellen Sie sicher, dass Sie dieses Element nach dem schließenden Tag für uap:VisualElements angeben.

<!-- Package.appxmanifest -->
<Application>
...
    <Extensions>

    </Extensions>
</Application>

Die erste Erweiterung, die hinzugefügt werden muss, ist die ComServer-Erweiterung. Dadurch wird der Einstiegspunkt der ausführbaren Datei beim Betriebssystem registriert. Diese Erweiterung ist das Paket-App-Äquivalent zur Registrierung eines COM-Servers durch Festlegen eines Registrierungsschlüssels und nicht spezifisch für Feedanbieter. Fügen Sie das folgende com:Extension-Element als untergeordnetes Element des Elements Extensions hinzu. Ändern Sie die GUID im Id-Attribut des com:Class-Elements in die GUID, die Sie in einem vorherigen Schritt generiert haben.

<!-- Package.appxmanifest -->
<Extensions>
    <com:Extension Category="windows.comServer">
        <com:ComServer>
            <com:ExeServer Executable="ExampleFeedProvider\ExampleFeedProvider.exe" Arguments="-RegisterProcessAsComServer" DisplayName="C++ Feed Provider App">
                <com:Class Id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" DisplayName="FeedProvider" />
            </com:ExeServer>
        </com:ComServer>
    </com:Extension>
</Extensions>

Fügen Sie als Nächstes die Erweiterung hinzu, die die App als Feedanbieter registriert. Fügen Sie das uap3:Extension-Element als untergeordnetes Element des Extensions-Elements in den folgenden Codeausschnitt ein. Ersetzen Sie das ClassId-Attribut des COM-Elements durch die GUID, die Sie in den vorherigen Schritten verwendet haben.

<!-- Package.appxmanifest -->
<Extensions>
    ...
    <uap3:Extension Category="windows.appExtension">
        <uap3:AppExtension Name="com.microsoft.windows.widgets.feeds" DisplayName="ContosoFeed" Id="com.examplewidgets.examplefeed" PublicFolder="Public">
            <uap3:Properties>
                <FeedProvider Icon="ms-appx:Assets\StoreLogo.png" Description="FeedDescription">
                    <Activation>
                        <!-- Apps exports COM interface which implements IFeedProvider -->
                        <CreateInstance ClassId="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" />
                    </Activation>
                    <Definitions>
                        <Definition Id="Contoso_Feed"
                            DisplayName="Contoso_Feed Feed"
                            Description="Feed representing Contoso"
                            ContentUri="https://www.contoso.com/"
                            Icon="ms-appx:Images\StoreLogo.png">
                        </Definition>
                        <Definition Id="Fabrikam_Feed"
                            DisplayName="Fabrikam Feed"
                            Description="Feed representing Example"
                            ContentUri="https://www.fabrikam.com/"
                            Icon="ms-appx:Images\StoreLogo.png">
                        </Definition>
                    </Definitions>
                </FeedProvider>
            </uap3:Properties>
        </uap3:AppExtension>
    </uap3:Extension>
</Extensions>

Ausführliche Beschreibungen und Formatinformationen für all diese Elemente finden Sie unter XML-Format des Feedanbieter-Paketmanifests.

Hinzufügen von Symbolen zu Ihrem Paketerstellungsprojekt

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr ExampleFeedProviderPackage, und wählen Sie Hinzufügen –> Neuer Ordner aus. Nennen Sie diesen Ordner „ProviderAssets“, da dies das ist, was im Package.appxmanifest im vorherigen Schritt verwendet wurde. Hier speichern wir unser Symbol für unsere Feeds. Nachdem Sie die gewünschten Symbole und Screenshots hinzugefügt haben, stellen Sie sicher, dass die Bildnamen mit dem übereinstimmen, was nach Path=ProviderAssets\ in Ihrem Package.appxmanifest steht, oder die Feeds werden nicht im Widgets Board angezeigt.

Testen des Feedanbieters

Stellen Sie sicher, dass Sie in der Dropdownliste Projektmappenplattformen die Architektur ausgewählt haben, die Ihrem Entwicklungscomputer entspricht, z. B. „x64“. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, und wählen Sie Projektmappe erstellen aus. Klicken Sie anschließend mit der rechten Maustaste auf Ihr ExampleWidgetProviderPackage, und wählen Sie Bereitstellen aus. Die Konsolenanwendung sollte bei der Bereitstellung starten und Sie werden sehen, dass die Feeds in der Konsolenausgabe aktiviert werden. Öffnen Sie das Widgets Board. Sie sollten die neuen Feeds auf den Registerkarten am oberen Rand des Feeds-Abschnitts sehen.

Debuggen des Feedanbieters

Nachdem Sie Ihre Feeds angeheftet haben, startet die Widgetplattform Ihre Feedanbieteranwendung, um relevante Informationen über den Feed zu empfangen und zu senden. Zum Debuggen des ausgeführten Feeds können Sie entweder einen Debugger an die ausgeführte Feedanbieteranwendung anfügen oder Visual Studio so einrichten, dass das Debuggen des Feedanbieterprozesses nach dem Start automatisch gestartet wird.

Zum Anfügen an den ausgeführten Prozess:

  1. Klicken Sie in Visual Studio auf Debuggen -> An den Prozess anhängen.
  2. Filtern Sie die Prozesse, und suchen Sie ihre gewünschte Feedanbieteranwendung.
  3. Fügen Sie den Debugger an.

Zum Anfügen des Debuggers an den Prozess beim erstmaligen Start:

  1. Klicken Sie in Visual Studio auf Debuggen -> Andere Debugziele -> Installiertes App-Paket debuggen aus.
  2. Filtern Sie die Pakete, und suchen Sie ihr gewünschtes Feedanbieterpaket.
  3. Wählen Sie es aus, und aktivieren Sie das Kontrollkästchen „Eigenen Code zunächst nicht starten, sondern debuggen“.
  4. Klicken Sie auf Anfügenaus.

Konvertieren Sie Ihre Konsolen-App in eine Windows-App

So konvertieren Sie die in dieser exemplarischen Vorgehensweise erstellte Konsolen-App in eine Windows-App:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt „ExampleWidgetProvider“, und wählen Sie Eigenschaften aus. Navigieren Sie zu Linker -> System, und ändern Sie SubSystem von „Konsole“ in „Windows“. Dies kann auch durch Hinzufügen von <SubSystem>Windows</SubSystem> zum Abschnitt <Link>..</Link> der VCXPROJ-Datei erfolgen.
  2. Ändern Sie in der Datei „main.cpp“ int main() in int WINAPI wWinMain(_In_ HINSTANCE /*hInstance*/, _In_opt_ HINSTANCE /*hPrevInstance*/, _In_ PWSTR pCmdLine, _In_ int /*nCmdShow*/).

Ein Screenshot der Eigenschaften des C++-Feedanbieterprojekts, wobei der Ausgabetyp auf „Windows-Anwendung“ festgelegt ist

Veröffentlichen Ihrer Feedanbieter-App

Nachdem Sie Ihren Feedanbieter entwickelt und getestet haben, können Sie Ihre App im Microsoft Store veröffentlichen, damit Benutzer Ihre Feeds auf ihren Geräten installieren können. Eine schrittweise Anleitung zum Veröffentlichen einer App finden Sie unter Veröffentlichen Ihrer App im Microsoft Store.

Die Feeds Store-Sammlung

Nachdem Ihre App im Microsoft Store veröffentlicht wurde, können Sie anfordern, dass Ihre App in die Feeds Store-Sammlung aufgenommen wird, mit der Benutzer Apps entdecken können, die Windows-Feeds enthalten. Informationen zum Übermitteln Ihrer Anfrage finden Sie unter "Übermitteln Ihres Feeds/Boards" zur Ergänzung zur Store-Sammlung.

  • Last updated on