(0) exportieren Drucken
Alle erweitern
Erweitern Minimieren
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen.
Übersetzung
Original

Vorgehensweise: Konfigurieren und Verwenden von Pushbenachrichtigungen in SharePoint 2013 apps für Windows Phone

SharePoint 2013

Erstellen Sie eine Projektmappe in SharePoint Server für das Senden von Push-Benachrichtigungen und entwickeln Sie eine Windows Phone app für den Empfang von Benachrichtigungen zu.

Letzte Änderung: Dienstag, 24. Juni 2014

Gilt für: SharePoint Foundation 2013 | SharePoint Server 2013

Microsoft Push Notification Service (MPNS) verwenden, können Windows Phone apps für Microsoft SharePoint Serverausgelösten Ereignissen Benachrichtigungen über das Internet erhalten. Telefon app muss Server für Änderungen, z. B. die Elemente in einer Liste die Abfragen auf dem Telefon app basiert. Die app kann registriert werden, um Benachrichtigungen vom Server zu erhalten und ein Ereignisempfänger kann eine Benachrichtigung zu initiieren und senden Sie sie an die empfangende Anwendung für die Behandlung. Die Push-Benachrichtigung wird von MPNS mit Windows Phone-Geräten weitergeleitet.

Windows Phone 7 unterstützt nicht mehrere Anwendungen gleichzeitig ausführen. Als Komponenten des Betriebssystems Windows Phone (OS) selbst kann nur eine Anwendung auf dem Telefon zu einem Zeitpunkt ausgeführt werden. Ein Ereignis für einen bestimmten Telefon app auftreten (wie beispielsweise ein Element einer Liste hinzugefügt wird) bei die Anwendung auf dem Telefon im Vordergrund ausgeführt ist nicht (d. h. wenn die app veraltet oder geschlossen ist). Sie könnten Hintergrunddienst am Telefon eine periodische Aufgabe, die Änderungen an der Liste auf dem Server überprüfen kann entwickeln, aber dieser Ansatz würde verbrauchen Ressourcen (z. B. Netzwerk-Bandbreite und Akku Power) am Telefon. Mit MPNS und die Komponenten, die Unterstützung von Benachrichtigungen in Windows Phone 7-Betriebssystem integriert, das Telefon selbst kann erhalten eine Benachrichtigung, die von einer bestimmten Anwendung für den Kontext relevant – Wenn auch nicht, dass app ausgeführt wird – und der Benutzer kann die Möglichkeit zum Starten der entsprechenden Anwendung als Reaktion auf die Benachrichtigung angegeben werden. (Weitere Informationen über Push-Benachrichtigungen finden Sie Push-Benachrichtigungen Übersicht für Windows Phone in der MSDN-Bibliothek.)

In diesem Thema erstellen Sie eine serverseitige Lösung zum Senden von Push-Benachrichtigungen an ein Telefon app auf Grundlage einer Änderung in der Liste, auf der die Anwendung basiert. Anschließend erstellen Sie für den Empfang dieser Benachrichtigungen Telefon app.

Die serverseitige Lösung kann entweder eine SharePoint-Anwendung in einem isolierten SPWeb Objekt bereitgestellt oder einer SharePoint-Farm-Lösung als ein SharePoint-Lösungspaket (d. h. eine WSP-Datei), das eine Funktion Web-Ebene enthalten. In den Verfahren in diesem Abschnitt entwickeln Sie eine einfache SharePoint-Lösung, die eine Zielliste von Windows Phone-app verwendet werden erstellt und, Push-Benachrichtigung-Mechanismus auf dem Server aktiviert. Im folgenden Abschnitt wird die Windows Phone-app für den Empfang von Benachrichtigungen von der serverseitigen Lösung entwickelt.

Das serverseitige Projekt erstellen

  1. Starten Sie Visual Studio 2012 mit der Option Als Administrator ausführen.

  2. Klicken Sie auf Datei, Neu, Projekt.

    Das Dialogfeld Neues Projekt wird angezeigt.

  3. Erweitern Sie den Knoten SharePoint unter Visual C#klicken Sie im Dialogfeld Neues Projekt , und wählen Sie dann den Knoten 15 .

  4. Klicken Sie im Bereich Vorlagen Wählen Sie SharePoint 2013-Projekt , und geben Sie einen Namen für das Projekt ein, z. B. PushNotificationsList.

  5. Wählen Sie die Schaltfläche " OK ". SharePoint Customization Wizard wird angezeigt. Mit diesem Assistenten können Sie der Zielsite zum Entwickeln und Debuggen das Projekt und die Vertrauensebene der Projektmappe auswählen.

  6. Geben Sie die URL einer Site SharePoint Server . Wählen Sie eine Site, die Sie später in der Entwicklung von der SharePoint Liste app für Windows Phone verwendet werden.

  7. Wählen Sie als Farmlösung bereitstellen, und klicken Sie dann auf Fertig stellen , um das Projekt zu erstellen.

Als Nächstes fügen Sie dem Projekt eine Klassendatei, und erstellen Sie ein paar Klassen kapseln und Push-Benachrichtigungen verwalten.

