Schnellstart: Pushbenachrichtigungen im Windows App SDK

In dieser Schnellstartanleitung erstellen Sie eine Desktopanwendung Windows, die Pushbenachrichtigungen mithilfe der Windows App SDK sendet und empfängt.

Prerequisites

• Start developing Windows apps
• Erstellen Sie entweder Ein neues Projekt, das das Windows App SDK ODER Verwenden Sie die Windows App SDK in einem vorhandenen Projekt
• Eine Azure Account ist erforderlich, um Windows App SDK Pushbenachrichtigungen zu verwenden.
• Lesen Sie die Übersicht zu Push-Benachrichtigungen

Verpackungsanforderungen

Pushbenachrichtigungen in der Windows App SDK unterstützen sowohl verpackte als auch wirklich entpackte Desktop-Apps. Die Paketidentität ist jedoch für die Hintergrundbereitstellung und COM-Aktivierung erforderlich – das am häufigsten verwendete Produktionsszenario. In der folgenden Tabelle wird zusammengefasst, was auf Der Grundlage Ihres Verpackungsmodells erforderlich ist:

Beispiel-App

In dieser Schnellstartanleitung wird erklärt, wie Sie Ihrer App unter Windows App SDK 1.7 die Unterstützung für Push-Benachrichtigungen hinzufügen. Sehen Sie sich in den Beispiel-Apps, die auf GitHub gefunden wurden, ähnlichen Code zu dieser Schnellstartanleitung an. Überprüfen Sie unbedingt die branch mit Ihrer bevorzugten Version der Windows App SDK für die Beispiele, die ihrem Projekt am besten entsprechen.

Sie können auch Beispiele für jede Version von Windows App SDK finden, indem Sie einen Versionszweig im Beispiel-Repository auswählen.

API-Referenz

Api-Referenzdokumentation für Pushbenachrichtigungen finden Sie unter Microsoft.Windows. PushNotifications-Namespace.

Konfigurieren der Identität Ihrer App in Azure Active Directory (AAD)

Pushbenachrichtigungen in der Windows App SDK verwenden Identitäten aus Azure Active Directory (AAD). Azure Anmeldeinformationen sind beim Anfordern eines WNS-Kanal-URI und beim Anfordern von Zugriffstoken erforderlich, um Pushbenachrichtigungen zu senden. Hinweis: Wir unterstützen nicht die Verwendung von Windows App SDK Pushbenachrichtigungen mit Microsoft Partner Center.

Schritt 1: Erstellen einer AAD-App-Registrierung

Melden Sie sich bei Ihrem Azure Konto an, und erstellen Sie eine neue AAD-App-RegistrierungRessource. Wählen Sie Neue Registrierung aus.

Schritt 2: Geben Sie einen Namen ein, und wählen Sie eine Option für mehrere Mandanten aus.

1. Geben Sie einen App-Namen an.

2. Pushbenachrichtigungen erfordern die Option für mehrere Mandanten. Wählen Sie dies also aus.

   1. Weitere Informationen zu Benutzern finden Sie unter Wer kann sich in Ihrer App anmelden?.

3. Wählen Sie Registrieren aus.

4. Notieren Sie sich Ihre Application (Client)-ID, da dies Ihre Azure AppId ist, die Sie während der Aktivierungsregistrierung und Zugriffstokenanforderung verwenden.

5. Notieren Sie sich Ihre Directory(Mandant)-ID, da dies Ihre Azure TenantId ist, die Sie beim Anfordern eines Zugriffstokens verwenden werden.

   Important

   Merken Sie sich die Anwendungs-ID (Client-ID) und die Verzeichnis-ID (Mandanten-ID) .

6. Notieren Sie sich Ihre Object-ID, da dies Ihre Azure ObjectId ist, die Sie beim Anfordern einer Kanalanforderung verwenden werden. Beachten Sie, dass dies NICHT die Objekt-ID ist, die auf der Essentials-Seite aufgeführt ist. Um die richtige Objekt-IDzu finden, klicken Sie stattdessen im Feld der verwalteten Anwendung im lokalen Verzeichnis auf den App-Namen auf der Seite Essentials.

   

   

   Note

   Ein Serviceprinzipal ist erforderlich, um eine Objekt-ID abzurufen, wenn keine ihrer App zugeordnet ist, führen Sie die Schritte in einem der folgenden Artikel aus, um eine im Azure Portal oder mithilfe der Befehlszeile zu erstellen:

   Verwenden Sie das Portal, um eine Azure AD-Anwendung und einen Dienstprinzipal zu erstellen, die auf Ressourcen zugreifen können

   Verwenden Sie Azure PowerShell, um einen Dienstprinzipal mit einem Zertifikat zu erstellen

