Tutorial: Senden von Benachrichtigungen an bestimmte Benutzer mit Azure Notification HubsTutorial: Send notifications to specific users by using Azure Notification Hubs

ÜbersichtOverview

Ein ASP.NET WebAPI-Back-End wird verwendet, um Clients zu authentifizieren.This tutorial shows you how to use Azure Notification Hubs to send push notifications to a specific app user on a specific device. Mit dem authentifizierten Clientbenutzer wird automatisch ein Tag vom Back-End zur Benachrichtigungsregistrierung hinzugefügt.An ASP.NET WebAPI backend is used to authenticate clients. Wenn das Back-End einen Benutzer einer Clientanwendung authentifiziert, fügt es der Benachrichtigungsregistrierung automatisch ein Tag hinzu.When the backend authenticates a client application user, it automatically adds a tag to the notification registration. Das Back-End nutzt dieses Tag, um Benachrichtigungen an den jeweiligen Benutzer zu senden.The backend uses this tag to send notifications to the specific user.

Hinweis

Den vollständigen Code für dieses Tutorial finden Sie auf GitHub.The completed code for this tutorial can be found on GitHub.

In diesem Tutorial führen Sie die folgenden Schritte aus:In this tutorial, you take the following steps:

  • Erstellen des WebAPI-ProjektsCreate the WebAPI project
  • Authentifizieren von Clients beim WebAPI-Back-EndAuthenticate clients to the WebAPI backend
  • Registrieren für Benachrichtigungen unter Verwendung des WebAPI-Back-EndsRegister for notifications by using the WebAPI backend
  • Senden von Benachrichtigungen über das WebAPI-Back-EndSend notifications from the WebAPI backend
  • Veröffentlichen des neuen WebAPI-Back-EndsPublish the new WebAPI backend
  • Aktualisieren des Codes für das ClientprojektUpdate the code for the client project
  • Testen der AnwendungTest the application

VoraussetzungenPrerequisites

Dieses Tutorial baut auf dem Benachrichtigungs-Hub und dem Visual Studio-Projekt auf, die Sie unter Tutorial: Senden von Benachrichtigungen an Apps für die universelle Windows-Plattform mit Azure Notification Hubs erstellt haben.This tutorial builds on the notification hub and Visual Studio project that you created in the Tutorial: Send notifications to Universal Windows Platform apps by using Azure Notification Hubs tutorial. Dieses müssen Sie daher zunächst abschließen, bevor Sie mit diesem Tutorial beginnen.Therefore, complete it before starting on this tutorial.

Hinweis

Wenn Sie Mobile Apps in Azure App Service als Back-End-Dienst verwenden, finden Sie weitere Informationen in der Mobile Apps-Version dieses Tutorials.If you are using Mobile Apps in Azure App Service as your backend service, see the Mobile Apps version of this tutorial.

Erstellen des WebAPI-ProjektsCreate the WebAPI project

In den folgenden Abschnitten wird die Erstellung eines neuen ASP.NET-WebAPI-Back-Ends erläutert.The following sections discuss the creation of a new ASP.NET WebAPI backend. Dieser Prozess hat drei Hauptfunktionen:This process has three main purposes:

  • Authentifizieren von Clients: Sie fügen einen Meldungshandler hinzu, um Clientanforderungen zu authentifizieren und den Benutzer der Anforderung zuzuordnen.Authenticate clients: You add a message handler to authenticate client requests and associate the user with the request.
  • Registrieren für Benachrichtigungen unter Verwendung des WebAPI-Back-Ends: Sie fügen einen Controller hinzu, um neue Registrierungen für ein Clientgerät zum Empfangen von Benachrichtigungen zu verarbeiten.Register for notifications by using the WebAPI backend: You add a controller to handle new registrations for a client device to receive notifications. Der authentifizierte Benutzername wird der Registrierung automatisch als Tag hinzugefügt.The authenticated username is automatically added to the registration as a tag.
  • Senden von Benachrichtigungen an Clients: Sie fügen einen Controller hinzu, um Benutzern die Möglichkeit zu geben, einen sicheren Pushvorgang an Geräte und Clients auszulösen, die dem Tag zugeordnet sind.Send notifications to clients: You add a controller to provide a way for users to trigger a secure push to devices and clients associated with the tag.

Gehen Sie zum Erstellen des neuen ASP.NET-WebAPI-Back-Ends wie folgt vor:Create the new ASP.NET WebAPI backend by doing the following actions:

Wichtig

Falls Sie Visual Studio 2015 oder eine ältere Version verwenden, vergewissern Sie sich vor Beginn dieses Tutorials, dass bei Ihnen die neueste Version des NuGet-Paket-Managers für Visual Studio installiert ist.If you are using Visual Studio 2015 or earlier, before starting this tutorial, ensure that you have installed the latest version of NuGet Package Manager for Visual Studio.

Um dies zu überprüfen, starten Sie Visual Studio.To check, start Visual Studio. Wählen Sie im Menü Extras die Option Erweiterungen und Updates aus.On the Tools menu, select Extensions and Updates. Suchen Sie in Ihrer Version von Visual Studio nach NuGet-Paket-Manager, und vergewissern Sie sich, dass Sie über die neueste Version verfügen.Search for NuGet Package Manager in your version of Visual Studio, and make sure you have the latest version. Deinstallieren Sie andernfalls Ihre Version, und installieren Sie den NuGet-Paket-Manager erneut.If your version is not the latest version, uninstall it, and then reinstall the NuGet Package Manager.

Hinweis