So erstellen Sie die Klassen für die Verwaltung von Pushbenachrichtigungen

  1. Wählen Sie im Projektmappen-Explorerden Knoten, der das Projekt (mit dem Namen PushNotificationsList , wenn Sie die in diesen Verfahren verwendete Namenskonvention folgen).

  2. Klicken Sie im Menü Projekt auf Klasse hinzufügen. Das Dialogfeld Neues Element hinzufügen wird angezeigt. Die C#-Vorlage Klasse ist bereits ausgewählt.

  3. Geben Sie PushNotification.cs als Namen für die Datei, und klicken Sie auf Hinzufügen. Die Klassendatei ist der Projektmappe hinzugefügt und zur Bearbeitung geöffnet.

  4. Ersetzen Sie den Inhalt der Datei durch den folgenden Code:

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Net;
    using System.Text;
    using Microsoft.SharePoint;
    
    namespace PushNotificationsList
    {
        internal static class WP7Constants
        {
            internal static readonly string[] WP_RESPONSE_HEADERS = 
                {
                    "X-MessageID",
                    "X-DeviceConnectionStatus",
                    "X-SubscriptionStatus",
                    "X-NotificationStatus"
                };
        }
    
        public enum TileIntervalValuesEnum
        {
            ImmediateTile = 1,
            Delay450SecondsTile = 11,
            Delay900SecondsTile = 21,
        }
    
        public enum ToastIntervalValuesEnum
        {
            ImmediateToast = 2,
            Delay450SecondsToast = 12,
            Delay900SecondsToast = 22,
        }
    
        public enum RawIntervalValuesEnum
        {
            ImmediateRaw = 3,
            Delay450SecondsRaw = 13,
            Delay900SecondsRaw = 23
        }
    
        public enum NotificationTypeEnum
        {
            Tile = 1,
            Toast = 2,
            Raw = 3
        }
    
        class PushNotification
        {
            public PushNotificationResponse PushToast(SPPushNotificationSubscriber subscriber, string toastTitle, string toastMessage, string toastParam, ToastIntervalValuesEnum intervalValue)
            {
                // Construct toast notification message from parameter values.
                string toastNotification = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                "<wp:Notification xmlns:wp=\"WPNotification\">" +
                   "<wp:Toast>" +
                        "<wp:Text1>" + toastTitle + "</wp:Text1>" +
                        "<wp:Text2>" + toastMessage + "</wp:Text2>" +
                        "<wp:Param>" + toastParam + "</wp:Param>" +
                   "</wp:Toast> " +
                "</wp:Notification>";
    
                return SendPushNotification(NotificationTypeEnum.Toast, subscriber, toastNotification, (int)intervalValue);
            }
    
            public PushNotificationResponse PushRaw(SPPushNotificationSubscriber subscriber, string rawMessage, RawIntervalValuesEnum intervalValue)
            {
                return SendPushNotification(NotificationTypeEnum.Raw, subscriber, rawMessage, (int)intervalValue);
            }
    
            private PushNotificationResponse SendPushNotification(NotificationTypeEnum notificationType, SPPushNotificationSubscriber subscriber, string message, int intervalValue)
            {
                // Create HTTP Web Request object.
                string subscriptionUri = subscriber.ServiceToken;
                HttpWebRequest sendNotificationRequest = (HttpWebRequest)WebRequest.Create(subscriptionUri);
    
                // MPNS expects a byte array, so convert message accordingly.
                byte[] notificationMessage = Encoding.Default.GetBytes(message);
                
                // Set the notification request properties.
                sendNotificationRequest.Method = WebRequestMethods.Http.Post;
                sendNotificationRequest.ContentLength = notificationMessage.Length;
                sendNotificationRequest.ContentType = "text/xml";
                sendNotificationRequest.Headers.Add("X-MessageID", Guid.NewGuid().ToString());
    
                switch (notificationType)
                {
                    case NotificationTypeEnum.Tile:
                        sendNotificationRequest.Headers.Add("X-WindowsPhone-Target", "token");
                        break;
                    case NotificationTypeEnum.Toast:
                        sendNotificationRequest.Headers.Add("X-WindowsPhone-Target", "toast");
                        break;
                    case NotificationTypeEnum.Raw:
                        // A value for the X-WindowsPhone-Target header is not specified for raw notifications.
                        break;
                }            
    
                sendNotificationRequest.Headers.Add("X-NotificationClass", intervalValue.ToString());
    
                // Merge byte array payload with headers.
                using (Stream requestStream = sendNotificationRequest.GetRequestStream())
                {
                    requestStream.Write(notificationMessage, 0, notificationMessage.Length);
                }
    
                string statCode = string.Empty;
                PushNotificationResponse notificationResponse;
    
                try
                {
                    // Send the notification and get the response.
                    HttpWebResponse response = (HttpWebResponse)sendNotificationRequest.GetResponse();
                    statCode = Enum.GetName(typeof(HttpStatusCode), response.StatusCode);
    
                    // Create PushNotificationResponse object.
                    notificationResponse = new PushNotificationResponse((int)intervalValue, subscriber.ServiceToken);
                    notificationResponse.StatusCode = statCode;
                    foreach (string header in WP7Constants.WP_RESPONSE_HEADERS)
                    {
                        notificationResponse.Properties[header] = response.Headers[header];
                    }                
                }
                catch (Exception ex)
                {
                    statCode = ex.Message;
                    notificationResponse = new PushNotificationResponse((int)intervalValue, subscriber.ServiceToken);
                    notificationResponse.StatusCode = statCode;
                }
    
                return notificationResponse;
            }
        }     
    
        /// <summary>
        /// Object used for returning notification request results.
        /// </summary>
        class PushNotificationResponse
        {
            private DateTime timestamp;
            private int notificationIntervalValue;
            private string statusCode = string.Empty;
            private string serviceToken;
            private Dictionary<string, string> properties;
    
            public PushNotificationResponse(int numericalIntervalValue, string srvcToken)
            {
                timestamp = DateTime.UtcNow;
                notificationIntervalValue = numericalIntervalValue;
                serviceToken = srvcToken;
                properties = new Dictionary<string, string>();
            }
    
            public DateTime TimeStamp
            {
                get { return timestamp; }
            }
    
            public int NotificationIntervalValue
            {
                get { return notificationIntervalValue; }
            }
    
            public string StatusCode
            {
                get { return statusCode; }
                set { statusCode = value; }
            }
    
            public string ServiceToken
            {
                get { return serviceToken; }
            }
    
            public Dictionary<string, string> Properties
            {
                get { return properties; }
            }
        }
    }
    
  5. Speichern Sie die Datei.

In diesem Code werden die Methoden PushToast und PushRaw Parameterargumente für den angegebenen Typ der Benachrichtigung senden, verarbeitet diese Argumente und rufen Sie dann die SendPushNotification -Methode, die die Benachrichtigung mit dem Microsoft Push Notification Service erfolgt. (Im folgenden Beispielcode ist eine Methode zum Senden von Benachrichtigungen Kachel nicht implementiert.) Die PushNotificationResponse -Klasse ist einfach ein Mechanismus zum Einkapseln des Ergebnis aus der Benachrichtigungsanforderung empfangen. Die Klasse fügt hier einige Informationen für das Objekt (Cast als HttpWebResponse Objekt) von der GetResponse -Methode des HttpWebRequest -Objekts zurückgegeben. Der Ereignisempfänger, die, den Sie in der folgenden Prozedur erstellen, verwendet diese Klasse PushNotificationResponse um eine Ergebnisliste Benachrichtigungen auf dem Server aktualisieren.

Nun Erstellen einer Ereignisempfängerklasse, die Push-Benachrichtigungen an Geräte senden, die registriert wurden, um sie zu empfangen. (Sie binden dieser Ereignisempfänger an der Liste der Projekte, die in einer späteren Prozedur erstellt wird.)

Die Ereignisempfängerklasse eine Liste erstellen

  1. Wählen Sie im Projektmappen-Explorerden Knoten, der das Projekt darstellt.

  2. Klicken Sie im Menü Projekt auf Klasse hinzufügen. Mit der C#- Klasse Vorlage bereits aktiviert, wird das Dialogfeld Neues Element hinzufügen angezeigt.

  3. Geben Sie ListItemEventReceiver.cs als Namen für die Datei, und klicken Sie auf Hinzufügen. Die Klassendatei ist der Projektmappe hinzugefügt und zur Bearbeitung geöffnet.

  4. Ersetzen Sie den Inhalt der Datei durch den folgenden Code:

    using System;
    using System.Security.Permissions;
    using System.Text;
    using Microsoft.SharePoint;
    using Microsoft.SharePoint.Utilities;
    
    namespace PushNotificationsList
    {
        /// <summary>
        /// List Item Events
        /// </summary>
        public class ListItemEventReceiver : SPItemEventReceiver
        {
            internal static string ResultsList = "Push Notification Results";
    
            /// <summary>
            /// An item was added.
            /// </summary>
            public override void ItemAdded(SPItemEventProperties properties)
            {
                SPWeb spWeb = properties.Web;
                SPPushNotificationSubscriberCollection pushSubscribers = spWeb.PushNotificationSubscribers;
                PushNotification pushNotification = new PushNotification();
    
                SPListItem listItem = properties.ListItem;
    
                string jobAssignment = "[Unassigned]";
    
                // This event receiver is intended to be associated with a specific list,
                // but the list may not have an "AssignedTo" field, so using try/catch here.
                try
                {
                    jobAssignment = listItem["AssignedTo"].ToString();
                }
                catch { }
    
                PushNotificationResponse pushResponse = null;
    
                foreach (SPPushNotificationSubscriber ps in pushSubscribers)
                {
                    // Send a toast notification to be displayed on subscribed phones on which the app is not running.
                    pushResponse = pushNotification.PushToast(ps, "New job for:", jobAssignment, string.Empty, ToastIntervalValuesEnum.ImmediateToast);
                    UpdateNotificationResultsList(spWeb, ps.User.Name, pushResponse);
    
                    // Also send a raw notification to be displayed on subscribed phones on which the app is running when the item is added.
                    pushResponse = pushNotification.PushRaw(ps, string.Format("New job for: {0}", jobAssignment), RawIntervalValuesEnum.ImmediateRaw);
                    UpdateNotificationResultsList(spWeb, ps.User.Name, pushResponse);
                }
    
                base.ItemAdded(properties);
            }
    
            private void UpdateNotificationResultsList(SPWeb spWeb, string subscriberName, PushNotificationResponse pushResponse)
            {
                SPList resultsList = spWeb.Lists.TryGetList(ResultsList);
    
                if (resultsList == null)
                    return;
    
                try
                {
                    SPListItem resultItem = resultsList.Items.Add();
                    resultItem["Title"] = subscriberName;
                    resultItem["Notification Time"] = pushResponse.TimeStamp;
                    resultItem["Status Code"] = pushResponse.StatusCode;
                    resultItem["Service Token"] = pushResponse.ServiceToken;
    
                    StringBuilder builder = new StringBuilder();
                    foreach (string key in pushResponse.Properties.Keys)
                    {
                        builder.AppendFormat("{0}: {1}; ", key, pushResponse.Properties[key]);
                    }
                    resultItem["Headers"] = builder.ToString();
    
                    resultItem["Interval Value"] = pushResponse.NotificationIntervalValue;
                    resultItem.Update();
                }
                catch
                {
                    // Could log to ULS here if adding list item fails.
                }
            }
        }
    }
    
  5. Speichern Sie die Datei.