Schritt 3: Erstellen eines geheimen Schlüssels für Ihre App-Registrierung

Ihr Geheimer Schlüssel wird zusammen mit Ihrer Azure AppId/ClientId verwendet, wenn Sie ein Zugriffstoken zum Senden von Pushbenachrichtigungen anfordern.

Navigieren Sie zu Zertifikate und Geheimnisse und wählen Sie Neues Clientgeheimnis aus.

Schritt 4: Zuordnen des Paketfamiliennamens Ihrer App zu ihrer Azure AppId

Wenn Ihre App gepackt ist (einschließlich paketiert mit einem externen Speicherort), können Sie diesen Fluss verwenden, um den Paketfamiliennamen (PACKAGE Family Name, PFN) Ihrer App und deren Azure AppId zuzuordnen.

Wenn Ihre App eine gepackte Win32-App ist, stellen Sie eine Zuordnungsanforderung für den Paketfamiliennamen (PFN) durch eine E-Mail an Win_App_SDK_Push@microsoft.com mit dem Betreff "Windows App SDK Mapping-Anforderung für Push-Benachrichtigungen" und folgendem Inhalt: "PFN: [Ihr PFN], AppId: [Ihre APPId], ObjectId: [Ihre ObjectId]". Zuordnungsanfragen werden wöchentlich bearbeitet. Sie werden benachrichtigt, sobald Ihre Mapping-Anfrage abgeschlossen ist.

Sobald Sie ihre Azure AppId, ObjectId und geheimen Schlüssel haben, können Sie diese Anmeldeinformationen dem folgenden Beispielcode hinzufügen.

konfigurieren Sie Ihre App für den Empfang von Pushbenachrichtigungen

Schritt 1: Hinzufügen von Windows App SDK und erforderlichen NuGet-Paketen

Klicken Sie als Nächstes mit der rechten Maustaste auf die Lösung im Projektmappen-Explorer, und wählen Sie Manage NuGet Packages aus.

Fügen Sie in der Paket-Manager die folgenden Pakete hinzu:

• Microsoft. WindowsAppSDK (Mindestversion 1.1.0)
• Microsoft. Windows. SDK. BuildTools (Mindestversion 10.0.22000.194)
• Microsoft.Windows.CppWinRT, (Mindestversion 2.0.210930.14)
• Microsoft. Windows. ImplementationLibrary, (Mindestversion 1.0.210930.1)

Wenn Sie das Windows-App-SDK zum ersten Mal in Ihrem Projekt verwenden und es entweder mit einem externen Speicherort verpackt oder entpackt ist, initialisieren Sie das Windows-App-SDK, indem Sie die folgende Eigenschaft zu Ihrer Projektdatei hinzufügen:

<!-- your .vcxproj or .proj file -->
<PropertyGroup Label="Globals">
    <!-- Other properties -->
    <WindowsPackageType>None</WindowsPackageType>
</PropertyGroup>

oder verwenden Sie die Bootstrapper-API. Weitere Informationen finden Sie unter Die Verwendung der Windows App SDK-Laufzeitumgebung für Apps, die mit externem Speicherort gepackt oder unverpackt sind.

Schritt 2: Hinzufügen von Namespaces

Fügen Sie als Nächstes den Namespace für Windows App SDK Pushbenachrichtigungen Microsoft.Windows.PushNotifications hinzu.

#include <winrt/Microsoft.Windows.PushNotifications.h>

using namespace winrt::Microsoft::Windows::PushNotifications;

Wenn Sie die Fehlermeldung "Kann Microsoft.Windows.PushNotifications nicht finden" erhalten, weist das wahrscheinlich darauf hin, dass die Headerdateien nicht generiert wurden. Um dies zu beheben, stellen Sie sicher, dass die oben genannten Pakete installiert sind, kommentieren Sie die include- und using-Anweisungen aus, die den Fehler verursachen, und erstellen Sie die Anwendung neu, um die Header-Dateien zu generieren. Nachdem der Build erfolgreich war, entfernen Sie die Kommentierung und fügen Sie die using-Anweisungen hinzu. Erstellen Sie dann das Projekt neu. Dadurch sollte der Fehler behoben werden.