Stellen Sie sicher, dass Sie das Visual Studio Azure SDK für die Websitebereitstellung installiert haben.Make sure you have installed the Visual Studio Azure SDK for website deployment.

  1. Starten Sie Visual Studio oder Visual Studio Express.Start Visual Studio or Visual Studio Express.

  2. Wählen Sie Server-Explorer aus, und melden Sie sich bei Ihrem Azure-Konto an.Select Server Explorer, and sign in to your Azure account. Zur Erstellung der Websiteressourcen für Ihr Konto müssen Sie angemeldet sein.To create the web site resources on your account, you must be signed in.

  3. Klicken Sie in Visual Studio mit der rechten Maustaste auf die Visual Studio-Projektmappe, zeigen Sie auf Hinzufügen, und klicken Sie auf Neues Projekt.In Visual Studio, right-click Visual Studio solution, point to Add, and click New Project.

  4. Erweitern Sie Visual C# , wählen Sie Web aus, und klicken Sie auf ASP.NET-Webanwendung.Expand Visual C#, select Web, and click ASP.NET Web Application.

  5. Geben Sie im Feld Name die Zeichenfolge AppBackend ein, und wählen Sie dann OK aus.In the Name box, type AppBackend, and then select OK.

    Das Fenster „Neues Projekt“

  6. Aktivieren Sie im Fenster Neues ASP.NET-Projekt das Kontrollkästchen Web-API, und wählen Sie anschließend OK aus.In the New ASP.NET Project window, select the Web API check box, and then select OK.

    Das Fenster „Neues ASP.NET-Projekt“

  7. Wählen Sie im Fenster Microsoft Azure-Web-App konfigurieren ein Abonnement aus, und führen Sie anschließend in der Liste App Service-Plan eine der folgenden Aktionen aus:In the Configure Microsoft Azure Web App window, select a subscription and then, in the App Service plan list, do either of the following actions:

    • Wählen Sie einen bereits erstellten App Service-Plan aus.Select an app service plan that you've already created.
    • Wählen Sie Einen neuen App Services-Plan erstellen aus, und erstellen Sie einen neuen Plan.Select Create a new app service plan, and then create one.

    Sie benötigen für dieses Lernprogramm keine Datenbank.You do not need a database for this tutorial. Wählen Sie nach der Wahl Ihres App Service-Plans OK aus, um das Projekt zu erstellen.After you have selected your app service plan, select OK to create the project.

    Das Fenster „Microsoft Azure-Web-App konfigurieren“

    Wird diese Seite zum Konfigurieren des App Service-Plans nicht angezeigt, fahren Sie mit dem Tutorial fort.If you don't see this page for configure app service plan, continue with the tutorial. Sie können ihn später beim Veröffentlichen der App konfigurieren.You can configure it while publishing the app later.

Authentifizieren von Clients beim WebAPI-Back-EndAuthenticate clients to the WebAPI backend

In diesem Abschnitt erstellen Sie für das neue Back-End eine neue Meldungshandlerklasse namens AuthenticationTestHandler.In this section, you create a new message-handler class named AuthenticationTestHandler for the new backend. Diese Klasse wird von DelegatingHandler abgeleitet und als Meldungshandler hinzugefügt, damit alle beim Back-End eingehenden Anforderungen verarbeitet werden können.This class is derived from DelegatingHandler and added as a message handler so that it can process all requests that come into the backend.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie Hinzufügen und anschließend Klasse aus.In Solution Explorer, right-click the AppBackend project, select Add, and then select Class.

  2. Geben Sie der neuen Klasse den Namen AuthenticationTestHandler.cs, und wählen Sie Hinzufügen aus, um die Klasse zu generieren.Name the new class AuthenticationTestHandler.cs, and then select Add to generate the class. Mit dieser Klasse werden Benutzer der Einfachheit halber unter Verwendung der Standardauthentifizierung authentifiziert.This class authenticates users by using Basic Authentication for simplicity. Ihre App kann ein beliebiges Authentifizierungsschema verwenden.Your app can use any authentication scheme.

  3. Fügen Sie in der Datei "AuthenticationTestHandler.cs" die folgenden using -Anweisungen hinzu:In AuthenticationTestHandler.cs, add the following using statements:

    using System.Net.Http;
    using System.Threading;
    using System.Security.Principal;
    using System.Net;
    using System.Text;
    using System.Threading.Tasks;
    
  4. Ersetzen Sie in der Datei „AuthenticationTestHandler.cs“ die Definition der Klasse AuthenticationTestHandler durch den folgenden Code:In AuthenticationTestHandler.cs, replace the AuthenticationTestHandler class definition with the following code:

    Der Handler autorisiert die Anforderung, wenn die folgenden drei Bedingungen erfüllt sind:The handler authorizes the request when the following three conditions are true:

    • Die Anforderung enthält einen Autorisierungsheader.The request includes an Authorization header.
    • Für die Anforderung wird die Standardauthentifizierung verwendet.The request uses basic authentication.
    • Bei der Benutzernamen-Zeichenfolge und der Kennwortzeichenfolge handelt es sich um die gleiche Zeichenfolge.The user name string and the password string are the same string.

    Andernfalls wird die Anforderung abgelehnt.Otherwise, the request is rejected. Diese Authentifizierung ist keine echte Vorgehensweise zur Authentifizierung und Autorisierung.This authentication is not a true authentication and authorization approach. Hierbei handelt es sich lediglich um ein einfaches Beispiel für dieses Tutorial.It is only a simple example for this tutorial.

    Wenn die Anforderungsnachricht von AuthenticationTestHandler authentifiziert und autorisiert wurde, wird der Benutzer der Standardauthentifizierung an die aktuelle Anforderung in HttpContext angefügt.If the request message is authenticated and authorized by AuthenticationTestHandler, the basic authentication user is attached to the current request on HttpContext. Die Benutzerinformationen in „HttpContext“ werden später von einem anderen Controller (RegisterController) verwendet, um der Registrierungsanforderung für die Benachrichtigung ein Tag hinzuzufügen.User information in HttpContext will be used by another controller (RegisterController) later to add a tag to the notification registration request.

    public class AuthenticationTestHandler : DelegatingHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var authorizationHeader = request.Headers.GetValues("Authorization").First();
    
            if (authorizationHeader != null && authorizationHeader
                .StartsWith("Basic ", StringComparison.InvariantCultureIgnoreCase))
            {
                string authorizationUserAndPwdBase64 =
                    authorizationHeader.Substring("Basic ".Length);
                string authorizationUserAndPwd = Encoding.Default
                    .GetString(Convert.FromBase64String(authorizationUserAndPwdBase64));
                string user = authorizationUserAndPwd.Split(':')[0];
                string password = authorizationUserAndPwd.Split(':')[1];
    
                if (verifyUserAndPwd(user, password))
                {
                    // Attach the new principal object to the current HttpContext object
                    HttpContext.Current.User =
                        new GenericPrincipal(new GenericIdentity(user), new string[0]);
                    System.Threading.Thread.CurrentPrincipal =
                        System.Web.HttpContext.Current.User;
                }
                else return Unauthorized();
            }
            else return Unauthorized();
    
            return base.SendAsync(request, cancellationToken);
        }
    
        private bool verifyUserAndPwd(string user, string password)
        {
            // This is not a real authentication scheme.
            return user == password;
        }
    
        private Task<HttpResponseMessage> Unauthorized()
        {
            var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
            var tsc = new TaskCompletionSource<HttpResponseMessage>();
            tsc.SetResult(response);
            return tsc.Task;
        }
    }
    

    Hinweis

    Sicherheitshinweis: Die Klasse AuthenticationTestHandler ermöglicht keine wirkliche Authentifizierung.Security note: The AuthenticationTestHandler class does not provide true authentication. Sie wird nur verwendet, um eine Standardauthentifizierung zu imitieren, und ist nicht sicher.It is used only to mimic basic authentication and is not secure. Sie müssen einen sicheren Authentifizierungsmechanismus in Ihren Produktionsanwendungen und -diensten implementieren.You must implement a secure authentication mechanism in your production applications and services.

  5. Fügen Sie am Ende der Methode Register in der Klasse App_Start/WebApiConfig.cs den folgenden Code hinzu, um den Meldungshandler zu registrieren:To register the message handler, add the following code at the end of the Register method in the App_Start/WebApiConfig.cs class:

    config.MessageHandlers.Add(new AuthenticationTestHandler());
    
  6. Speichern Sie die Änderungen.Save your changes.

