Uso di Hub di notifica per inviare le ultime notizieUse Notification Hubs to send breaking news

PanoramicaOverview

In questo argomento viene illustrato come utilizzare Hub di notifica di Azure per trasmettere le notifiche relative alle ultime notizie a un'app per iOS.This topic shows you how to use Azure Notification Hubs to broadcast breaking news notifications to an iOS app. Al termine dell'esercitazione, si sarà appreso a effettuare la registrazione alle categorie di ultime notizie desiderate e ricevere le notifiche push solo da tali categorie.When complete, you will be able to register for breaking news categories you are interested in, and receive only push notifications for those categories. Questo scenario è un modello comune per molte app nelle quali le notifiche devono essere inviate a gruppi di utenti che hanno dichiarato un interesse, ad esempio lettori di feed RSS, app per fan di musica e così via.This scenario is a common pattern for many apps where notifications have to be sent to groups of users that have previously declared interest in them, e.g. RSS reader, apps for music fans, etc.

È possibile abilitare gli scenari di trasmissione includendo uno o più tag durante la creazione di una registrazione nell'hub di notifica.Broadcast scenarios are enabled by including one or more tags when creating a registration in the notification hub. Quando le notifiche vengono inviate a un tag, tutti i dispositivi che hanno effettuato la registrazione al tag riceveranno la notifica.When notifications are sent to a tag, all devices that have registered for the tag will receive the notification. Poiché i tag sono costituiti da stringhe, non è necessario eseguire il provisioning anticipatamente.Because tags are simply strings, they do not have to be provisioned in advance. Per ulteriori informazioni sui tag, vedere Espressioni di routing e tag per hub di notifica.For more information about tags, refer to Notification Hubs Routing and Tag Expressions.

prerequisitiPrerequisites

Questo argomento si basa sull'app creata nell'esercitazione Introduzione ad Hub di notifica.This topic builds on the app you created in Get started with Notification Hubs. Prima di iniziare questa esercitazione, è necessario completare le procedure illustrate in Introduzione ad Hub di notifica.Before starting this tutorial, you must have already completed Get started with Notification Hubs.

Aggiungere la selezione delle categorie all'appAdd category selection to the app

Il primo passaggio prevede l'aggiunta degli elementi dell'interfaccia utente allo storyboard esistente per consentire all'utente di selezionare le categorie per le quali registrarsi.The first step is to add the UI elements to your existing storyboard that enable the user to select categories to register. Le categorie selezionate da un utente sono archiviate nel dispositivo.The categories selected by a user are stored on the device. All'avvio dell'app, viene creata una registrazione nell'hub di notifica con le categorie selezionate come tag.When the app starts, a device registration is created in your notification hub with the selected categories as tags.

  1. Nel file MainStoryboard_iPhone.storyboard aggiungere i componenti seguenti dalla libreria di oggetti:In your MainStoryboard_iPhone.storyboard add the following components from the object library:

    • Un'etichetta con il testo "Breaking News".A label with "Breaking News" text,
    • Etichette con il testo relativo alle categorie "World", "Politics", "Business", "Technology", "Science", "Sports".Labels with category texts "World", "Politics", "Business", "Technology", "Science", "Sports",
    • Sei opzioni, una per ogni categoria, impostare lo stato di ogni opzione su Off per impostazione predefinita.Six switches, one per category, set each switch State to be Off by default.
    • Un pulsante con l'etichetta "Subscribe".One button labeled "Subscribe"

      L'aspetto dello storyboard dovrebbe essere simile al seguente:Your storyboard should look as follows:

  2. Nell'assistente dell'editor creare outlet per tutte le opzioni e denominarli "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch".In the assistant editor, create outlets for all the switches and call them "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch"
  3. Creare un'azione per il pulsante denominata "subscribe".Create an Action for your button called "subscribe". BreakingNewsViewController.h deve contenere quanto segue:Your ViewController.h should contain the following:

     @property (weak, nonatomic) IBOutlet UISwitch *WorldSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *PoliticsSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *BusinessSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *TechnologySwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *ScienceSwitch;
     @property (weak, nonatomic) IBOutlet UISwitch *SportsSwitch;
    
     - (IBAction)subscribe:(id)sender;
    
  4. Creare una nuova classe Cocoa Touch chiamata Notifications.Create a new Cocoa Touch Class called Notifications. Copiare il seguente codice nella sezione dell'interfaccia del file Notifications.h:Copy the following code in the interface section of the file Notifications.h:

     @property NSData* deviceToken;
    
     - (id)initWithConnectionString:(NSString*)listenConnectionString HubName:(NSString*)hubName;
    
     - (void)storeCategoriesAndSubscribeWithCategories:(NSArray*)categories
                 completion:(void (^)(NSError* error))completion;
    
     - (NSSet*)retrieveCategories;
    
     - (void)subscribeWithCategories:(NSSet*)categories completion:(void (^)(NSError *))completion;
    
  5. Aggiungere la seguente direttiva import a Notifications.m:Add the following import directive to Notifications.m:

     #import <WindowsAzureMessaging/WindowsAzureMessaging.h>
    
  6. Copiare il codice seguente nella sezione di implementazione del file Notifications.m:Copy the following code in the implementation section of the file Notifications.m.

     SBNotificationHub* hub;
    
     - (id)initWithConnectionString:(NSString*)listenConnectionString HubName:(NSString*)hubName{
    
         hub = [[SBNotificationHub alloc] initWithConnectionString:listenConnectionString
                                     notificationHubPath:hubName];
    
         return self;
     }
    
     - (void)storeCategoriesAndSubscribeWithCategories:(NSSet *)categories completion:(void (^)(NSError *))completion {
         NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
         [defaults setValue:[categories allObjects] forKey:@"BreakingNewsCategories"];
    
         [self subscribeWithCategories:categories completion:completion];
     }
    
     - (NSSet*)retrieveCategories {
         NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
    
         NSArray* categories = [defaults stringArrayForKey:@"BreakingNewsCategories"];
    
         if (!categories) return [[NSSet alloc] init];
         return [[NSSet alloc] initWithArray:categories];
     }
    
    - (void)subscribeWithCategories:(NSSet *)categories completion:(void (^)(NSError *))completion
    {
       //[hub registerNativeWithDeviceToken:self.deviceToken tags:categories completion: completion];

        NSString* templateBodyAPNS = @"{\"aps\":{\"alert\":\"$(messageParam)\"}}";

        [hub registerTemplateWithDeviceToken:self.deviceToken name:@"simpleAPNSTemplate" 
            jsonBodyTemplate:templateBodyAPNS expiryTemplate:@"0" tags:categories completion:completion];
    }