Schritt 3: Hinzufügen des COM-Aktivators zum Manifest Ihrer App

Wenn Ihre App verpackt ist (einschließlich mit externem Speicherort verpackt): Öffnen Sie Ihre Package.appxmanifest. Fügen Sie Folgendes innerhalb des <Application>-Elements hinzu. Ersetzen Sie die Werte Id, Executable und DisplayName durch die für Ihre App spezifischen Werte.

<!--Packaged apps only-->
<!--package.appxmanifest-->

<Package
  ...
  xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"
  ...
  <Applications>
    <Application>
      ...
      <Extensions>

        <!--Register COM activator-->    
        <com:Extension Category="windows.comServer">
          <com:ComServer>
              <com:ExeServer Executable="SampleApp\SampleApp.exe" DisplayName="SampleApp" Arguments="----WindowsAppRuntimePushServer:">
                <com:Class Id="[Your app's Azure AppId]" DisplayName="Windows App SDK Push" />
            </com:ExeServer>
          </com:ComServer>
        </com:Extension>
    
      </Extensions>
    </Application>
  </Applications>
 </Package>    

Schritt 4: Registrieren und Reagieren auf Pushbenachrichtigungen beim Starten der App

Aktualisieren Sie die Methode main() Ihrer App, um Folgendes hinzuzufügen:

1. Registrieren Sie Ihre App, um Pushbenachrichtigungen zu empfangen, indem Sie PushNotificationManager::Default().Register()aufrufen.
2. Überprüfen Sie die Quelle der Aktivierungsanforderung, indem Sie AppInstance::GetCurrent().GetActivatedEventArgs()aufrufen. Wenn die Aktivierung von einer Pushbenachrichtigung ausgelöst wurde, antworten Sie basierend auf der Nutzlast der Benachrichtigung.

Hinzufügen von Vordergrund-Ereignishandlern

Um ein Ereignis im Vordergrund zu behandeln, registrieren Sie einen Handler für PushNotificationManager.PushReceived.

System.Runtime.InteropServices.COMException: Element not found. Must register event handlers before calling Register().

Fügen Sie die Überprüfung von PushNotificationManager::IsSupported() hinzu

Fügen Sie als Nächstes eine Überprüfung hinzu, ob die PushNotification-APIs mit PushNotificationManager.IsSupported()unterstützt werden. Wir empfehlen Ihnen, entweder Polling oder Ihre eigene benutzerdefinierte Socket-Implementierung zu verwenden.

Nachdem die Unterstützung für Pushbenachrichtigungen bestätigt wurde, fügen Sie das Verhalten basierend auf PushNotificationReceivedEventArgs hinzu.

Schritt 5: Anfordern eines WNS-Kanal-URI und Registrieren mit dem WNS-Server

WNS-Kanal-URIs sind die HTTP-Endpunkte zum Senden von Pushbenachrichtigungen. Jeder Client muss einen Kanal-URI anfordern und mit dem WNS-Server registrieren, um Pushbenachrichtigungen zu empfangen.

auto channelOperation{ PushNotificationManager::Default().CreateChannelAsync(winrt::guid("[Your app's Azure ObjectID]")) };

Wenn Sie dem Lernprogrammcode folgen, fügen Sie hier Ihre Azure-Objekt-ID hinzu:

// To obtain an AAD RemoteIdentifier for your app,
// follow the instructions on https://dori-uw-1.kuma-moon.com/azure/active-directory/develop/quickstart-register-app
winrt::guid remoteId{ "00000000-0000-0000-0000-000000000000" }; // Replace this with your own Azure ObjectId

Der PushNotificationManager- versucht, einen Kanal-URI zu erstellen, der automatisch für maximal 15 Minuten wiederholt wird. ** Erstellen Sie einen Ereignishandler, um zu warten, bis der Aufruf abgeschlossen ist. Sobald der Aufruf abgeschlossen ist, registrieren Sie den URI bei dem WNS-Server, falls er erfolgreich war.

Beispielcode