In diesem Code nach der Liste ein Element hinzugefügt wird, der Ereignisempfänger gebunden ist, werden Push-Benachrichtigungen an Abonnenten gesendet, die registriert haben, um Benachrichtigungen zu erhalten. Der Wert des Felds ' ZugewiesenAn ' aus dem hinzugefügten Element gehört die Benachrichtigung an die Abonnenten gesendet. Für die Benachrichtigung Spruch werden die Werte des Parameters toastTitle (für die PushToast -Methode in der vorangehenden Prozedur definiert) und den toastMessage -Parameter festgelegt. Diese Werte entsprechen den Eigenschaften Text1 und Text2 im XML-Schema, das Benachrichtigungen Toast definiert.

Eine leere Zeichenfolge ist einfach als Wert des toastParam -Parameters übergeben wird, entspricht der Param -Eigenschaft im XML-Schema für Toast Benachrichtigungen. Diese Parameter können an, z. B. eine Seite öffnen, klickt der Benutzer auf die Benachrichtigung auf dem Mobiltelefon Telefon app. Im Beispiel Telefon app weiter unten in diesem Thema für den Empfang dieser Benachrichtigungen vom Server entwickelt wird die Param -Eigenschaft nicht verwendet. Das Formular (List.xaml) in der Anwendung ist einfach geöffnet, klickt der Benutzer auf die Benachrichtigung.

Hinweis Hinweis

Die Param -Eigenschaft für Benachrichtigungen Toast ist nur in Windows Phone OS Version 7.1 oder höher unterstützt.

Für die unformatierten Benachrichtigungsdaten in diesem Beispiel wird eine Zeichenfolge übergeben, die den Wert des Feldes ' ZugewiesenAn ' aus dem hinzugefügten Element enthält.

Notiz, die auf die Benachrichtigung Spruch angezeigt werden abonniert Telefone (falls Telefon app für die Benachrichtigung bestimmt ist, nicht ausgeführt wird), und die Meldung angezeigt, wenn er länger als ungefähr 41 Zeichen abgeschnitten. RAW Benachrichtigungen in MPNS sind beschränkt auf 1024 Bytes (1 KB). (Die genaue Anzahl von Zeichen, die gesendet werden können, je nach der Art der verwendet wird, z. B. UTF-8-Codierung). Kachel Benachrichtigungen unterliegen auch Größenbeschränkungen. Große Mengen von Daten können nicht über die Typen von Benachrichtigungen gesendet werden. Die optimale Nutzung dieser Benachrichtigungen ist nicht als Mechanismus für die Übertragung von Daten, aber als eine Möglichkeit zum Senden von kurzer Nachrichten abonniert Telefone, damit bestimmte Aktionen auf dem Telefon durchgeführt werden können. Diese Aktionen, z. B. eine Liste mit den Daten auf dem Server aktualisieren können größere Mengen an Daten, je nach dem Entwurf der Windows Phone-app umfassen.

Das PushNotificationResponse -Objekt, das von einer Benachrichtigungsanforderung zurückgegeben wird, wird der UpdateNotificationResultsList -Methode übergeben. Diese Methode fügt Informationen über die Anforderung mit einer SharePoint-Liste mit der Bezeichnung Push Notification Ergebnisse (wenn die Liste vorhanden ist). Dies ist lediglich eine Demonstration eine Möglichkeit, das zurückgegebene Objekt verwenden. Das zurückgegebene Objekt können Sie anspruchsvollere Verwendungszwecke in einer Produktionslösung einfügen. Sie können z. B. das zurückgegebene Objekt für bestimmte Statuscodes überprüfen, wenn eine an einen bestimmten Benutzer (z. B. der Benutzer für die Zuordnung in das Feld ' ZugewiesenAn ' bezeichnet Benachrichtigung) und die entsprechende Aktion. In einer Produktionsanwendung würde nicht Sie wahrscheinlich alle diese Informationen in einer Liste auf dem Server speichern. Die Informationen werden hier gespeichert wird, um MPNS Benachrichtigungen zugeordneten Eigenschaften besser zu verstehen.

Als Nächstes erstellen Sie eine einfache SharePoint Liste, mit dem Namen Jobs, mit einer Kategorie, eine Beschreibung ein und die Person, die die Aufgabe zugewiesen ist. Außerdem erstellen Sie eine zusätzliche Liste namens Benachrichtigungsergebnisse Push zum Speichern von Informationen zu Benachrichtigungsanforderungen Telefone Abonnement gesendet.

In der folgenden Prozedur erstellen Sie eine Klasse, ListCreator, die eine CreateJobsList Methode für das Erstellen und Konfigurieren der Liste Projekte die Projektmappe aktiviert ist auf dem Server enthält. Die Klasse fügt auch den ItemAdded -Ereignisempfänger (weiter oben in der ListItemEventReceiver -Klasse erstellt) der EventReceivers -Auflistung mit der Liste verknüpft ist. Die ListCreator -Klasse enthält auch eine Methode zum Erstellen der Push Notification Ergebnisse der SharePoint-Liste.

Zum Erstellen einer Klasse zum Hinzufügen und Konfigurieren der Listen

  1. Wählen Sie im Projektmappen-Explorerden Knoten des Projekts (in diesem Fall benannte PushNotificationsList Wenn Sie die in diesen Verfahren verwendete Namenskonvention folgen).

  2. Klicken Sie im Menü Projekt auf Klasse hinzufügen. Mit der C#- Klasse Vorlage bereits aktiviert, wird das Dialogfeld Neues Element hinzufügen angezeigt.

  3. Geben Sie ListCreator.cs als Namen für die Datei, und klicken Sie auf Hinzufügen. Die Klassendatei ist der Projektmappe hinzugefügt und zur Bearbeitung geöffnet.

  4. Ersetzen Sie den Inhalt der Datei durch den folgenden Code:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Xml;
    using Microsoft.SharePoint;
    
    namespace PushNotificationsList
    {
        class ListCreator
        {
            internal void CreateJobsList(SPWeb spWeb)
            {
                string listTitle = "Jobs";
                string listDescription = "List of jobs and assignments.";
                Dictionary<string, SPFieldType> columns = new Dictionary<string, SPFieldType>();
    
                // The "Title" column will be added based on the GenericList template. That field
                // will be used as the category name for the job (e.g., Shopping), so only need to add
                // the remaining fields.
                columns.Add("Description", SPFieldType.Text);
                columns.Add("AssignedTo", SPFieldType.Text);
    
                // Creating list (or retrieving GUID for list if it already exists).
                Guid listId = CreateCustomList(spWeb, listTitle, listDescription, columns, false);
                if (listId.Equals(Guid.Empty))
                    return;
    
                SPList list = spWeb.Lists[listId];
    
                // Add event receiver (if the current Jobs list is not already associated with the receiver).
                bool ReceiverExists = false;
                string receiverClassName = "PushNotificationsList.ListItemEventReceiver";
    
                for (int i = 0; i < list.EventReceivers.Count; i++)
                {
                    SPEventReceiverDefinition rd = list.EventReceivers[i];
                    if (rd.Class == receiverClassName && rd.Type == SPEventReceiverType.ItemAdded)
                    {
                        ReceiverExists = true;
                        break;
                    }
                }
    
                if (ReceiverExists == false)
                {
                    SPEventReceiverDefinition eventReceiver = list.EventReceivers.Add();
                    // Must specify information here for this specific assembly.
                    eventReceiver.Assembly = "PushNotificationsList,
                        Version=1.0.0.0, Culture=Neutral,
                        PublicKeyToken=[YOUR TOKEN VALUE HERE]";
                    eventReceiver.Class = receiverClassName;
                    eventReceiver.Name = "ItemAdded Event";
                    eventReceiver.Type = SPEventReceiverType.ItemAdded;
                    eventReceiver.SequenceNumber = 10000;
                    eventReceiver.Synchronization = SPEventReceiverSynchronization.Synchronous;
                    eventReceiver.Update();
                }
            }
    
            internal void CreateNotificationResultsList(SPWeb spWeb)
            {
                string listTitle = "Push Notification Results";
                string listDescription = "List for results from push notification operations.";
    
                Dictionary<string, SPFieldType> columns = new Dictionary<string, SPFieldType>();
                columns.Add("Notification Time", SPFieldType.Text);
                columns.Add("Status Code", SPFieldType.Text);
                columns.Add("Service Token", SPFieldType.Text);
                columns.Add("Headers", SPFieldType.Text);
                columns.Add("Interval Value", SPFieldType.Integer);
    
                // Creating the list for storing notification results.
                CreateCustomList(spWeb, listTitle, listDescription, columns, true);
            }
    
            /// <summary>
            /// Creates a SharePoint list (based on the Generic List template).
            /// </summary>
            /// <param name="spWeb">The target Web site for the list.</param>
            /// <param name="listTitle">The title of the list.</param>
            /// <param name="listDescription">A description for the list.</param>
            /// <param name="columns">A Dictionary object containing field names and types.</param>
            /// <param name="replaceExistingList">Indicates whether to overwrite an existing list of the same name on the site.</param>
            /// <returns>A GUID for the created (or existing) list.</returns>
            internal Guid CreateCustomList(SPWeb spWeb, string listTitle, string listDescription, Dictionary<string, SPFieldType> columns, bool replaceExistingList)
            {
                SPList list = spWeb.Lists.TryGetList(listTitle);
    
                if (list != null)
                {
                    if (replaceExistingList == true)
                    {
                        try
                        {
                            list.Delete();
                        }
                        catch
                        {
                            return Guid.Empty;
                        }
                    }
                    else
                    {
                        return list.ID;
                    }
                }
    
                try
                {
                    Guid listId = spWeb.Lists.Add(listTitle, listDescription, SPListTemplateType.GenericList);
                    list = spWeb.Lists[listId];
                    SPView view = list.DefaultView;
    
                    foreach (string key in columns.Keys)
                    {
                        list.Fields.Add(key, columns[key], false);
                        view.ViewFields.Add(key);
                    }
                    
                    list.Update();
                    view.Update();
    
                    return listId;
                }
                catch
                {
                    return Guid.Empty;
                }
            }
        }
    }
    

    Achten Sie darauf, dass Sie dem entsprechenden öffentlichen Schlüsseltoken Wert für bestimmte Ihrer Assembly angeben. Ein Tool zum Visual Studio zum Abrufen des öffentlichen Schlüsseltokens Werts für die Assembly finden Sie unter wie: Erstellen eines Tools, das den öffentlichen Schlüssel einer Assembly abrufen in der MSDN Library. Beachten Sie, dass Sie mindestens einmal das Projekt zu kompilieren, um das öffentliche Schlüsseltoken für die Ausgabeassembly nutzen können.

  5. Speichern Sie die Datei.

In diesem Code die CreateJobsList -Methode der ListCreator -Klasse erstellt die Liste (oder ruft die Liste ab, wenn es auf dem Server vorhanden ist) und bindet die Ereignissenke in einem früheren Schritt zur Liste erstellt werden, indem die EventReceivers -Klasse, die der Liste hinzugefügt. Die CreateNotificationResultsList -Methode erstellt die Ergebnisliste für Push-Benachrichtigung.

Fügen Sie anschließend ein Feature zum Projekt um Initialisierungsvorgänge auf dem Server auszuführen, wenn die Projektmappe bereitgestellt und aktiviert ist. Behandeln der Ereignisse FeatureActivated und FeatureDeactivating die Funktion hinzugefügt eine Ereignisempfängerklasse.

Eine Funktion zum Projekt hinzufügen

  1. In Visual Studio 2012, klicken Sie im Menü Ansicht auf Weitere Fenster, und klicken Sie dann auf Paket-Explorer.

  2. Klicken Sie im Paket-Explorerauf den Knoten, das das Projekt darstellt, und klicken Sie auf Funktion hinzufügen. Projekt unter einem Knoten Funktionen (im Projektmappen-Explorer) ist eine neue Funktion (mit dem Namen "Feature1" standardmäßig) hinzugefügt.

  3. Jetzt im Projektmappen-Explorerunter dem Knoten Funktionen mit der rechten Maustaste in des neu hinzugefügten Features ( Feature1) und auf der Ereignisempfänger hinzufügen. Eine Ereignis Receiver-Klassendatei (Feature1.EventReceiver.cs) ist das Feature hinzugefügt und zur Bearbeitung geöffnet.

  4. Fügen Sie innerhalb der Implementierung (von öffnenden und schließenden geschweiften Klammern abgegrenzt) der Feature1EventReceiver -Klasse den folgenden Code ein.

    internal const string PushNotificationFeatureId = "41E1D4BF-B1A2-47F7-AB80-D5D6CBBA3092";
    

    Dieser String-Variable speichert die ID für die Funktion für die Push-Benachrichtigung auf dem Server.

    TippTipp

    Eine Liste von eindeutigen Bezeichnern erhalten für die Features auf einer SharePoint Server Sie durch Ausführen des folgenden Windows PowerShell-Cmdlets:

    Get-SPFeature | Sort -Property DisplayName

    Die Funktion für die Push-Benachrichtigung wird als "PhonePNSubscriber" in den Ergebnissen von dieses Cmdlet zurückgegeben wird.

  5. Die Ereignis Receiver-Klassendatei wird mit einigen Standard Methodendeklarationen zur Behandlung von Ereignissen für die Funktion erstellt. Die Methodendeklarationen in der Datei werden zunächst auskommentiert. Ersetzen Sie die FeatureActivated -Methode in der Datei durch den folgenden Code.

    public override void FeatureActivated(SPFeatureReceiverProperties properties)
    {
        base.FeatureActivated(properties);
        SPWeb spWeb = (SPWeb)properties.Feature.Parent;
    
        ListCreator listCreator = new ListCreator();
        listCreator.CreateJobsList(spWeb);
        listCreator.CreateNotificationResultsList(spWeb);
    
        // Then activate the Push Notification Feature on the server.
        // The Push Notification Feature is not activated by default in a SharePoint Server installation.
        spWeb.Features.Add(new Guid(PushNotificationFeatureId), false);
    }
    
  6. Ersetzen Sie die FeatureDeactivating -Methode in der Datei durch den folgenden Code.

    public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
    {
        base.FeatureDeactivating(properties);
        SPWeb spWeb = (SPWeb)properties.Feature.Parent;
    
        // Deactivate the Push Notification Feature on the server
        // when the PushNotificationsList Feature is deactivated.
        spWeb.Features.Remove(new Guid(PushNotificationFeatureId), false);
    }
    
  7. Speichern Sie die Datei.

In der Implementierung der FeatureActivated -Ereignishandler eine Instanz der ListCreator -Klasse instanziiert und seine Methoden CreateJobsList und CreateNotificationResultsList aufgerufen, mit der SPWeb , in dem das Feature bereitgestellt und aktiviert wird, als Speicherort, in dem die Listen erstellt werden. Darüber hinaus, da Push Notification-Funktionalität in einer Standardinstallation von SharePoint Serverin der Standardeinstellung nicht aktiviert ist, aktiviert die Funktion für die Push-Benachrichtigung auf dem Server. Im FeatureDeactivating -Ereignishandler wird Push Notification-Funktionalität deaktiviert, wenn die Anwendung deaktiviert wurde. Es ist nicht notwendig, dieses Ereignis behandelt wird. Sie können oder sollten nicht auf dem Server Push-Benachrichtigungen deaktivieren, wenn die Anwendung deaktiviert wird, je nach den Umständen Ihrer Installation und gibt an, ob andere Anwendungen auf dem Zielcomputer stellen Website von Push-Benachrichtigungen verwenden.