<span data-ttu-id="36962-132">Questa classe usa l'archiviazione locale per archiviare le categorie di notizie che il dispositivo deve ricevere.</span><span class="sxs-lookup"><span data-stu-id="36962-132">This class uses local storage to store and retrieve the categories of news that this device will receive.</span></span> <span data-ttu-id="36962-133">Contiene inoltre un metodo per effettuare la registrazione per queste categorie tramite una registrazione [Modello](notification-hubs-templates-cross-platform-push-messages.md) .</span><span class="sxs-lookup"><span data-stu-id="36962-133">Also, it contains a method to register for these categories using a [Template](notification-hubs-templates-cross-platform-push-messages.md) registration.</span></span>
  1. Nel file Appdelegate.h, aggiungere un'istruzione import per Notifications.h e aggiungere una proprietà per un'istanza della classe delle notifiche:In the AppDelegate.h file, add an import statement for Notifications.h and add a property for an instance of the Notifications class:

     #import "Notifications.h"
    
     @property (nonatomic) Notifications* notifications;
    
  2. Nel metodo didFinishLaunchingWithOptions in AppDelegate.m aggiungere il codice per inizializzare l'istanza di notifiche all'inizio del metodo.In the didFinishLaunchingWithOptions method in AppDelegate.m, add the code to initialize the notifications instance at the beginning of the method.

    HUBNAME e HUBLISTENACCESS (definiti in hubinfo.h) dovrebbero già avere i segnaposto <hub name> e <connection string with listen access> sostituiti con il nome dell'hub di notifica e la stringa di connessione per DefaultListenSharedAccessSignature ottenuta in precedenza.HUBNAME and HUBLISTENACCESS (defined in hubinfo.h) should already have the <hub name> and <connection string with listen access> placeholders replaced with your notification hub name and the connection string for DefaultListenSharedAccessSignature that you obtained earlier

     self.notifications = [[Notifications alloc] initWithConnectionString:HUBLISTENACCESS HubName:HUBNAME];
    

    Nota

    Poiché le credenziali che sono distribuite con un'app client in genere non sono sicure, distribuire solo la chiave per l'accesso Listen con l'app client.Because credentials that are distributed with a client app are not generally secure, you should only distribute the key for listen access with your client app. L'accesso Listen consente all'app di registrarsi per le notifiche ma le registrazioni esistenti non possono essere modificate e le notifiche non possono essere inviate.Listen access enables your app to register for notifications, but existing registrations cannot be modified and notifications cannot be sent. La chiave di accesso completa viene usata in un servizio back-end sicuro per l'invio delle notifiche e la modifica delle registrazioni esistenti.The full access key is used in a secured backend service for sending notifications and changing existing registrations.

  3. Nel metodo didRegisterForRemoteNotificationsWithDeviceToken in AppDelegate.m sostituire il codice nel metodo con il codice seguente per passare il token del dispositivo alla classe delle notifiche.In the didRegisterForRemoteNotificationsWithDeviceToken method in AppDelegate.m, replace the code in the method with the following code to pass the device token to the notifications class. La classe delle notifiche eseguirà la registrazione per le notifiche con le categorie.The notifications class will perform the registering for notifications with the categories. Se l'utente modifica le selezioni delle categorie, chiamare il metodo subscribeWithCategories in risposta al pulsante sottoscrizione per aggiornarle.If the user changes category selections, we call the subscribeWithCategories method in response to the subscribe button to update them.

    Nota

    Poiché il token di dispositivo assegnato dal servizio di notifica Push di Apple può cambiare in qualsiasi momento, è necessario ripetere la registrazione per le notifiche di frequente per evitare errori di notifica.Because the device token assigned by the Apple Push Notification Service (APNS) can chance at any time, you should register for notifications frequently to avoid notification failures. In questo esempio viene effettuata la registrazione per le notifiche a ogni avvio dell'app.This example registers for notification every time that the app starts. Per le app che vengono eseguite con una frequenza maggiore di una volta al giorno, è possibile ignorare la registrazione per conservare la larghezza di banda qualora sia trascorso meno di un giorno dalla registrazione precedente.For apps that are run frequently, more than once a day, you can probably skip registration to preserve bandwidth if less than a day has passed since the previous registration.

     self.notifications.deviceToken = deviceToken;
    
     // Retrieves the categories from local storage and requests a registration for these categories
     // each time the app starts and performs a registration.
    
     NSSet* categories = [self.notifications retrieveCategories];
     [self.notifications subscribeWithCategories:categories completion:^(NSError* error) {
         if (error != nil) {
             NSLog(@"Error registering for notifications: %@", error);
         }
     }];
    

    Si noti che a questo punto nel metodo didRegisterForRemoteNotificationsWithDeviceToken non dovrebbe essere presente altro codice.Note that at this point there should be no other code in the didRegisterForRemoteNotificationsWithDeviceToken method.

  4. I metodi seguenti devono essere già presenti in AppDelegate.m in seguito al completamento dell'esercitazione Introduzione ad Hub di notifica.The following methods should already be present in AppDelegate.m from completing the Get started with Notification Hubs tutorial. In caso contrario, aggiungerli.If not, add them.

    -(void)MessageBox:(NSString *)title message:(NSString *)messageText {-(void)MessageBox:(NSString *)title message:(NSString *)messageText {

     UIAlertView *alert = [[UIAlertView alloc] initWithTitle:title message:messageText delegate:self
         cancelButtonTitle:@"OK" otherButtonTitles: nil];
     [alert show];
    

    }}

    • (void)application:(UIApplication *)application didReceiveRemoteNotification: (NSDictionary *)userInfo { NSLog(@"%@", userInfo); [self MessageBox:@"Notification" message:[[userInfo objectForKey:@"aps"] valueForKey:@"alert"]]; }(void)application:(UIApplication *)application didReceiveRemoteNotification: (NSDictionary *)userInfo { NSLog(@"%@", userInfo); [self MessageBox:@"Notification" message:[[userInfo objectForKey:@"aps"] valueForKey:@"alert"]]; }

    This method handles notifications received when the app is running by displaying a simple UIAlert.This method handles notifications received when the app is running by displaying a simple UIAlert.

  5. In ViewController.m, aggiungere un'istruzione import per AppDelegate.h e copiare il codice seguente nel metodo subscribe generato da XCode.In ViewController.m, add a import statement for AppDelegate.h and copy the following code into the XCode-generated subscribe method. Questo codice aggiornerà la registrazione della notifica per utilizzare i nuovi tag di categoria selezionati dall'utente nell'interfaccia utente.This code will update the notification registration to use the new category tags the user has chosen in the user interface.

    ```
    #import "Notifications.h"
    ```
    
    NSMutableArray* categories = [[NSMutableArray alloc] init];
    
    if (self.WorldSwitch.isOn) [categories addObject:@"World"];
    if (self.PoliticsSwitch.isOn) [categories addObject:@"Politics"];
    if (self.BusinessSwitch.isOn) [categories addObject:@"Business"];
    if (self.TechnologySwitch.isOn) [categories addObject:@"Technology"];
    if (self.ScienceSwitch.isOn) [categories addObject:@"Science"];
    if (self.SportsSwitch.isOn) [categories addObject:@"Sports"];
    
    Notifications* notifications = [(AppDelegate*)[[UIApplication sharedApplication]delegate] notifications];
    
    [notifications storeCategoriesAndSubscribeWithCategories:categories completion: ^(NSError* error) {
        if (!error) {
            [(AppDelegate*)[[UIApplication sharedApplication]delegate] MessageBox:@"Notification" message:@"Subscribed!"];
        } else {
            NSLog(@"Error subscribing: %@", error);
        }
    }];
    

    Questo metodo crea un elenco NSMutableArray di categorie e usa la classe Notifications per archiviare l'elenco nell'archiviazione locale e registrare i tag corrispondenti nell'hub di notifica.This method creates an NSMutableArray of categories and uses the Notifications class to store the list in the local storage and registers the corresponding tags with your notification hub. Se le categorie vengono modificate, la registrazione viene ricreata con le nuove categorie.When categories are changed, the registration is recreated with the new categories.

  6. In ViewController.m, aggiungere il codice seguente nel metodo viewDidLoad per impostare l'interfaccia utente in base alle categorie salvate in precedenza.In ViewController.m, add the following code in the viewDidLoad method to set the user interface based on the previously saved categories.

     // This updates the UI on startup based on the status of previously saved categories.
    
     Notifications* notifications = [(AppDelegate*)[[UIApplication sharedApplication]delegate] notifications];
    
     NSSet* categories = [notifications retrieveCategories];
    
     if ([categories containsObject:@"World"]) self.WorldSwitch.on = true;
     if ([categories containsObject:@"Politics"]) self.PoliticsSwitch.on = true;
     if ([categories containsObject:@"Business"]) self.BusinessSwitch.on = true;
     if ([categories containsObject:@"Technology"]) self.TechnologySwitch.on = true;
     if ([categories containsObject:@"Science"]) self.ScienceSwitch.on = true;
     if ([categories containsObject:@"Sports"]) self.SportsSwitch.on = true;
    