#include <iostream>
#include <winrt/Microsoft.Windows.PushNotifications.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Microsoft.Windows.AppLifecycle.h>
#include <winrt/Windows.ApplicationModel.Background.h>
#include <wil/cppwinrt.h>
#include <wil/result.h>

using namespace winrt::Microsoft::Windows::PushNotifications;
using namespace winrt::Windows::Foundation;
using namespace winrt::Microsoft::Windows::AppLifecycle;

// To obtain an AAD RemoteIdentifier for your app,
// follow the instructions on https://dori-uw-1.kuma-moon.com/azure/active-directory/develop/quickstart-register-app
winrt::guid remoteId{ "00000000-0000-0000-0000-000000000000" }; // Replace this with your own Azure ObjectId

winrt::Windows::Foundation::IAsyncOperation<PushNotificationChannel> RequestChannelAsync()
{
    auto channelOperation = PushNotificationManager::Default().CreateChannelAsync(remoteId);

    // Set up the in-progress event handler
    channelOperation.Progress(
        [](auto&& sender, auto&& args)
        {
            if (args.status == PushNotificationChannelStatus::InProgress)
            {
                // This is basically a noop since it isn't really an error state
                std::cout << "Channel request is in progress." << std::endl << std::endl;
            }
            else if (args.status == PushNotificationChannelStatus::InProgressRetry)
            {
                LOG_HR_MSG(
                    args.extendedError,
                    "The channel request is in back-off retry mode because of a retryable error! Expect delays in acquiring it. RetryCount = %d",
                    args.retryCount);
            }
        });

    auto result = co_await channelOperation;

    if (result.Status() == PushNotificationChannelStatus::CompletedSuccess)
    {
        auto channelUri = result.Channel().Uri();

        std::cout << "channelUri: " << winrt::to_string(channelUri.ToString()) << std::endl << std::endl;

        auto channelExpiry = result.Channel().ExpirationTime();

        // Caller's responsibility to keep the channel alive
        co_return result.Channel();
    }
    else if (result.Status() == PushNotificationChannelStatus::CompletedFailure)
    {
        LOG_HR_MSG(result.ExtendedError(), "We hit a critical non-retryable error with channel request!");
        co_return nullptr;
    }
    else
    {
        LOG_HR_MSG(result.ExtendedError(), "Some other failure occurred.");
        co_return nullptr;
    }

};

PushNotificationChannel RequestChannel()
{
    auto task = RequestChannelAsync();
    if (task.wait_for(std::chrono::seconds(300)) != AsyncStatus::Completed)
    {
        task.Cancel();
        return nullptr;
    }

    auto result = task.GetResults();
    return result;
}

void SubscribeForegroundEventHandler()
{
    winrt::event_token token{ PushNotificationManager::Default().PushReceived([](auto const&, PushNotificationReceivedEventArgs const& args)
    {
        auto payload{ args.Payload() };

        std::string payloadString(payload.begin(), payload.end());
        std::cout << "\nPush notification content received in the FOREGROUND: " << payloadString << std::endl;
    }) };

    std::cout << "Push notification foreground event handler registered." << std::endl;
}

int main()
{
    // Set up an event handler, so we can receive notifications in the foreground while the app is running.
    // You must register notification event handlers before calling Register(). Otherwise, the following runtime
    // exception will be thrown: System.Runtime.InteropServices.COMException: 'Element not found. Must register
    // event handlers before calling Register().'
    SubscribeForegroundEventHandler();

    // Register the app for push notifications.
    PushNotificationManager::Default().Register();

    auto args{ AppInstance::GetCurrent().GetActivatedEventArgs() };
    switch (args.Kind())
    {
        case ExtendedActivationKind::Launch:
        {
            std::cout << "App launched by user or from the debugger." << std::endl;
            if (PushNotificationManager::IsSupported())
            {
                std::cout << "Push notifications are supported on this device." << std::endl;

                // Request a WNS Channel URI which can be passed off to an external app to send notifications to.
                // The WNS Channel URI uniquely identifies this app for this user and device.
                PushNotificationChannel channel{ RequestChannel() };
                if (!channel)
                {
                    std::cout << "\nThere was an error obtaining the WNS Channel URI" << std::endl;

                    if (remoteId == winrt::guid{ "00000000-0000-0000-0000-000000000000" })
                    {
                        std::cout << "\nThe ObjectID has not been set. Refer to the readme file accompanying this sample\nfor the instructions on how to obtain and setup an ObjectID" << std::endl;
                    }
                }

                std::cout << "\nPress 'Enter' at any time to exit App." << std::endl;
                std::cin.ignore();
            }
            else
            {
                std::cout << "Push notifications are NOT supported on this device." << std::endl;
                std::cout << "App implements its own custom socket here to receive messages from the cloud since Push APIs are unsupported." << std::endl;
                std::cin.ignore();
            }
        }
        break;

        case ExtendedActivationKind::Push:
        {
            std::cout << "App activated via push notification." << std::endl;
            PushNotificationReceivedEventArgs pushArgs{ args.Data().as<PushNotificationReceivedEventArgs>() };

            // Call GetDeferral to ensure that code runs in low power
            auto deferral{ pushArgs.GetDeferral() };

            auto payload{ pushArgs.Payload() };

            // Do stuff to process the raw notification payload
            std::string payloadString(payload.begin(), payload.end());
            std::cout << "\nPush notification content received in the BACKGROUND: " << payloadString.c_str() << std::endl;
            std::cout << "\nPress 'Enter' to exit the App." << std::endl;

            // Call Complete on the deferral when finished processing the payload.
            // This removes the override that kept the app running even when the system was in a low power mode.

            deferral.Complete();
            std::cin.ignore();
        }
        break;

        default:
            std::cout << "\nUnexpected activation type" << std::endl;
            std::cout << "\nPress 'Enter' to exit the App." << std::endl;
            std::cin.ignore();
            break;
    }
}

Schritt 6: Erstellen und Installieren Ihrer App

Verwenden Sie Visual Studio, um Ihre App zu erstellen und zu installieren. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Lösungsdatei, und wählen Sie Deploy aus. Visual Studio erstellt Ihre App und installiert sie auf Ihrem Computer. Sie können die App ausführen, indem Sie sie über das Startmenü oder den Visual Studio Debugger starten.

Die Konsole des Lernprogrammcodes sieht wie folgt aus:

Sie benötigen das Token, um eine Pushbenachrichtigung an Ihre App zu senden.

Senden einer Pushbenachrichtigung an Ihre App

An diesem Punkt ist die gesamte Konfiguration abgeschlossen, und der WNS-Server kann Pushbenachrichtigungen an Client-Apps senden. In den folgenden Schritten finden Sie weitere Details zu den Anforderungs- und Antwortheadern für Push-Benachrichtigungen.

Schritt 1: Anfordern eines Zugriffstokens

Zum Senden einer Pushbenachrichtigung muss der WNS-Server zuerst ein Zugriffstoken anfordern. Senden Sie eine HTTP POST-Anforderung mit Ihrer Azure TenantId, Azure AppId und dem geheimen Schlüssel. Informationen zum Abrufen der Azure-TenantId und Azure-AppId finden Sie unter Mandanten- und App-ID-Werte zum Anmelden abrufen.

HTTP-Beispielanforderung:

POST /{tenantID}/oauth2/v2.0/token Http/1.1
Host: login.microsoftonline.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 160

grant_type=client_credentials&client_id=<Azure_App_Registration_AppId_Here>&client_secret=<Azure_App_Registration_Secret_Here>&scope=https://wns.windows.com/.default/

C#-Beispielanforderung:

//Sample C# Access token request
var client = new RestClient("https://login.microsoftonline.com/{tenantID}/oauth2/v2.0");
var request = new RestRequest("/token", Method.Post);
request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
request.AddParameter("grant_type", "client_credentials");
request.AddParameter("client_id", "[Your app's Azure AppId]");
request.AddParameter("client_secret", "[Your app's secret]");
request.AddParameter("scope", "https://wns.windows.com/.default");
RestResponse response = await client.ExecutePostAsync(request);
Console.WriteLine(response.Content);

Wenn Ihre Anforderung erfolgreich ist, erhalten Sie eine Antwort, die Ihr Token im Feld access_token enthält.

{
    "token_type":"Bearer",
    "expires_in":"86399",
    "ext_expires_in":"86399",
    "expires_on":"1653771789",
    "not_before":"1653685089",
    "access_token":"[your access token]"
}

Schritt 2. Senden einer unformatierten Benachrichtigung

Erstellen Sie eine HTTP POST-Anforderung, die das Zugriffstoken enthält, das Sie im vorherigen Schritt abgerufen haben, und den Inhalt der Pushbenachrichtigung, die Sie senden möchten. Der Inhalt der Pushbenachrichtigung wird an die App übermittelt.

POST /?token=[The token query string parameter from your channel URL. E.g. AwYAAABa5cJ3...] HTTP/1.1
Host: dm3p.notify.windows.com
Content-Type: application/octet-stream
X-WNS-Type: wns/raw
Authorization: Bearer [your access token]
Content-Length: 46

{ Sync: "Hello from the Contoso App Service" }

var client = new RestClient("[Your channel URL. E.g. https://wns2-by3p.notify.windows.com/?token=AwYAAABa5cJ3...]");
var request = new RestRequest();
request.Method = Method.Post; 
request.AddHeader("Content-Type", "application/octet-stream");
request.AddHeader("X-WNS-Type", "wns/raw");
request.AddHeader("Authorization", "Bearer [your access token]");
request.AddBody("Notification body");
RestResponse response = await client.ExecutePostAsync(request);");

Schritt 3: Senden einer cloudbasierten App-Benachrichtigung

Wenn Sie nur unformatierte Benachrichtigungen senden möchten, ignorieren Sie diesen Schritt. Um eine Benachrichtigung über eine cloudbasierte App zu senden, auch als Push-Popupbenachrichtigung bezeichnet, folgen Sie zuerst Quickstart: App-Benachrichtigungen im Windows App SDK. App-Benachrichtigungen können entweder per Push (aus der Cloud gesendet) oder lokal gesendet werden. Das Senden einer cloudbasierten App-Benachrichtigung ähnelt dem Senden einer unformatierten Benachrichtigung in Schritt 2, außer dass der X-WNS-Type-Header ist toast, der Content-Type ist text/xmlund der Inhalt die XML-Nutzlast der App-Benachrichtigung enthält. Weitere Informationen zum Erstellen Ihrer XML-Nutzlast finden Sie im Benachrichtigungs-XML-Schema.

Erstellen Sie eine HTTP POST-Anforderung, die Ihr Zugriffstoken und den Inhalt der cloudbasierten App-Benachrichtigung enthält, die Sie senden möchten. Der Inhalt der Pushbenachrichtigung wird an die App übermittelt.

POST /?token=AwYAAAB%2fQAhYEiAESPobjHzQcwGCTjHu%2f%2fP3CCNDcyfyvgbK5xD3kztniW%2bjba1b3aSSun58SA326GMxuzZooJYwtpgzL9AusPDES2alyQ8CHvW94cO5VuxxLDVzrSzdO1ZVgm%2bNSB9BAzOASvHqkMHQhsDy HTTP/1.1
Host: dm3p.notify.windows.com
Content-Type: text/xml
X-WNS-Type: wns/toast
Authorization: Bearer [your access token]
Content-Length: 180

<toast><visual><binding template="ToastGeneric"><text>Example cloud toast notification</text><text>This is an example cloud notification using XML</text></binding></visual></toast>

var client = new RestClient("https://dm3p.notify.windows.com/?token=AwYAAAB%2fQAhYEiAESPobjHzQcwGCTjHu%2f%2fP3CCNDcyfyvgbK5xD3kztniW%2bjba1b3aSSun58SA326GMxuzZooJYwtpgzL9AusPDES2alyQ8CHvW94cO5VuxxLDVzrSzdO1ZVgm%2bNSB9BAzOASvHqkMHQhsDy");
client.Timeout = -1;

var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "text/xml");
request.AddHeader("X-WNS-Type", "wns/toast");
request.AddHeader("Authorization", "Bearer <AccessToken>");
request.AddParameter("text/xml", "<toast><visual><binding template=\"ToastGeneric\"><text>Example cloud toast notification</text><text>This is an example cloud notification using XML</text></binding></visual></toast>",  ParameterType.RequestBody);
Console.WriteLine(response.Content);

Resources

• Windows Pushbenachrichtigungsdienst (WNS)
• Push-Benachrichtigungsbeispielcode für GitHub
• Details der Microsoft.Windows.PushNotifications-API
• Spezifikation für Push-Benachrichtigungen auf GitHub
• Toast-Inhalt
• Benachrichtigungs-XML-Schema