Registrieren für Benachrichtigungen unter Verwendung des WebAPI-Back-EndsRegister for notifications by using the WebAPI backend

In diesem Abschnitt wird dem WebAPI-Back-End ein neuer Controller hinzugefügt, um Anforderungen zum Registrieren eines Benutzers und eines Geräts für Benachrichtigungen unter Verwendung der Clientbibliothek für Notification Hubs zu verarbeiten.In this section, you add a new controller to the WebAPI backend to handle requests to register a user and a device for notifications by using the client library for notification hubs. Der Controller fügt ein Benutzertag für den Benutzer hinzu, der durch AuthenticationTestHandler authentifiziert und an „HttpContext“ angefügt wurde.The controller adds a user tag for the user that was authenticated and attached to HttpContext by AuthenticationTestHandler. Die Markierung hat das Zeichenfolgenformat "username:<actual username>".The tag has the string format, "username:<actual username>".

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie dann NuGet-Pakete verwalten aus.In Solution Explorer, right-click the AppBackend project and then select Manage NuGet Packages.

  2. Wählen Sie im linken Bereich Online aus, und geben Sie dann im Feld Suche die Zeichenfolge Microsoft.Azure.NotificationHubs ein.In the left pane, select Online and then, in the Search box, type Microsoft.Azure.NotificationHubs.

  3. Wählen Sie in der Ergebnisliste die Option Microsoft Azure Notification Hubs und anschließend Installieren aus.In the results list, select Microsoft Azure Notification Hubs, and then select Install. Schließen Sie die Installation ab, und schließen Sie dann das Fenster des NuGet-Paket-Managers.Complete the installation, and then close the NuGet Package Manager window.

    Dadurch wird mithilfe des Microsoft.Azure.NotificationHubs-NuGet-Pakets ein Verweis auf das Azure Notification Hubs-SDK hinzugefügt.This action adds a reference to the Azure Notification Hubs SDK by using the Microsoft.Azure.Notification Hubs NuGet package.

  4. Erstellen Sie eine neue Klassendatei, die die Verbindung mit dem Notification Hub darstellt, der zum Senden von Benachrichtigungen verwendet wird.Create a new class file that represents the connection with the notification hub that's used to send notifications. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Modelle, und wählen Sie dann Hinzufügen und anschließend Klasse aus.In Solution Explorer, right-click the Models folder, select Add, and then select Class. Nennen Sie die neue Klasse Notifications.cs, und wählen Sie dann Hinzufügen aus, um die Klasse zu generieren.Name the new class Notifications.cs, and then select Add to generate the class.

    Das Fenster „Neues Element hinzufügen“

  5. Fügen Sie die folgende using -Anweisung am Anfang der Datei "Notifications.cs" hinzu:In Notifications.cs, add the following using statement at the top of the file:

    using Microsoft.Azure.NotificationHubs;
    
  6. Ersetzen Sie die Definition der Klasse Notifications durch den folgenden Code und die beiden Platzhalter durch die Verbindungszeichenfolge (mit Vollzugriff) für Ihren Notification Hub bzw. durch den Namen des Hubs (verfügbar im Azure-Portal):Replace the Notifications class definition with the following code, and replace the two placeholders with the connection string (with full access) for your notification hub and the hub name (available at Azure portal):

    public class Notifications
    {
        public static Notifications Instance = new Notifications();
    
        public NotificationHubClient Hub { get; set; }
    
        private Notifications() {
            Hub = NotificationHubClient.CreateClientFromConnectionString("<your hub's DefaultFullSharedAccessSignature>",
                                                                            "<hub name>");
        }
    }
    

    Wichtig

    Geben Sie für den Hub den Namen und einen Wert für DefaultFullSharedAccessSignature ein, bevor Sie fortfahren.Enter the name and the DefaultFullSharedAccessSignature of your hub before proceeding further.

  7. Erstellen Sie als Nächstes einen neuen Controller namens RegisterController.Next, create a new controller named RegisterController. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller, und wählen Sie dann Hinzufügen und Controller aus.In Solution Explorer, right-click the Controllers folder, select Add, and then select Controller.

  8. Wählen Sie Web-API-2-Controller – Leer und anschließend Hinzufügen aus.Select Web API 2 Controller - Empty, and then select Add.

    Das Fenster „Gerüst hinzufügen“

  9. Geben Sie im Feld Controllername die Zeichenfolge RegisterController ein, um die neue Klasse zu benennen, und wählen Sie anschließend Hinzufügen aus.In the Controller name box, type RegisterController to name the new class, and then select Add.

    Das Fenster „Controller hinzufügen“

  10. Fügen Sie in der Datei "RegisterController.cs" die folgenden using -Anweisungen hinzu:In RegisterController.cs, add the following using statements:

    using Microsoft.Azure.NotificationHubs;
    using Microsoft.Azure.NotificationHubs.Messaging;
    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  11. Fügen Sie innerhalb der RegisterController -Klassendefinition den folgenden Code hinzu.Add the following code inside the RegisterController class definition. Mit diesem Code fügen Sie ein Benutzertag für den Benutzer hinzu, der HttpContext angefügt ist.In this code, you add a user tag for the user that's attached to HttpContext. Der Benutzer wurde mit dem von Ihnen hinzugefügten Nachrichtenfilter AuthenticationTestHandler authentifiziert und HttpContext angefügt.The user was authenticated and attached to HttpContext by the message filter that you added, AuthenticationTestHandler. Sie können auch optionale Überprüfungen hinzufügen, um zu überprüfen, dass der Benutzer die richtigen Berechtigungen besitzt, um sich für die angeforderten Tags zu registrieren.You can also add optional checks to verify that the user has rights to register for the requested tags.

    private NotificationHubClient hub;
    
    public RegisterController()
    {
        hub = Notifications.Instance.Hub;
    }
    
    public class DeviceRegistration
    {
        public string Platform { get; set; }
        public string Handle { get; set; }
        public string[] Tags { get; set; }
    }
    
    // POST api/register
    // This creates a registration id
    public async Task<string> Post(string handle = null)
    {
        string newRegistrationId = null;
    
        // make sure there are no existing registrations for this push handle (used for iOS and Android)
        if (handle != null)
        {
            var registrations = await hub.GetRegistrationsByChannelAsync(handle, 100);
    
            foreach (RegistrationDescription registration in registrations)
            {
                if (newRegistrationId == null)
                {
                    newRegistrationId = registration.RegistrationId;
                }
                else
                {
                    await hub.DeleteRegistrationAsync(registration);
                }
            }
        }
    
        if (newRegistrationId == null) 
            newRegistrationId = await hub.CreateRegistrationIdAsync();
    
        return newRegistrationId;
    }
    
    // PUT api/register/5
    // This creates or updates a registration (with provided channelURI) at the specified id
    public async Task<HttpResponseMessage> Put(string id, DeviceRegistration deviceUpdate)
    {
        RegistrationDescription registration = null;
        switch (deviceUpdate.Platform)
        {
            case "mpns":
                registration = new MpnsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "wns":
                registration = new WindowsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "apns":
                registration = new AppleRegistrationDescription(deviceUpdate.Handle);
                break;
            case "fcm":
                registration = new FcmRegistrationDescription(deviceUpdate.Handle);
                break;
            default:
                throw new HttpResponseException(HttpStatusCode.BadRequest);
        }
    
        registration.RegistrationId = id;
        var username = HttpContext.Current.User.Identity.Name;
    
        // add check if user is allowed to add these tags
        registration.Tags = new HashSet<string>(deviceUpdate.Tags);
        registration.Tags.Add("username:" + username);
    
        try
        {
            await hub.CreateOrUpdateRegistrationAsync(registration);
        }
        catch (MessagingException e)
        {
            ReturnGoneIfHubResponseIsGone(e);
        }
    
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    // DELETE api/register/5
    public async Task<HttpResponseMessage> Delete(string id)
    {
        await hub.DeleteRegistrationAsync(id);
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    private static void ReturnGoneIfHubResponseIsGone(MessagingException e)
    {
        var webex = e.InnerException as WebException;
        if (webex.Status == WebExceptionStatus.ProtocolError)
        {
            var response = (HttpWebResponse)webex.Response;
            if (response.StatusCode == HttpStatusCode.Gone)
                throw new HttpRequestException(HttpStatusCode.Gone.ToString());
        }
    }
    
  12. Speichern Sie die Änderungen.Save your changes.

Senden von Benachrichtigungen über das WebAPI-Back-EndSend notifications from the WebAPI backend

In diesem Abschnitt wird ein neuer Controller hinzugefügt, der Clientgeräten das Senden einer Benachrichtigung ermöglicht.In this section, you add a new controller that exposes a way for client devices to send a notification. Die Benachrichtigung basiert auf dem Benutzernamentag, das die Azure Notification Hubs .NET-Bibliothek des ASP.NET WebAPI-Back-Ends verwendet.The notification is based on the username tag that uses Azure Notification Hubs .NET Library in the ASP.NET WebAPI backend.

  1. Erstellen Sie einen weiteren neuen Domänencontroller namens NotificationsController. Verwenden Sie dazu die gleiche Vorgehensweise wie bei der Erstellung von RegisterController im vorherigen Abschnitt.Create another new controller named NotificationsController the same way you created RegisterController in the previous section.

  2. Fügen Sie in der Datei "NotificationsController.cs" die folgenden using -Anweisungen hinzu:In NotificationsController.cs, add the following using statements:

    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  3. Fügen Sie der Klasse NotificationsController die folgende Methode hinzu:Add the following method to the NotificationsController class:

    Mit diesem Code wird ein Benachrichtigungstyp gesendet, der auf dem Parameter pns des Plattformbenachrichtigungssystems (Plattform Notification System, PNS) basiert.This code sends a notification type that's based on the Platform Notification Service (PNS) pns parameter. Der Wert von to_tag dient zum Festlegen des username -Tags in der Nachricht.The value of to_tag is used to set the username tag on the message. Dieses Tag muss mit einem Benutzernamentag einer aktiven Notification Hub-Registrierung übereinstimmen.This tag must match a username tag of an active notification hub registration. Die Benachrichtigung wird aus dem Text der POST-Anforderung abgerufen und für den Ziel-PNS formatiert.The notification message is pulled from the body of the POST request and formatted for the target PNS.

    Abhängig von dem PNS, mit dem Ihre unterstützten Geräte Benachrichtigungen empfangen, werden Benachrichtigungen mit unterschiedlichen Formaten unterstützt.Depending on the PNS that your supported devices use to receive notifications, the notifications are supported by a variety of formats. Ein Beispiel: Angenommen, Sie verwenden auf Windows-Geräten eine Popupbenachrichtigung mit WNS, die nicht direkt durch ein anderes PNS unterstützt wird.For example, on Windows devices, you might use a toast notification with WNS that isn't directly supported by another PNS. In diesem Fall muss Ihr Back-End die Benachrichtigung so formatieren, dass sie mit dem PNS der zu unterstützenden Geräte kompatibel ist.In such an instance, your backend needs to format the notification into a supported notification for the PNS of devices you plan to support. Verwenden Sie anschließend die entsprechende Sende-API für die NotificationHubClient-Klasse.Then use the appropriate send API on the NotificationHubClient class.

    public async Task<HttpResponseMessage> Post(string pns, [FromBody]string message, string to_tag)
    {
        var user = HttpContext.Current.User.Identity.Name;
        string[] userTag = new string[2];
        userTag[0] = "username:" + to_tag;
        userTag[1] = "from:" + user;
    
        Microsoft.Azure.NotificationHubs.NotificationOutcome outcome = null;
        HttpStatusCode ret = HttpStatusCode.InternalServerError;
    
        switch (pns.ToLower())
        {
            case "wns":
                // Windows 8.1 / Windows Phone 8.1
                var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">" + 
                            "From " + user + ": " + message + "</text></binding></visual></toast>";
                outcome = await Notifications.Instance.Hub.SendWindowsNativeNotificationAsync(toast, userTag);
                break;
            case "apns":
                // iOS
                var alert = "{\"aps\":{\"alert\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendAppleNativeNotificationAsync(alert, userTag);
                break;
            case "fcm":
                // Android
                var notif = "{ \"data\" : {\"message\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendFcmNativeNotificationAsync(notif, userTag);
                break;
        }
    
        if (outcome != null)
        {
            if (!((outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Abandoned) ||
                (outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Unknown)))
            {
                ret = HttpStatusCode.OK;
            }
        }
    
        return Request.CreateResponse(ret);
    }
    
  4. Drücken Sie F5, um die Anwendung auszuführen und sich zu vergewissern, dass soweit alles funktioniert.To run the application and ensure the accuracy of your work so far, select the F5 key. Die App öffnet einen Webbrowser und wird auf der Homepage von ASP.NET angezeigt.The app opens a web browser, and it is displayed on the ASP.NET home page.

Veröffentlichen des neuen WebAPI-Back-EndsPublish the new WebAPI backend

Als Nächstes wird die App auf einer Azure-Website bereitgestellt, damit sie für alle Geräte zur Verfügung steht.Next, you deploy the app to an Azure website to make it accessible from all devices.

  1. Klicken Sie mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie Veröffentlichen aus.Right-click the AppBackend project, and then select Publish.

  2. Wählen Sie Microsoft Azure App Service als Veröffentlichungsziel und anschließend **Veröffentlichen aus.Select Microsoft Azure App Service as your publish target, and then select **Publish. Das Fenster „App Service erstellen“ wird geöffnet.The Create App Service window opens. Hier können Sie alle Azure-Ressourcen erstellen, die zum Ausführen der ASP.NET-Web-App in Azure benötigt werden.Here you can create all the necessary Azure resources to run the ASP.NET web app in Azure.

    Die Kachel „Microsoft Azure App Service“

  3. Wählen Sie im Fenster App Service erstellen Ihr Azure-Konto aus.In the Create App Service window, select your Azure account. Wählen Sie Typ ändern > Web App aus.Select Change Type > Web App. Behalten Sie den Standardwert für Web-App-Name bei, und wählen Sie Abonnement, Ressourcengruppe und App Service-Plan aus.Keep the default Web App Name, and then select the Subscription, Resource Group, and App Service Plan.

  4. Klicken Sie auf Erstellen.Select Create.

  5. Notieren Sie sich die Website-URL aus der Zusammenfassung.Make a note of the Site URL property in the Summary section. Diese URL ist später im Tutorial Ihr Back-End-Endpunkt.This URL is your back-end endpoint later in the tutorial.

  6. Wählen Sie Veröffentlichen.Select Publish.

Nach Abschluss des Assistenten wird die ASP.NET Web-App in Azure veröffentlicht und anschließend im Standardbrowser geöffnet.After you've completed the wizard, it publishes the ASP.NET web app to Azure and then opens the app in the default browser. Ihre Anwendung kann in Azure App Services angezeigt werden.Your application is viewable in Azure App Services.

In der URL wird der von Ihnen angegebene Web-App-Name im Format „http://.azurewebsites.net“ verwendet.The URL uses the web app name that you specified earlier, with the format http://<app_name>.azurewebsites.net.

Aktualisieren des Codes für den UWP-ClientUpdate the code for the UWP client

In diesem Abschnitt aktualisieren Sie den Code des Projekts, das Sie unter Tutorial: Senden von Benachrichtigungen an Apps für die universelle Windows-Plattform mit Azure Notification Hubs erstellt haben.In this section, you update the code in the project you completed for the Tutorial: Send notifications to Universal Windows Platform apps by using Azure Notification Hubs tutorial. Das Projekt sollte bereits mit dem Windows Store verknüpft sein.The project should already be associated with the Windows store. Es sollte auch so konfiguriert sein, dass es Ihren Benachrichtigungs-Hub verwendet.It also should be configured to use your notification hub. In diesem Abschnitt fügen Sie Code hinzu, um das neue WebAPI-Back-End aufzurufen und es zum Registrieren und Senden von Benachrichtigungen zu verwenden.In this section, you add code to call the new WebAPI backend and use it for registering and sending notifications.

  1. Öffnen Sie in Visual Studio die Projektmappe, die Sie unter Tutorial: Senden von Benachrichtigungen an Apps für die universelle Windows-Plattform mit Azure Notification Hubs erstellt haben.In Visual Studio, open the solution you created for the Tutorial: Send notifications to Universal Windows Platform apps by using Azure Notification Hubs.

  2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das UWP-Projekt (Universelle Windows-Plattform), und klicken Sie dann auf NuGet-Pakete verwalten.In Solution Explorer, right-click the Universal Windows Platform (UWP) project and then click Manage NuGet Packages.

  3. Wählen Sie auf der linken Seite Durchsuchen aus.On the left-hand side, select Browse.

  4. Geben Sie in das Suchfeld den Begriff Http Client ein.In the Search box, type Http Client.

  5. Klicken Sie in der Ergebnisliste auf System.Net.Http und dann auf Installieren.In the results list, click System.Net.Http, and click Install. Schließen Sie die Installation ab.Complete the installation.

  6. Geben Sie in das NuGet-Suchfeld die Zeichenfolge Json.net ein.Back in the NuGet Search box, type Json.net. Installieren Sie das Paket Newtonsoft.json, und schließen Sie dann das Fenster des NuGet-Paket-Managers.Install the Newtonsoft.json package, and then close the NuGet Package Manager window.

  7. Doppelklicken Sie im Projektmappen-Explorer im Projekt WindowsApp auf MainPage.xaml, um die Datei im Visual Studio-Editor zu öffnen.In Solution Explorer, in the WindowsApp project, double-click MainPage.xaml to open it in the Visual Studio editor.

  8. Ersetzen Sie im XML-Code von MainPage.xaml den Abschnitt <Grid> durch den folgenden Code: Dieser Code fügt ein Textfeld für den Benutzernamen und das Kennwort hinzu, mit denen sich der Benutzer authentifiziert.In the MainPage.xaml XML code, replace the <Grid> section with the following code: This code adds a username and password textbox that the user authenticates with. Darüber hinaus werden Textfelder für die Benachrichtigungsmeldung und das Benutzernamentag hinzugefügt, das die Benachrichtigung empfangen soll:It also adds text boxes for the notification message and the username tag that should receive the notification:

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
    
        <TextBlock Grid.Row="0" Text="Notify Users" HorizontalAlignment="Center" FontSize="48"/>
    
        <StackPanel Grid.Row="1" VerticalAlignment="Center">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition></ColumnDefinition>
                    <ColumnDefinition></ColumnDefinition>
                    <ColumnDefinition></ColumnDefinition>
                </Grid.ColumnDefinitions>
                <TextBlock Grid.Row="0" Grid.ColumnSpan="3" Text="Username" FontSize="24" Margin="20,0,20,0"/>
                <TextBox Name="UsernameTextBox" Grid.Row="1" Grid.ColumnSpan="3" Margin="20,0,20,0"/>
                <TextBlock Grid.Row="2" Grid.ColumnSpan="3" Text="Password" FontSize="24" Margin="20,0,20,0" />
                <PasswordBox Name="PasswordTextBox" Grid.Row="3" Grid.ColumnSpan="3" Margin="20,0,20,0"/>
    
                <Button Grid.Row="4" Grid.ColumnSpan="3" HorizontalAlignment="Center" VerticalAlignment="Center"
                            Content="1. Login and register" Click="LoginAndRegisterClick" Margin="0,0,0,20"/>
    
                <ToggleButton Name="toggleWNS" Grid.Row="5" Grid.Column="0" HorizontalAlignment="Right" Content="WNS" IsChecked="True" />
                <ToggleButton Name="toggleFCM" Grid.Row="5" Grid.Column="1" HorizontalAlignment="Center" Content="FCM" />
                <ToggleButton Name="toggleAPNS" Grid.Row="5" Grid.Column="2" HorizontalAlignment="Left" Content="APNS" />
    
                <TextBlock Grid.Row="6" Grid.ColumnSpan="3" Text="Username Tag To Send To" FontSize="24" Margin="20,0,20,0"/>
                <TextBox Name="ToUserTagTextBox" Grid.Row="7" Grid.ColumnSpan="3" Margin="20,0,20,0" TextWrapping="Wrap" />
                <TextBlock Grid.Row="8" Grid.ColumnSpan="3" Text="Enter Notification Message" FontSize="24" Margin="20,0,20,0"/>
                <TextBox Name="NotificationMessageTextBox" Grid.Row="9" Grid.ColumnSpan="3" Margin="20,0,20,0" TextWrapping="Wrap" />
                <Button Grid.Row="10" Grid.ColumnSpan="3" HorizontalAlignment="Center" Content="2. Send push" Click="PushClick" Name="SendPushButton" />
            </Grid>
        </StackPanel>
    </Grid>
    
  9. Öffnen Sie im Projektmappen-Explorer die Datei MainPage.xaml.cs für die Projekte (Windows 8.1) und (Windows Phone 8.1) .In Solution Explorer, open the MainPage.xaml.cs file for the (Windows 8.1) and (Windows Phone 8.1) projects. Fügen Sie am Anfang der beiden Dateien die folgenden using -Anweisungen ein:Add the following using statements at the top of both files:

    using System.Net.Http;
    using Windows.Storage;
    using System.Net.Http.Headers;
    using Windows.Networking.PushNotifications;
    using Windows.UI.Popups;
    using System.Threading.Tasks;
    
  10. Fügen Sie in MainPage.xaml.cs für das Projekt WindowsApp das folgende Element der MainPage-Klasse hinzu.In MainPage.xaml.cs for the WindowsApp project, add the following member to the MainPage class. Ersetzen Sie <Enter Your Backend Endpoint> unbedingt durch den tatsächlichen Back-End-Endpunkt, den Sie zuvor abgerufen haben.Be sure to replace <Enter Your Backend Endpoint> with your actual backend endpoint obtained previously. Beispiel: http://mybackend.azurewebsites.net.For example, http://mybackend.azurewebsites.net.

    private static string BACKEND_ENDPOINT = "<Enter Your Backend Endpoint>";
    
  11. Fügen Sie den folgenden Code der MainPage-Klasse in MainPage.xaml.cs für die Projekte (Windows 8.1) und (Windows Phone 8.1) hinzu.Add the code below to the MainPage class in MainPage.xaml.cs for the (Windows 8.1) and (Windows Phone 8.1) projects.

    Die PushClick -Methode ist ein Klick-Handler für die Schaltfläche Send Push .The PushClick method is the click handler for the Send Push button. Sie ruft den Back-End auf, um eine Benachrichtigung an alle Geräte mit einem Benutzernamentag zu senden, das dem to_tag -Parameter entspricht.It calls the backend to trigger a notification to all devices with a username tag that matches the to_tag parameter. Die Benachrichtigungsmeldung wird als JSON-Inhalt im Anforderungstext gesendet.The notification message is sent as JSON content in the request body.

    Die LoginAndRegisterClick-Methode ist ein Klickhandler für die Schaltfläche Login and register.The LoginAndRegisterClick method is the click handler for the Login and register button. Sie speichert das Token für die Standardauthentifizierung (kann ein beliebiges von Ihrem Authentifizierungsschema verwendetes Token sein) im lokalen Speicher und verwendet dann RegisterClient zur Registrierung für Benachrichtigungen mithilfe des Back-Ends.It stores the basic authentication token (represents any token your authentication scheme uses) in local storage, then uses RegisterClient to register for notifications using the backend.

    private async void PushClick(object sender, RoutedEventArgs e)
    {
        if (toggleWNS.IsChecked.Value)
        {
            await sendPush("wns", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);
        }
        if (toggleFCM.IsChecked.Value)
        {
            await sendPush("fcm", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);
        }
        if (toggleAPNS.IsChecked.Value)
        {
            await sendPush("apns", ToUserTagTextBox.Text, this.NotificationMessageTextBox.Text);
    
        }
    }
    
    private async Task sendPush(string pns, string userTag, string message)
    {
        var POST_URL = BACKEND_ENDPOINT + "/api/notifications?pns=" +
            pns + "&to_tag=" + userTag;
    
        using (var httpClient = new HttpClient())
        {
            var settings = ApplicationData.Current.LocalSettings.Values;
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string)settings["AuthenticationToken"]);
    
            try
            {
                await httpClient.PostAsync(POST_URL, new StringContent("\"" + message + "\"",
                    System.Text.Encoding.UTF8, "application/json"));
            }
            catch (Exception ex)
            {
                MessageDialog alert = new MessageDialog(ex.Message, "Failed to send " + pns + " message");
                alert.ShowAsync();
            }
        }
    }
    
    private async void LoginAndRegisterClick(object sender, RoutedEventArgs e)
    {
        SetAuthenticationTokenInLocalStorage();
    
        var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
    
        // The "username:<user name>" tag gets automatically added by the message handler in the backend.
        // The tag passed here can be whatever other tags you may want to use.
        try
        {
            // The device handle used is different depending on the device and PNS.
            // Windows devices use the channel uri as the PNS handle.
            await new RegisterClient(BACKEND_ENDPOINT).RegisterAsync(channel.Uri, new string[] { "myTag" });
    
            var dialog = new MessageDialog("Registered as: " + UsernameTextBox.Text);
            dialog.Commands.Add(new UICommand("OK"));
            await dialog.ShowAsync();
            SendPushButton.IsEnabled = true;
        }
        catch (Exception ex)
        {
            MessageDialog alert = new MessageDialog(ex.Message, "Failed to register with RegisterClient");
            alert.ShowAsync();
        }
    }
    
    private void SetAuthenticationTokenInLocalStorage()
    {
        string username = UsernameTextBox.Text;
        string password = PasswordTextBox.Password;
    
        var token = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(username + ":" + password));
        ApplicationData.Current.LocalSettings.Values["AuthenticationToken"] = token;
    }
    
  12. Öffnen Sie App.xaml.cs, und suchen Sie im Ereignishandler InitNotificationsAsync() nach dem Aufruf von OnLaunched().Open App.xaml.cs and find the call to InitNotificationsAsync() in the OnLaunched() event handler. Kommentieren Sie den Aufruf von InitNotificationsAsync()aus, oder löschen Sie ihn.Comment out or delete the call to InitNotificationsAsync(). Der zuvor hinzugefügte Schaltflächenhandler initialisiert Benachrichtigungsregistrierungen.The button handler initializes notification registrations.

    protected override void OnLaunched(LaunchActivatedEventArgs e)
    {
        //InitNotificationsAsync();
    
  13. Klicken Sie mit der rechten Maustaste auf das Projekt WindowsApp, klicken Sie auf Hinzufügen und dann auf Klasse.Right-click the WindowsApp project, click Add, and then click Class. Nennen Sie die Klasse RegisterClient.cs, und klicken Sie dann auf OK, um die Klasse zu generieren.Name the class RegisterClient.cs, then click OK to generate the class.

    Diese Klasse umschließt die REST-Aufrufe, die für das Kontaktieren des App-Back-Ends erforderlich sind, um sich für Pushbenachrichtigungen zu registrieren.This class wraps the REST calls required to contact the app backend, in order to register for push notifications. Außerdem werden die vom Notification Hub erstellten registrationIds lokal gespeichert, wie unter Registrierung vom App-Back-End ausbeschrieben.It also locally stores the registrationIds created by the Notification Hub as detailed in Registering from your app backend. Wenn Sie auf die Schaltfläche Log in and register klicken, wird ein Authentifizierungstoken aus dem lokalen Speicher verwendet.It uses an authorization token stored in local storage when you click the Login and register button.

  14. Fügen Sie die folgenden using -Anweisungen am Anfang der Datei "RegisterClient.cs" hinzu:Add the following using statements at the top of the RegisterClient.cs file:

    using Windows.Storage;
    using System.Net;
    using System.Net.Http;
    using System.Net.Http.Headers;
    using Newtonsoft.Json;
    using System.Threading.Tasks;
    using System.Linq;
    
  15. Fügen Sie innerhalb der RegisterClient -Klassendefinition den folgenden Code hinzu.Add the following code inside the RegisterClient class definition.

    private string POST_URL;
    
    private class DeviceRegistration
    {
        public string Platform { get; set; }
        public string Handle { get; set; }
        public string[] Tags { get; set; }
    }
    
    public RegisterClient(string backendEndpoint)
    {
        POST_URL = backendEndpoint + "/api/register";
    }
    
    public async Task RegisterAsync(string handle, IEnumerable<string> tags)
    {
        var regId = await RetrieveRegistrationIdOrRequestNewOneAsync();
    
        var deviceRegistration = new DeviceRegistration
        {
            Platform = "wns",
            Handle = handle,
            Tags = tags.ToArray<string>()
        };
    
        var statusCode = await UpdateRegistrationAsync(regId, deviceRegistration);
    
        if (statusCode == HttpStatusCode.Gone)
        {
            // regId is expired, deleting from local storage & recreating
            var settings = ApplicationData.Current.LocalSettings.Values;
            settings.Remove("__NHRegistrationId");
            regId = await RetrieveRegistrationIdOrRequestNewOneAsync();
            statusCode = await UpdateRegistrationAsync(regId, deviceRegistration);
        }
    
        if (statusCode != HttpStatusCode.Accepted && statusCode != HttpStatusCode.OK)
        {
            // log or throw
            throw new System.Net.WebException(statusCode.ToString());
        }
    }
    
    private async Task<HttpStatusCode> UpdateRegistrationAsync(string regId, DeviceRegistration deviceRegistration)
    {
        using (var httpClient = new HttpClient())
        {
            var settings = ApplicationData.Current.LocalSettings.Values;
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string) settings["AuthenticationToken"]);
    
            var putUri = POST_URL + "/" + regId;
    
            string json = JsonConvert.SerializeObject(deviceRegistration);
                            var response = await httpClient.PutAsync(putUri, new StringContent(json, Encoding.UTF8, "application/json"));
            return response.StatusCode;
        }
    }
    
    private async Task<string> RetrieveRegistrationIdOrRequestNewOneAsync()
    {
        var settings = ApplicationData.Current.LocalSettings.Values;
        if (!settings.ContainsKey("__NHRegistrationId"))
        {
            using (var httpClient = new HttpClient())
            {
                httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string)settings["AuthenticationToken"]);
    
                var response = await httpClient.PostAsync(POST_URL, new StringContent(""));
                if (response.IsSuccessStatusCode)
                {
                    string regId = await response.Content.ReadAsStringAsync();
                    regId = regId.Substring(1, regId.Length - 2);
                    settings.Add("__NHRegistrationId", regId);
                }
                else
                {
                    throw new System.Net.WebException(response.StatusCode.ToString());
                }
            }
        }
        return (string)settings["__NHRegistrationId"];
    
    }
    
  16. Speichern Sie alle Änderungen.Save all your changes.