In diesem Abschnitt erstellen Sie eine Windows Phone app aus der Vorlage Windows Phone SharePoint Liste Anwendung die SharePoint-Liste, die im vorherigen Abschnitt erstellt, als der Zielliste für die Anwendung angeben. Sie entwickeln eine Notifications Klasse für push-Benachrichtigungen abonnieren, implementieren Handler für Benachrichtigungsereignisse und Speichern von Informationen im Zusammenhang mit Benachrichtigungen auf dem Telefon. Sie hinzufügen können Ihre Anwendung mit Steuerelementen, Benutzern das Registrieren oder Aufheben der Registrierung für Push-Benachrichtigungen eine XAML-Seite.

Um die Verfahren in diesem Abschnitt ausführen, führen Sie zuerst die Schritte in dem Verfahren Vorgehensweise: Erstellen eine Windows Phone SharePoint 2013 Liste app erstellen Sie ein Visual Studio Projekt aus der Anwendung für Windows Phone SharePoint Liste Vorlage, mit der Liste der Projekte im vorangehenden Abschnitt als eine SharePoint-Liste für das Projekt erstellt. Für die Zwecke der Verfahren in diesem Abschnitt wird davon ausgegangen, dass der angegebene Name für das Projekt SPListAppForNotificationsist.

So erstellen Sie die Klasse zum Verwalten von Abonnements und empfangenen Benachrichtigungen

  1. Wählen Sie im Projektmappen-Explorerden Knoten, der das Projekt (mit der Bezeichnung SPListAppForNotifications).

  2. Klicken Sie im Menü Projekt auf Klasse hinzufügen. Mit der C#- Klasse Vorlage bereits aktiviert, wird das Dialogfeld Neues Element hinzufügen angezeigt.

  3. Geben Sie als Namen für die Datei "Notifications.cs", und klicken Sie auf Hinzufügen. Die Klassendatei ist der Projektmappe hinzugefügt und zur Bearbeitung geöffnet.

  4. Ersetzen Sie den Inhalt der Datei durch den folgenden Code:

    using System;
    using System.Linq;
    using System.Net;
    using System.Windows;
    using Microsoft.Phone.Notification;
    using Microsoft.SharePoint.Client;
    using System.Diagnostics;
    using System.Collections.Generic;
    using Microsoft.Phone.Shell;
    using System.IO;
    using System.IO.IsolatedStorage;
    
    namespace SPListAppForNotifications
    {
        public class Notifications
        {
            static HttpNotificationChannel httpChannel;
            private const string RegStatusKey = "RegistrationStatus";
            public static string DeviceAppIdKey = "DeviceAppInstanceId";
            public static string ChannelName = "JobsListNotificationChannel";
            public static ClientContext Context { get; set; }
    
            public static void OpenNotificationChannel(bool isInitialRegistration)
            {
                try
                {
                    // Get channel if it was created in a previous session of the app.
                    httpChannel = HttpNotificationChannel.Find(ChannelName);
    
                    // If channel is not found, create one.
                    if (httpChannel == null)
                    {
                        httpChannel = new HttpNotificationChannel(ChannelName);
    
                        // Add event handlers. When the Open method is called, the ChannelUriUpdated event will fire.
                        // A call is made to the SubscribeToService method in the ChannelUriUpdated event handler.                    
                        AddChannelEventHandlers();
                        httpChannel.Open();
                    }
                    else
                    {
                        // The channel exists and is already open. Add handlers for channel events.
                        // The ChannelUriUpdated event won't fire in this case.
                        AddChannelEventHandlers();
    
                        // If app instance is registering for first time
                        // (instead of just starting up again), then call SubscribeToService.
                        if (isInitialRegistration)
                        {
                            SubscribeToService();
                        }
                    }
                }
                catch (Exception ex)
                {                
                    ShowMessage(ex.Message, "Error Opening Channel");
                    CloseChannel();
                }
            }
    
            private static void AddChannelEventHandlers()
            {
                httpChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(httpChannel_ChannelUriUpdated);
                httpChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(httpChannel_ExceptionOccurred);
                httpChannel.ShellToastNotificationReceived += new EventHandler<NotificationEventArgs>(httpChannel_ShellToastNotificationReceived);
                httpChannel.HttpNotificationReceived += new EventHandler<HttpNotificationEventArgs>(httpChannel_HttpNotificationReceived);
            }
    
            private static void httpChannel_ChannelUriUpdated(object sender, NotificationChannelUriEventArgs e)
            {
                UpdateChannelUriOnServer();
                SubscribeToService();
            }
    
            private static void httpChannel_ExceptionOccurred(object sender, NotificationChannelErrorEventArgs e)
            {
                // Simply showing the exception error.
                ShowMessage(e.Message, "Channel Event Error");
            }
    
            static void httpChannel_ShellToastNotificationReceived(object sender, NotificationEventArgs e)
            {
                if (e.Collection != null)
                {
                    Dictionary<string, string> collection = (Dictionary<string, string>)e.Collection;
                    ShellToast toast = new ShellToast();
                    toast.Title = collection["wp:Text1"];
                    toast.Content = collection["wp:Text2"];
    
                    // Note that the Show method for a toast notification won't
                    // display the notification in the UI of the phone when the app
                    // that calls the method is running (as the foreground app on the phone).
                    // toast.Show();
                   //Toast and Raw notification will be displayed if user is running the app. Be default only Toast notification
                   // will be displayed when the app is tombstoned                                               
    
                    // Showing the toast notification with the ShowMessage method.
                    ShowMessage(string.Format("Title: {0}\r\nContent: {1}", toast.Title, toast.Content), "Toast Notification");
                }
            }
    
            static void httpChannel_HttpNotificationReceived(object sender, HttpNotificationEventArgs e)
            {
                Stream messageStream = e.Notification.Body;
                string message = string.Empty;
    
                // Replacing NULL characters in stream.
                using (var reader = new StreamReader(messageStream))
                {
                    message = reader.ReadToEnd().Replace('\0', ' ');
                }
    
                // Simply displaying the raw notification.
                ShowMessage(message, "Raw Notification");
            }
    
            private static void SubscribeToService()
            {
                Guid deviceAppInstanceId = GetSettingValue<Guid>(DeviceAppIdKey, false);
    
                Context.Load(Context.Web, w => w.Title, w => w.Description);
    
                PushNotificationSubscriber pushSubscriber = Context.Web.RegisterPushNotificationSubscriber(deviceAppInstanceId, httpChannel.ChannelUri.AbsoluteUri);
    
                Context.Load(pushSubscriber);
    
                Context.ExecuteQueryAsync
                    (
                        (object sender, ClientRequestSucceededEventArgs args) =>
                            {
                                SetRegistrationStatus(true);
    
                                // Indicate that tile and toast notifications can be
                                // received by phone shell when phone app is not running.
                                if (!httpChannel.IsShellTileBound)
                                    httpChannel.BindToShellTile();
    
                                if (!httpChannel.IsShellToastBound)
                                    httpChannel.BindToShellToast();
    
                                ShowMessage(
                                    string.Format("Subscriber successfully registered: {0}", pushSubscriber.User.LoginName),
                                    "Success");
                            },
                        (object sender, ClientRequestFailedEventArgs args) =>
                            {
                                ShowMessage(args.Exception.Message, "Error Subscribing");
                            });
            }
    
            private static void UpdateChannelUriOnServer()
            {
                Guid deviceAppInstanceId = GetSettingValue<Guid>(DeviceAppIdKey, false);
    
                Context.Load(Context.Web, w => w.Title, w => w.Description);            
    
                PushNotificationSubscriber subscriber = Context.Web.GetPushNotificationSubscriber(deviceAppInstanceId);
    
                Context.Load(subscriber);
    
                Context.ExecuteQueryAsync(
                        (object sender1, ClientRequestSucceededEventArgs args1) =>
                        {
                            subscriber.ServiceToken = httpChannel.ChannelUri.AbsolutePath;
                            subscriber.Update();
                            Context.ExecuteQueryAsync(
                                (object sender2, ClientRequestSucceededEventArgs args2) =>
                                    {
                                        ShowMessage("Channel URI updated on server.", "Success");
                                    },
                                (object sender2, ClientRequestFailedEventArgs args2) =>
                                    {
                                        ShowMessage(args2.Exception.Message, "Error Upating Channel URI");
                                    });
                        },
                       (object sender1, ClientRequestFailedEventArgs args1) =>
                       {
                           // This condition can be ignored. Getting to this point means the subscriber
                           // doesn't yet exist on the server, so updating the Channel URI is unnecessary.
                           //ShowMessage("Subscriber doesn't exist on server.", "DEBUG");
                       });
            }
    
            public static void UnSubscribe()
            {
                Context.Load(Context.Web, w => w.Title, w => w.Description);
                Guid deviceAppInstanceId = GetSettingValue<Guid>(DeviceAppIdKey, false);
    
                Context.Web.UnregisterPushNotificationSubscriber(deviceAppInstanceId);
    
                Context.ExecuteQueryAsync
                    (
                        (object sender, ClientRequestSucceededEventArgs args) =>
                        {
                            CloseChannel();
                            SetRegistrationStatus(false);
                            //SetInitializationStatus(false);
                            ShowMessage("Subscriber successfully unregistered.", "Success");
                        },
                        (object sender, ClientRequestFailedEventArgs args) =>
                        {
                            ShowMessage(args.Exception.Message, "Error Unsubscribing");
                        });
            }
    
            public static void ClearSubscriptionStore()
            {
                Context.Load(Context.Web, w => w.Title, w => w.Description);
                List subscriptionStore = Context.Web.Lists.GetByTitle("Push Notification Subscription Store");
                Context.Load(subscriptionStore);
                ListItemCollection listItems = subscriptionStore.GetItems(new CamlQuery());
                Context.Load(listItems);
    
                Context.ExecuteQueryAsync
                    (
                        (object sender1, ClientRequestSucceededEventArgs args1) =>
                        {
                            foreach (ListItem listItem in listItems.ToList())
                            {
                                listItem.DeleteObject();                            
                            }                        
                            Context.ExecuteQueryAsync(
                                    (object sender2, ClientRequestSucceededEventArgs args2) =>
                                    {
                                        // Close channel if open and set registration status for current app instance.
                                        CloseChannel();
                                        SetRegistrationStatus(false);
    
                                        ShowMessage("Subscriber store cleared.", "Success");
                                    },
                                    (object sender2, ClientRequestFailedEventArgs args2) =>
                                    {
                                        ShowMessage(args2.Exception.Message, "Error Deleting Subscribers");
                                    });
                        },
                        (object sender1, ClientRequestFailedEventArgs args1) =>
                        {
                            ShowMessage(args1.Exception.Message, "Error Loading Subscribers List");
                        });
            }
    
            private static void CloseChannel()
            {
                if (httpChannel == null) return;
                try
                {
                    httpChannel.UnbindToShellTile();
                    httpChannel.UnbindToShellToast();
                    httpChannel.Close();
                }
                catch (Exception ex)
                {
                    ShowMessage(ex.Message, "Error Closing Channel");
                }
            }
    
            public static void SaveDeviceAppIdToStorage()
            {
                if (!IsolatedStorageSettings.ApplicationSettings.Contains(DeviceAppIdKey))
                {
                    Guid DeviceAppId = Guid.NewGuid();
                    SetSettingValue<Guid>(DeviceAppIdKey, DeviceAppId, false);
                }
            }
    
            public static bool GetRegistrationStatus()
            {
                bool status = GetSettingValue<bool>(RegStatusKey, false);
                return status;
            }
    
            private static void SetRegistrationStatus(bool isRegistered)
            {
                SetSettingValue<bool>(RegStatusKey, isRegistered, false);
            }
    
            private static T GetSettingValue<T>(string key, bool fromTransientStorage)
            {
                if (fromTransientStorage == false)
                {
                    if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
                        return (T)IsolatedStorageSettings.ApplicationSettings[key];
                    return default(T);
                }
    
                if (PhoneApplicationService.Current.State.ContainsKey(key))
                    return (T)PhoneApplicationService.Current.State[key];
                return default(T);
            }
    
            private static void SetSettingValue<T>(string key, T value, bool toTransientStorage)
            {
                if (toTransientStorage == false)
                {
                    if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
                        IsolatedStorageSettings.ApplicationSettings[key] = value;
                    else
                        IsolatedStorageSettings.ApplicationSettings.Add(key, value);
    
                    IsolatedStorageSettings.ApplicationSettings.Save();
                }
                else
                {
                    if (PhoneApplicationService.Current.State.ContainsKey(key))
                        PhoneApplicationService.Current.State[key] = value;
                    else
                        PhoneApplicationService.Current.State.Add(key, value);
                }
            }
    
            // Method for showing messages on UI thread coming from a different originating thread.
            private static void ShowMessage(string message, string caption)
            {
                Deployment.Current.Dispatcher.BeginInvoke(() =>
                {
                    MessageBox.Show(message, caption, MessageBoxButton.OK);
                });
            }
        }
    }
    
  5. Speichern Sie die Datei.

In diesem Code wird die OpenNotificationChannel Benachrichtigung bereitgestellt für den Empfang von Benachrichtigungen von MPNS erstellt. Ereignishandler für das Channelobjekt für den Umgang mit Benachrichtigungsereignisse angefügt werden und dann der Kanal geöffnet wird. In diesem Beispiel wird das Ereignis HttpNotificationReceived (für den Empfang von Benachrichtigungen raw) implementiert. RAW-Benachrichtigungen können empfangen werden, nur, wenn die Telefon app ausgeführt wird. Der Handler für das Ereignis ShellToastNotificationReceived (für den Empfang von Benachrichtigungen Toast) wird auch hier implementiert, um ihre Verwendung. Kachel-Benachrichtigungen können empfangen werden, nur wenn abonnierenden Telefon app nicht ausgeführt wird, so keine Notwendigkeit besteht, implementieren Sie einen Ereignishandler in der Webanwendung für den Empfang von Benachrichtigungen Kachel.

Die SubscribeToService -Methode führt die RegisterPushNotificationSubscriber -Methode des SPWeb -Objekts asynchron (übergeben Sie einen Wert zum Identifizieren der Phone-app und einen URI-Wert der Benachrichtigungskanal zugeordnete) mit den SharePoint Server für Push-Benachrichtigungen registrieren. Wenn die Registrierung erfolgreich ist, wird die Windows Phone-Shell zu erhalten (und anzeigen) festgelegt ist toast und nebeneinander Benachrichtigungen auf die Benachrichtigungskanal mit der SharePoint Server erfasst werden, wenn die Telefon app selbst nicht ausgeführt wird.

Die UnSubscribe -Methode in diesem Code Ruft die UnregisterPushNotificationSubscriber -Methode der SPWeb-Objekt. Die Richtlinien für die Entwicklung für Windows Phone apps wird empfohlen, Benutzer wählen, ob Sie push-Benachrichtigungen oder nicht abonnieren. In einem späteren Verfahren fügen Sie einen Mechanismus für den Benutzer zu registrieren oder Aufheben der Registrierung für Benachrichtigungen und zwischen Sitzungen in der Anwendung, so dass es nicht erforderlich, Fragen Sie bei jedem Start die Anwendung registriert wird dieses Staates Registrierung beibehalten. Die GetRegistrationStatus -Methode wird zur Verfügung gestellt, damit die Telefon app bestimmen kann, ob der Benutzer (in einer vorangegangenen Sitzung) registriert hat, um Push-Benachrichtigungen zu erhalten und Benachrichtigung bereitgestellt wird anschließend geöffnet. Das SaveDeviceAppIdToStorage speichert den Bezeichner (dargestellt als GUID) für app-Instanz auf einem bestimmten Windows Phone in den isolierten Speicher.

Die ClearSubscriptionStore -Methode wurde aufgenommen, hier als Beispiel eine Möglichkeit, die Abonnenten aus dem Abonnementspeicher für die SharePoint Serverdeaktivieren. Abonnenten von Push-Benachrichtigungen werden in einer SharePoint-Liste mit dem Namen "Push Notification Subscription Store" gespeichert. Auf der Seite Benachrichtigungen Einstellungen der Anwendung in einer späteren Prozedur hinzugefügt wird eine Schaltfläche zum Aufrufen dieser Methode der Notifications -Klasse hinzugefügt.

Beachten Sie, dass Vorgänge, bei denen Zugriff auf die SharePoint Server zum Konfigurieren von Einstellungen oder Vorbereitung der Benachrichtigungen (z. B. die RegisterPushNotificationSubscriber -Methode), abhängig von den Netzwerkbedingungen und den Zugriff auf den Server dauern können. Diese Vorgänge sind daher asynchron ausgeführt (genauer gesagt von der ExecuteQueryAsync -Methode eines Objekts ClientContext ) ermöglichen die Anwendung weiterhin andere Prozesse und die Benutzeroberfläche für den Benutzer weiterhin reaktionsfähig bleibt.

Als Nächstes fügen Sie eine Seite der Anwendung mit Steuerelementen, mit denen einen Benutzer registrieren oder Aufheben der Registrierung von Push-Benachrichtigungen vom Server.

Die Anwendung einer Benachrichtigungsseite Einstellungen hinzu

  1. Wählen Sie im Projektmappen-Explorerden Knoten, der das Projekt (mit dem Namen SPListAppForNotifications , wenn Sie die Benennungskonvention in diesen Prozeduren folgen).

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen. Das Dialogfeld Neues Element hinzufügen wird angezeigt.

  3. Wählen Sie im Bereich VorlagenWindows Phone Hochformat Seitenvorlage. Geben Sie Settings.xaml als den Namen der Datei für die Seite, und klicken Sie auf Hinzufügen. Die Seite wird dem Projekt hinzugefügt und zur Bearbeitung geöffnet.

  4. Ersetzen Sie in der XAML-Ansicht für die Seite Inhalt zwischen der schließenden Klammer des XML-Tags, die das PhoneApplicationPage -Element definiert und das Endtag des Elements (</phone:PhoneApplicationPage>), durch das folgende Markup.

    <Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
    
        <!--TitlePanel contains the name of the application and page title-->
        <StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">
            <TextBlock x:Name="ApplicationTitle" Text="JOBS LIST" Style="{StaticResource PhoneTextNormalStyle}"/>
            <TextBlock x:Name="PageTitle" Text="Settings" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/>
        </StackPanel>
    
        <!--ContentPanel - place additional content here-->
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <StackPanel Margin="0,5,0,5">
                <StackPanel Orientation="Vertical" Margin="0,5,0,5">
                    <TextBlock TextWrapping="Wrap" HorizontalAlignment="Center" Style="{StaticResource PhoneTextTitle2Style}">Notification Registration</TextBlock>
                    <StackPanel Orientation="Vertical" Margin="0,5,0,5">
                        <TextBlock x:Name="txtRegistrationStatus" TextWrapping="Wrap" HorizontalAlignment="Center" Text="Registered: No" Style="{StaticResource PhoneTextAccentStyle}" Foreground="{StaticResource PhoneAccentBrush}" />
                        <Button x:Name="btnRegister" Content="Register" Height="71" Width="260" Click="OnRegisterButtonClick" />
                        <Button x:Name="btnUnregister" Content="Unregister" Height="71" Width="260" Click="OnUnregisterButtonClick" />
                    </StackPanel>
                </StackPanel>
                <StackPanel Orientation="Vertical" Margin="0,5,0,5">
                    <TextBlock TextWrapping="Wrap" HorizontalAlignment="Center" Style="{StaticResource PhoneTextTitle2Style}">Subscriber Management</TextBlock>
                    <Button x:Name="btnDeleteSubscribers" Content="Delete Subscribers" Height="71" Width="260" Click="OnDeleteSubscribersButtonClick" />
                </StackPanel>
            </StackPanel>
        </Grid>
    </Grid>
     
    <!--Sample code showing usage of ApplicationBar-->
    <phone:PhoneApplicationPage.ApplicationBar>
        <shell:ApplicationBar IsVisible="True" IsMenuEnabled="False">
            <shell:ApplicationBarIconButton x:Name="btnOK" IconUri="/Images/appbar.check.rest.png" Text="OK" Click="OnOKButtonClick" />
        </shell:ApplicationBar>
    </phone:PhoneApplicationPage.ApplicationBar>
    
  5. Drücken Sie mit der Settings.xaml-Datei im Projektmappen-ExplorerausgewähltF7um ihre zugeordnete Code-Behind-Datei Settings.xaml.cs, für die Bearbeitung zu öffnen.

  6. Ersetzen Sie den Inhalt der CodeBehind-Datei durch den folgenden Code.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Windows;
    using Microsoft.Phone.Controls;
    using Microsoft.SharePoint.Client;
    
    namespace SPListAppForNotifications
    {
        public partial class Settings : PhoneApplicationPage
        {
            private const string RegisteredYesText = "Registered: Yes";
            private const string RegisteredNoText = "Registered: No";
    
            public Settings()
            {
                InitializeComponent();
            }
    
            protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
            {
                this.txtRegistrationStatus.Text = (Notifications.GetRegistrationStatus()) ? RegisteredYesText : RegisteredNoText;
            }
    
            private void OnOKButtonClick(object sender, EventArgs e)
            {
                NavigationService.Navigate(new Uri("/Views/List.xaml", UriKind.Relative));
            }
    
            private void OnRegisterButtonClick(object sender, RoutedEventArgs e)
            {
                Notifications.OpenNotificationChannel(true);
                // Navigating back to List form. User will be notified when process is complete.
                NavigationService.Navigate(new Uri("/Views/List.xaml", UriKind.Relative));
            }
    
            private void OnUnregisterButtonClick(object sender, RoutedEventArgs e)
            {
                Notifications.UnSubscribe();
                // Navigating back to List form. User will be notified when process is complete.
                NavigationService.Navigate(new Uri("/Views/List.xaml", UriKind.Relative));
            }
    
            private void OnDeleteSubscribersButtonClick(object sender, RoutedEventArgs e)
            {            
                Notifications.ClearSubscriptionStore();
                // Navigating back to List form. User will be notified when process is complete.
                NavigationService.Navigate(new Uri("/Views/List.xaml", UriKind.Relative));
            }
        }
    }
    
  7. Speichern Sie die Datei.

  8. Fügen Sie dem Projekt die Image-Datei (appbar.check.rest.png) für die ApplicationBar -Schaltfläche (BtnOK) in der Datei Settings.xaml deklariert den Ordnerknoten Bilder im Projektmappen-Explorerauswählen.

  9. Klicken Sie im Menü Projekt auf Vorhandenes Element hinzufügen. Ein Datei-Browser -Fenster wird geöffnet.

  10. Navigieren Sie zu dem Ordner, in dem die standard Windows Phone-Symbole durch Windows Phone SDK 7.1-Version installiert wurden.

    Hinweis Hinweis

    Die Bilder mit einem hellen Vordergrund und einen dunklen Hintergrund sind in % ProgramFiles% %(x86) \Microsoft SDKs\Windows Phone\v7.1\Icons\dark in einer Standardinstallation des SDK.

  11. Wählen Sie die Bilddatei mit dem Namen appbar.check.rest.png, und klicken Sie auf Hinzufügen. Das Bild wird hinzugefügt, wird das Projekt unter dem Knoten Bilder hinzugefügt.

  12. Wählen Sie im Projektmappen-Explorerdie Datei nur hinzugefügt und legen Sie im Eigenschaftenfenster für die Datei, die Build Action -Eigenschaft für die Image-Datei auf "Content" und legen Sie die Eigenschaft In Ausgabeverzeichnis kopieren auf "Kopieren, wenn neuer".

Als Nächstes fügen Sie eine Schaltfläche auf das Formular (List.xaml) im Projekt und implementieren Sie den Click -Ereignishandler der Schaltfläche zu der in den vorhergehenden Schritten erstellte Seite navigieren. Ändern Sie auch den OnViewModelInitialization -Ereignishandler um einen Benachrichtigungskanal öffnen (wenn der Benutzer gewählt hat, Push-Benachrichtigungen abonnieren).

So ändern Sie das Formular

  1. Doppelklicken Sie im Projektmappen-Explorerunter dem Knoten Ansichten auf die Datei List.xaml. Die Datei wird zur Bearbeitung geöffnet.

  2. Fügen Sie Markup, um eine zusätzliche Schaltfläche im ApplicationBar -Element der Datei, wie im folgenden Beispiel deklarieren.

    ...
        <phone:PhoneApplicationPage.ApplicationBar>
            <shell:ApplicationBar IsVisible="True" IsMenuEnabled="True">
                <shell:ApplicationBarIconButton x:Name="btnNew" 
                       IconUri="/Images/appbar.new.rest.png" Text="New" 
                        Click="OnNewButtonClick" />
                <shell:ApplicationBarIconButton x:Name="btnRefresh" 
                        IconUri="/Images/appbar.refresh.rest.png" Text="Refresh" IsEnabled="True" 
                        Click="OnRefreshButtonClick" />
                <shell:ApplicationBarIconButton x:Name="btnSettings" IconUri="/Images/appbar.feature.settings.rest.png" Text="Settings" IsEnabled="True" Click="OnSettingsButtonClick" />
            </shell:ApplicationBar>
        </phone:PhoneApplicationPage.ApplicationBar>
    ...
    
  3. Drücken Sie mit der List.xaml-Datei im Projektmappen-ExplorerausgewähltF7um ihre zugeordnete Code-Behind-Datei List.xaml.cs, für die Bearbeitung zu öffnen.

  4. Innerhalb der Codeblock (abgegrenzt durch öffnende und schließende Klammern), der die partielle Klasse ListForm implementiert, fügen Sie den folgenden Ereignishandler in der Datei.

    private void OnSettingsButtonClick(object sender, EventArgs e)
    {
        NavigationService.Navigate(new Uri("/Settings.xaml", UriKind.Relative));
    }
    
  5. Suchen Sie die OnViewModelInitialization in der Datei List.xaml.cs, und fügen Sie einen Aufruf der OpenNotificationChannel -Methode der zuvor erstellten Notifications -Klasse. Die geänderte Implementierung des Handlers in etwa den folgenden Code:

    private void OnViewModelInitialization(object sender, InitializationCompletedEventArgs e)
    {
        this.Dispatcher.BeginInvoke(() =>
        {
            //If initialization has failed, show error message and return
            if (e.Error != null)
            {
                MessageBox.Show(e.Error.Message, e.Error.GetType().Name, MessageBoxButton.OK);
                return;
            }
    
            App.MainViewModel.LoadData(((PivotItem)Views.SelectedItem).Name);
            this.DataContext = (sender as ListViewModel);
        });
    
        // Open notification channel here if user has chosen to subscribe to notifications.
        if (Notifications.GetRegistrationStatus() == true)
            Notifications.OpenNotificationChannel(false);
    }
    
  6. Speichern Sie die Datei.

  7. Fügen Sie dem Projekt die Image-Datei (appbar.feature.settings.rest.png) für die Schaltfläche " ApplicationBar " (BtnSettings) in der Datei List.xaml deklariert den Ordnerknoten Bilder im Projektmappen-Explorerauswählen.

  8. Klicken Sie im Menü Projekt auf Vorhandenes Element hinzufügen. Ein Datei-Browser -Fenster wird geöffnet.

  9. Navigieren Sie zu dem Ordner, in dem die standard Windows Phone-Symbole durch Windows Phone SDK 7.1-Version installiert wurden. (Siehe den Hinweis in der vorherigen Prozedur für den Speicherort der Bilddateien in einer Standardinstallation des SDK.)

  10. Wählen Sie die Bilddatei mit dem Namen appbar.feature.settings.rest.png, und klicken Sie auf Hinzufügen. Das Bild wird hinzugefügt, wird das Projekt unter dem Knoten Bilder hinzugefügt.

  11. Wählen Sie im Projektmappen-Explorerdie Datei nur hinzugefügt und legen Sie im Eigenschaftenfenster für die Datei, die Build Action -Eigenschaft für die Image-Datei auf "Content" und legen Sie die Eigenschaft In Ausgabeverzeichnis kopieren auf "Kopieren, wenn neuer".

Fügen Sie abschließend Code auf der Application_Launching -Ereignishandler in der Datei App.xaml.cs app für den Empfang von Push-Benachrichtigungen mithilfe der Eigenschaften und Methoden der Klasse Notifications zuvor erstellten vorbereiten.

Die Datei "App.Xaml.cs" Code hinzu

  1. Wählen Sie im Projektmappen-Explorerunter dem Knoten, der das Projekt die Datei App.xaml.

  2. Taste(n)F7um ihre zugeordnete Code-Behind-Datei App.xaml.cs, zur Bearbeitung zu öffnen.

  3. Suchen Sie den Application_Launching -Ereignishandler in der Datei. (Für neue Projekte, die aus der Anwendung für Windows Phone SharePoint Liste Vorlage erstellt werden, ist die Signatur für die Methode, die für die Ereignisbehandlung Application_Launching enthalten, jedoch keine Logik in die Methode implementiert ist.)

  4. Ersetzen Sie den Application_Launching -Ereignishandler durch folgenden Code.

    private void Application_Launching(object sender, LaunchingEventArgs e)
    {
        // Get set up for notifications.
        Notifications.Context = App.DataProvider.Context;
        Notifications.SaveDeviceAppIdToStorage();
    }
    
  5. Speichern Sie die Datei.

Wenn Sie das Projekt kompilieren und die Anwendung auf dem Windows Phone-Emulator bereitstellen ausführen, können Sie durch Klicken auf die Schaltfläche " Einstellungen " in der Anwendungsleiste auf eine Seite anzuzeigen, aus der Sie für Push-Benachrichtigungen (Abbildung 1) registrieren können.

Abbildung 1. Einstellungsseite für Registrierung

Einstellungen-Seite für Benachrichtigungsregistrierung

Wenn Sie bereitgestellt und die PushNotificationsList -Lösung (Abschnitt weiter oben in diesem Thema Erstellen einer serverseitigen Lösung zum basierend auf einer Liste Elementereignis Push-Benachrichtigungen senden entwickelt) für Ihr Ziel- SharePoint Serveraktiviert haben und vom Telefon für Benachrichtigungen Registrierung erfolgreich ist, können Sie der Liste Projekte auf dem Server ein Element hinzugefügt, und Sie erhalten beide eine Toastbenachrichtigung (Abbildung 2) und, wenn die app auf dem Telefon ausgeführt wird, wenn das Element der Liste einen unformatierten Benachrichtigungsdaten (Abbildung 3) hinzugefügt wird.

Abbildung 2. Toastbenachrichtigung (app ausgeführt)

Toast-Benachrichtigung (App wird ausgeführt)

Die Meldung angezeigt, wenn Ihre Anwendung eine Benachrichtigung Spruch empfangen, während er ausgeführt wird, hängt davon ab, wie Sie den ShellToastNotificationReceived -Ereignishandler in Ihrer Anwendung implementiert haben. In der Notifications -Klasse in diesem Beispiel werden die Titel und den Inhalt der Nachricht einfach an den Benutzer angezeigt.

Abbildung 3. Unformatierten Benachrichtigungsdaten

Unformatierte Benachrichtigung

Wenn die Anwendung nicht ausgeführt wird, wenn das Element zur Liste hinzugefügt wird, sollte das Telefon noch eine Benachrichtigung Spruch (Abbildung 4) angezeigt werden.

Abbildung 4. Toastbenachrichtigung (Anwendung nicht ausgeführt)

Toast-Benachrichtigung (App wird nicht ausgeführt)

Beim Hinzufügen eines Elements zur Jobs SharePoint-Liste, der Code bei Empfänger, die die Liste versucht, zum Senden von Benachrichtigungen über MPNS auf Telefonen abonniert, aber je nach Netzwerkbedingungen und anderen Faktoren kann eine bestimmte Benachrichtigung nicht von einem Telefon empfangen werden. Die Ergebnisliste für Push-Benachrichtigung ansehen auf dem Server, insbesondere die Werte in den Spalten Statuscode und Header bestimmen den Status und die Ergebnisse in Bezug auf einzelne Benachrichtigungen.

Anzeigen:
© 2014 Microsoft