Ora l'app può archiviare un insieme di categorie nella risorsa di archiviazione locale del dispositivo utilizzata per la registrazione con l'hub di notifica ogni volta che l'app viene avviata.The app can now store a set of categories in the device local storage used to register with the notification hub whenever the app starts. L'utente può modificare la selezione di categorie al runtime e scegliere il metodo subscribe per aggiornare la registrazione per il dispositivo.The user can change the selection of categories at runtime and click the subscribe method to update the registration for the device. Successivamente, si aggiornerà l'app per inviare le notifiche relative alle ultime notizie direttamente nell'applicazione stessa.Next, you will update the app to send the breaking news notifications directly in the app itself.

(facoltativo) Invio di notifiche con tag(optional) Sending tagged notifications

Se non si ha accesso a Visual Studio, è possibile passare alla sezione successiva e inviare notifiche dall’app stessa.If you don't have access to Visual Studio, you can skip to the next section and send notifications from the app itself. È anche possibile inviare la notifica del modello appropriata dal portale di Azure usando la scheda debug per l'hub di notifica.You can also send the proper template notification from the [Azure portal] using the debug tab for your notification hub.

In questa sezione si invieranno notizie aggiornate come notifiche modello con tag da un'app console .NET.In this section, you send breaking news as tagged template notifications from a .NET console app.

Se si usa la funzionalità App per dispositivi mobili di Servizio app di Microsoft Azure, vedere l'esercitazione Add push notifications for Mobile Apps e selezionare la piattaforma in uso nella parte superiore della pagina.If you are using the Mobile Apps feature of Microsoft Azure App Service, refer to the Add push notifications for Mobile Apps tutorial, and select your platform at the top.

Se si vuole usare Java o PHP, vedere How to use Notification Hubs from Java or PHP.If you want to use Java or PHP, refer to How to use Notification Hubs from Java or PHP. È possibile inviare notifiche da qualsiasi back-end tramite l'interfaccia REST di Hub di notifica.You can send notifications from any back end by using the Notification Hubs REST interface.

Se è stata creata l'app console per l'invio di notifiche al termine dell'esercitazione Get started with Notification Hubs, ignorare i passaggi da 1 a 3.If you created the console app for sending notifications when you completed Get started with Notification Hubs, skip steps 1-3.

  1. In Visual Studio creare una nuova applicazione console in Visual C#:In Visual Studio, create a new Visual C# console application:

    Collegamento all'app console

  2. Dal menu principale di Visual Studio scegliere Strumenti, > Gestione pacchetti libreria > Console di Gestione pacchetti e quindi immettere la stringa seguente nella finestra della console:On the Visual Studio main menu, select Tools > Library Package Manager > Package Manager Console and then, in the console window, enter the following string:

     Install-Package Microsoft.Azure.NotificationHubs
    
  3. Selezionare Enter (Invio).Select Enter.
    Questa azione aggiunge un riferimento ad Azure Notification Hubs SDK usando il pacchetto NuGet Microsoft.Azure.NotificationHubs.This action adds a reference to the Azure Notification Hubs SDK by using the Microsoft.Azure.Notification Hubs NuGet package.

  4. Aprire il file Program.cs e aggiungere l'istruzione using seguente:Open the Program.cs file, and add the following using statement:

     using Microsoft.Azure.NotificationHubs;
    
  5. Nella classe Program aggiungere il metodo seguente oppure sostituirlo se esiste già:In the Program class, add the following method, or replace it if it already exists:

     private static async void SendTemplateNotificationAsync()
     {
         // Define the notification hub.
         NotificationHubClient hub =
             NotificationHubClient.CreateClientFromConnectionString(
                 "<connection string with full access>", "<hub name>");
    
         // Create an array of breaking news categories.
         var categories = new string[] { "World", "Politics", "Business",
                                         "Technology", "Science", "Sports"};
    
         // Send the notification as a template notification. All template registrations that contain
         // "messageParam" and the proper tags will receive the notifications.
         // This includes APNS, GCM, WNS, and MPNS template registrations.
    
         Dictionary<string, string> templateParams = new Dictionary<string, string>();
    
         foreach (var category in categories)
         {
             templateParams["messageParam"] = "Breaking " + category + " News!";
             await hub.SendTemplateNotificationAsync(templateParams, category);
         }
      }
    

    Questo codice invia una notifica modello per ognuno dei sei tag nella matrice di stringhe.This code sends a template notification for each of the six tags in the string array. L'uso di tag garantisce che i dispositivi ricevano le notifiche solo per le categorie registrate.The use of tags ensures that devices receive notifications only for the registered categories.

  6. Nel codice precedente sostituire i segnaposto <hub name> e <connection string with full access> con il nome dell'hub di notifica e la stringa di connessione per DefaultFullSharedAccessSignature dal dashboard dell'hub di notifica.In the preceding code, replace the <hub name> and <connection string with full access> placeholders with your notification hub name and the connection string for DefaultFullSharedAccessSignature from the dashboard of your notification hub.

  7. Nel metodo Main aggiungere le righe seguenti:In the Main method, add the following lines:

      SendTemplateNotificationAsync();
      Console.ReadLine();
    
  8. Creare l'app console.Build the console app.

(facoltativo) Inviare notifiche dal dispositivo(optional) Send notifications from the device

In genere le notifiche vengono inviate da un servizio di back-end ma per questa esercitazione è possibile inviare notifiche relative alle ultime notizie direttamente dall'applicazione.Normally notifications would be sent by a backend service but, you can send breaking news notifications directly from the app. A tale scopo si aggiornerà il metodo SendNotificationRESTAPI definito nell'esercitazione Introduzione ad Hub di notifica.To do this we will update the SendNotificationRESTAPI method that we defined in the Get started with Notification Hubs tutorial.

  1. In ViewController.m aggiornare il metodo SendNotificationRESTAPI come segue in modo che accetti un parametro per il tag di categoria e invii la notifica modello appropriata.In ViewController.m update the SendNotificationRESTAPI method as follows so that it accepts a parameter for the category tag and sends the proper template notification.

     - (void)SendNotificationRESTAPI:(NSString*)categoryTag
     {
         NSURLSession* session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration
                                  defaultSessionConfiguration] delegate:nil delegateQueue:nil];
    
         NSString *json;
    
         // Construct the messages REST endpoint
         NSURL* url = [NSURL URLWithString:[NSString stringWithFormat:@"%@%@/messages/%@", HubEndpoint,
                                            HUBNAME, API_VERSION]];
    
         // Generated the token to be used in the authorization header.
         NSString* authorizationToken = [self generateSasToken:[url absoluteString]];
    
         //Create the request to add the template notification message to the hub
         NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
         [request setHTTPMethod:@"POST"];
    
         // Add the category as a tag
         [request setValue:categoryTag forHTTPHeaderField:@"ServiceBusNotification-Tags"];
    
         // Template notification
         json = [NSString stringWithFormat:@"{\"messageParam\":\"Breaking %@ News : %@\"}",
                 categoryTag, self.notificationMessage.text];
    
         // Signify template notification format
         [request setValue:@"template" forHTTPHeaderField:@"ServiceBusNotification-Format"];
    
         // JSON Content-Type
         [request setValue:@"application/json;charset=utf-8" forHTTPHeaderField:@"Content-Type"];
    
         //Authenticate the notification message POST request with the SaS token
         [request setValue:authorizationToken forHTTPHeaderField:@"Authorization"];
    
         //Add the notification message body
         [request setHTTPBody:[json dataUsingEncoding:NSUTF8StringEncoding]];
    
         // Send the REST request
         NSURLSessionDataTask* dataTask = [session dataTaskWithRequest:request
                    completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
            {
            NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;
                if (error || httpResponse.statusCode != 200)
                {
                    NSLog(@"\nError status: %d\nError: %@", httpResponse.statusCode, error);
                }
                if (data != NULL)
                {
                    //xmlParser = [[NSXMLParser alloc] initWithData:data];
                    //[xmlParser setDelegate:self];
                    //[xmlParser parse];
                }
            }];
    
         [dataTask resume];
     }
    
  2. In ViewController.m aggiornare l’azione Send Notification nel modo illustrato nel codice seguente.In ViewController.m update the Send Notification action as shown in the code that follows. In tal modo si inviano notifiche a più piattaforme utilizzando singolarmente ogni tag.So that it will send the notifications using each tag individually and send to multiple platforms.

     - (IBAction)SendNotificationMessage:(id)sender
     {
         self.sendResults.text = @"";
    
         NSArray* categories = [NSArray arrayWithObjects: @"World", @"Politics", @"Business",
                                 @"Technology", @"Science", @"Sports", nil];
    
         // Lets send the message as breaking news for each category to WNS, GCM, and APNS
         // using a template.
         for(NSString* category in categories)
         {
             [self SendNotificationRESTAPI:category];
         }
     }
    
  3. Ricompilare il progetto e assicurarsi che non siano presenti errori di compilazione.Rebuild your project and make sure you have no build errors.

Esecuzione dell'app e generazione di notificheRun the app and generate notifications

  1. Premere il pulsante Esegui per compilare il progetto e avviare l'app.Press the Run button to build the project and start the app. Selezionare alcune opzioni di notizie per cui eseguire la sottoscrizione e premere il pulsante Subscribe .Select some breaking news options to subscribe to and then press the Subscribe button. Verrà visualizzata una finestra di dialogo che indica che è staa effettuata la sottoscrizione alle notifiche.You should see a dialog indicating the notifications have been subscribed to.

    Quando si fa clic su Subscribe, l'app converte le categorie selezionate in tag e richiede una nuova registrazione del dispositivo per i tag selezionati dall'hub di notifica.When you choose Subscribe, the app converts the selected categories into tags and requests a new device registration for the selected tags from the notification hub.

  2. Immettere un messaggio da inviare come ultime notizie, quindi premere il pulsante Send Notification (Invia notifica).Enter a message to be sent as breaking news then press the Send Notification button. In alternativa, eseguire l'app console .NET per generare le notifiche.Alternatively, run the .NET console app to generate notifications.

  3. Ogni dispositivo iscritto alle notizie riceverà le notifiche relative alle ultime notizie appena inviate.Each device subscribed to breaking news will receive the breaking news notifications you just sent.

Passaggi successiviNext steps

In questa esercitazione si è appreso a trasmettere le ultime novità per categoria.In this tutorial we learned how to broadcast breaking news by category. Per informazioni su altri scenari avanzati di Hub di notifica, provare a completare le seguenti esercitazioni:Consider completing one of the following tutorials that highlight other advanced Notification Hubs scenarios:

  • Usare Hub di notifica per la trasmissione di notizie localizzate[Use Notification Hubs to broadcast localized breaking news]

    Informazioni su come espandere l'app relativa alle ultime novità per abilitare l'invio di notifiche localizzate.Learn how to expand the breaking news app to enable sending localized notifications.