Testen der AnwendungTest the Application

  1. Starten Sie die Anwendung unter beiden Windows-Versionen.Launch the application on both Windows.

  2. Geben Sie einen Benutzernamen und ein Kennwort ein, wie im folgenden Bildschirm dargestellt.Enter a Username and Password as shown in the screen below. Sie sollten einen anderen Benutzernamen und ein anders Kennwort als in Windows Phone eingeben.It should differ from the user name and password you enter on Windows Phone.

  3. Klicken Sie auf Login and register , und überprüfen Sie, ob ein Dialogfeld anzeigt, dass Sie sich angemeldet haben.Click Log in and register and verify a dialog shows that you have logged in. Durch diesen Code wird auch die Schaltfläche Send Push aktiviert.This code also enables the Send Push button.

  4. Geben Sie dann im Feld Recipient Username Tag den registrierten Benutzernamen ein.Then in the Recipient Username Tag field, enter the user name registered. Geben Sie eine Benachrichtigungsmeldung ein, und klicken Sie auf Send Push.Enter a notification message and click Send Push.

  5. Nur die Geräte, die mit dem entsprechenden Benutzernamentag registriert wurden, erhalten eine Benachrichtigungsmeldung.Only the devices that have registered with the matching username tag receive the notification message.

Nächste SchritteNext steps

In diesem Tutorial haben Sie gelernt, wie Sie Pushbenachrichtigungen an bestimmte Benutzer senden, deren Registrierungen Tags zugeordnet sind.In this tutorial, you learned how to push notifications to specific users that have tags associated with their registrations. Um zu erfahren, wie Sie standortbasierte Pushbenachrichtigungen senden, fahren Sie mit dem folgenden Tutorial fort:To learn how to push location-based notifications, advance to the following tutorial: