Usare l'SDK del server back-end .NET per app per dispositivi mobili di Azure

Articolo
10/01/2016

Questo argomento illustra come usare l'SDK del server back-end .NET negli scenari principali di App per dispositivi mobili del servizio app di Azure. Azure Mobile Apps SDK consente di usare i client per dispositivi mobili dall'applicazione ASP.NET.

Suggerimento

Il .NET Server SDK per App per dispositivi mobili di Azure è open source in GitHub. Il repository contiene tutto il codice sorgente, incluso l'intero gruppo di unit test dell'SDK del server e alcuni progetti di esempio.

Documentazione di riferimento

La documentazione di riferimento per l'SDK del server è disponibile qui: Informazioni di riferimento su .NET per app per dispositivi mobili di Azure.

Procedura: Creare un back-end dell'app per dispositivi mobili .NET

Se si avvia un nuovo progetto, è possibile creare un'applicazione del servizio app usando il portale di Azure o Visual Studio. È possibile eseguire l'applicazione del servizio app in locale o pubblicare il progetto nell'app per dispositivi mobili del servizio app basata sul cloud.

Se si aggiungono funzionalità per dispositivi mobili a un progetto esistente, vedere la sezione Scaricare e inizializzare l'SDK.

Creare un back-end .NET usando il portale di Azure

Per creare un back-end mobile del servizio app, seguire l'esercitazione di avvio rapido o seguire questa procedura:

Accedere al portale di Azure .
Selezionare +NEW>Web + Mobile>Mobile Appe quindi specificare un nome per il back-end delle app per dispositivi mobili.
Per gruppo di risorse, selezionare un gruppo di risorse esistente o crearne uno nuovo (usando lo stesso nome dell'app).
Per il piano di servizio app , viene selezionato il piano predefinito nel livello standard . È anche possibile selezionare un piano diverso oppure crearne uno nuovo.

Le impostazioni del piano di servizio app determinano la posizione , le funzionalità, i costi e le risorse di calcolo associati all'app. Per altre informazioni sui piani di servizio app e su come creare un nuovo piano in un piano tariffario diverso e nella località desiderata, vedere panoramica approfondita dei piani di servizio app di Azure.
Fare clic su Crea. Questo passaggio crea il back-end delle app per dispositivi mobili.
Nel riquadro Impostazioni di per il nuovo back-end di App per dispositivi mobili selezionare Avvio rapido> piattaforma dell'app client >Connettere un database.
Nel riquadro Aggiungi connessione dati, selezionare Database SQL>crea un nuovo database. Immettere il nome del database, scegliere un piano tariffario e quindi selezionare Server. È possibile riutilizzare questo nuovo database. Se si dispone già di un database nella stessa posizione, è possibile scegliere Usare un database esistente. Non è consigliabile usare un database in una posizione diversa, a causa dei costi della larghezza di banda e di una latenza più elevata.
Nel riquadro Nuovo server immettere un nome server univoco nella casella Nome server, specificare un account di accesso e una password, selezionare Consentire ai servizi di Azure di accedere al servere selezionare OK. Questo passaggio crea il nuovo database.
Nel riquadro Aggiungi connessione dati, seleziona Stringa di connessione, inserisci il nome utente e la password per il tuo database e seleziona OK.

Attendere alcuni minuti affinché il database venga distribuito correttamente prima di procedere.

Tornare al pannello Introduzione in Creare un'API di tabellascegliere C# come linguaggio back-end . Fare clic su Scaricare, estrarre i file di progetto compressi nel computer locale e aprire la soluzione in Visual Studio.

Creare un back-end .NET con Visual Studio 2017

Installare il carico di lavoro di Azure tramite il programma di installazione di Visual Studio per pubblicare nel progetto App per dispositivi mobili di Azure da Visual Studio. Dopo aver installato l'SDK, creare un'applicazione ASP.NET seguendo questa procedura:

Aprire la finestra di dialogo Nuovo progetto (da File>Nuovo>Progetto...).
Espandere Visual C# e selezionare Web.
Selezionare applicazione Web ASP.NET (.NET Framework).
Immettere il nome del progetto. Quindi fare clic su OK.
Seleziona il modello App per dispositivi mobili Azure dall'elenco dei modelli.
Fare clic su OK per creare la soluzione.
Fare clic con il pulsante destro del mouse sul progetto nell'Esplora soluzioni e scegliere Pubblica..., quindi scegliere Servizio App come destinazione di pubblicazione.
Seguire le istruzioni per l'autenticazione e scegliere un servizio app di Azure nuovo o esistente da pubblicare.

Creare un back-end .NET con Visual Studio 2015

Installare Azure SDK per .NET (versione 2.9.0 o successiva) per creare un progetto di App per dispositivi mobili di Azure in Visual Studio. Dopo aver installato l'SDK, creare un'applicazione ASP.NET seguendo questa procedura:

Aprire la finestra di dialogo nuovo progetto da File>Nuovo progetto>).
Espandi Modelli>Visual C#e seleziona Web.
Selezionare Applicazione Web ASP.NET.
Immettere il nome del progetto. Quindi fare clic su OK.
In Modelli ASP.NET 4.5.2, selezionare Azure Mobile App. Controllare Host nel cloud per creare un back-end per dispositivi mobili nel cloud in cui è possibile pubblicare questo progetto.
Fare clic su OK.

Procedura: Scaricare e inizializzare l'SDK

L'SDK è disponibile in NuGet.org. Questo pacchetto include la funzionalità di base necessaria per iniziare a usare l'SDK. Per inizializzare l'SDK, è necessario eseguire azioni sull'oggetto HttpConfiguration.

Installazione dell'SDK

Per installare l'SDK, fare clic con il pulsante destro del mouse sul progetto server in Visual Studio, selezionare Gestisci pacchetti NuGet, cercare il pacchetto Microsoft.Azure.Mobile.Server, quindi fare clic su Installa.

Inizializzare il progetto server

Un progetto server back-end .NET viene inizializzato in modo simile ad altri progetti di ASP.NET, includendo una classe di avvio OWIN. Assicurarsi di aver fatto riferimento al pacchetto NuGet Microsoft.Owin.Host.SystemWeb. Per aggiungere questa classe in Visual Studio, fare clic con il pulsante destro del mouse sul progetto server e selezionare Aggiungi>Nuovo elemento, quindi Web>Generale>Classe di Avvio OWIN. Viene generata una classe con l'attributo seguente:

[assembly: OwinStartup(typeof(YourServiceName.YourStartupClassName))]

Nel metodo Configuration() della classe di avvio OWIN usare un oggetto HttpConfiguration per configurare l'ambiente di App per dispositivi mobili di Azure. Nell'esempio seguente il progetto server viene inizializzato senza funzionalità aggiunte:

// in OWIN startup class
public void Configuration(IAppBuilder app)
{
    HttpConfiguration config = new HttpConfiguration();

    new MobileAppConfiguration()
        // no added features
        .ApplyTo(config);

    app.UseWebApi(config);
}

Per abilitare le singole funzionalità, è necessario chiamare i metodi di estensione nell'oggetto MobileAppConfiguration prima di chiamare ApplyTo. Ad esempio, il codice seguente aggiunge le route predefinite a tutti i controller API con l'attributo [MobileAppController] durante l'inizializzazione:

new MobileAppConfiguration()
    .MapApiControllers()
    .ApplyTo(config);

L'avvio rapido del server dal portale di Azure chiama UseDefaultConfiguration(). Equivale alla configurazione seguente:

    new MobileAppConfiguration()
        .AddMobileAppHomeController()             // from the Home package
        .MapApiControllers()
        .AddTables(                               // from the Tables package
            new MobileAppTableConfiguration()
                .MapTableControllers()
                .AddEntityFramework()             // from the Entity package
            )
        .AddPushNotifications()                   // from the Notifications package
        .MapLegacyCrossDomainController()         // from the CrossDomain package
        .ApplyTo(config);

I metodi di estensione usati sono:

AddMobileAppHomeController() fornisce la home page predefinita di App per dispositivi mobili di Azure.
MapApiControllers() fornisce funzionalità API personalizzate per i controller WebAPI decorati con l'attributo [MobileAppController].
AddTables() fornisce una mappatura degli endpoint /tables ai controller di tabella.
AddTablesWithEntityFramework() è una breve operazione per eseguire il mapping degli endpoint /tables usando controller basati su Entity Framework.
AddPushNotifications() fornisce un semplice metodo di registrazione dei dispositivi per Hub di notifica.
MapLegacyCrossDomainController() fornisce intestazioni CORS standard per lo sviluppo locale.

Estensioni SDK

I pacchetti di estensione basati su NuGet seguenti offrono varie funzionalità per dispositivi mobili che possono essere usate dall'applicazione. È possibile abilitare le estensioni durante l'inizializzazione usando l'oggetto MobileAppConfiguration.

Microsoft.Azure.Mobile.Server.Quickstart Supporta la configurazione di base delle app per dispositivi mobili. Aggiunta alla configurazione chiamando il metodo di estensione UseDefaultConfiguration durante l'inizializzazione. Questa estensione include le estensioni seguenti: Notifiche, Autenticazione, Entità, Tabelle, Cross-domain e Pacchetti Home. Questo pacchetto viene usato dalla guida introduttiva alle app per dispositivi mobili disponibile nel portale di Azure.
Microsoft.Azure.Mobile.Server.Home implementa la pagina predefinita "questa app per dispositivi mobili è attiva e in esecuzione" per la radice del sito Web. Aggiungere alla configurazione chiamando il metodo di estensione AddMobileAppHomeController.
Microsoft.Azure.Mobile.Server.Tables include classi per l'uso dei dati e la configurazione della pipeline di dati. Aggiungere alla configurazione chiamando il metodo di estensione addTables.
Microsoft.Azure.Mobile.Server.Entity Consente a Entity Framework di accedere ai dati nel database SQL. Aggiungere alla configurazione chiamando il metodo di estensione AddTablesWithEntityFramework.
Microsoft.Azure.Mobile.Server.Authentication Abilita l'autenticazione e configura il middleware OWIN usato per convalidare i token. Aggiungere alla configurazione chiamando il AddAppServiceAuthentication e IAppBuilder.Metodi di estensione UseAppServiceAuthentication.
Microsoft.Azure.Mobile.Server.Notifications Abilita le notifiche push e definisce un endpoint di registrazione push. Aggiungere alla configurazione chiamando il metodo di estensione AddPushNotifications.
Microsoft.Azure.Mobile.Server.CrossDomain Crea un controller che fornisce dati ai browser web legacy dalla tua app mobile. Aggiungere alla configurazione chiamando il metodo di estensione MapLegacyCrossDomainController.
metodo Microsoft.Azure.Mobile.Server.Login Fornisce il metodo AppServiceLoginHandler.CreateToken(), che è un metodo statico usato durante scenari di autenticazione personalizzati.

Procedura: Pubblicare il progetto server

Questa sezione illustra come pubblicare il progetto back-end .NET da Visual Studio. È anche possibile distribuire il progetto back-end usando Git o uno degli altri metodi disponibili in questa posizione.

In Visual Studio ricompilare il progetto per ripristinare i pacchetti NuGet.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto, scegliere Pubblica. La prima volta che si pubblica, è necessario definire un profilo di pubblicazione. Quando hai già definito un profilo, puoi selezionarlo e fare clic su Pubblica.
Se viene chiesto di selezionare una destinazione di pubblicazione, fare clic su Servizio app di Microsoft Azure>Avanti, quindi, se necessario, accedere con le credenziali di Azure. Visual Studio scarica e archivia in modo sicuro le impostazioni di pubblicazione direttamente da Azure.
Scegliere la sottoscrizione , selezionare tipo di risorsa da Visualizza, espandere app per dispositivi mobilie fare clic sul back-end dell'app per dispositivi mobili, quindi fare clic su OK.
Verificare le informazioni sul profilo di pubblicazione e fare clic su Pubblica.

Quando il back-end dell'app per dispositivi mobili è stato pubblicato correttamente, viene visualizzata una pagina di destinazione che indica l'esito positivo.

Procedura: Definire un controller di tabella

Definire un controller di tabella per esporre una tabella SQL ai client mobili. La configurazione di un controller di tabella richiede tre passaggi:

Creare una classe DTO (Data Transfer Object).
Configurare un riferimento a una tabella nella classe Mobile DbContext.
Creare un controller di tabella.

Un oggetto DTO (Data Transfer Object) è un oggetto C# normale che eredita da EntityData. Per esempio:

public class TodoItem : EntityData
{
    public string Text { get; set; }
    public bool Complete {get; set;}
}

L'oggetto DTO viene usato per definire la tabella all'interno del database SQL. Per creare la voce di database, aggiungere una proprietà DbSet<> all'oggetto DbContext in uso. Nel modello di progetto predefinito per App per dispositivi mobili di Azure, DbContext viene chiamato Models\MobileServiceContext.cs:

public class MobileServiceContext : DbContext
{
    private const string connectionStringName = "Name=MS_TableConnectionString";

    public MobileServiceContext() : base(connectionStringName)
    {

    }

    public DbSet<TodoItem> TodoItems { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Add(
            new AttributeToColumnAnnotationConvention<TableColumnAttribute, string>(
                "ServiceColumnTable", (property, attributes) => attributes.Single().ColumnType.ToString()));
    }
}

Se Azure SDK è installato, è ora possibile creare un controller di tabella modello come indicato di seguito:

Fare clic con il pulsante destro del mouse sulla cartella Controller e selezionare Aggiungi controller>....
Selezionare l'opzione Controller di Tabella per app per dispositivi mobili di Azure e quindi fare clic su Aggiungi.
Nella finestra di dialogo del controller aggiungi:
- Nel menu a discesa della classe modello , selezionare il nuovo DTO.
- Nell'elenco a discesa DbContext selezionare la classe DbContext del servizio mobile.
- Il nome del controller viene creato per te automaticamente.
Fare clic su Aggiungi.

Il progetto server di avvio rapido contiene un esempio per una semplice TodoItemController.

Procedura: Regolare le dimensioni della paginazione della tabella

Per impostazione predefinita, App per dispositivi mobili di Azure restituisce 50 record per richiesta. Il paging garantisce che il client non blocchi il thread dell'interfaccia utente né impegni il server per troppo tempo, assicurando un'esperienza utente ottimale. Per modificare le dimensioni del paging della tabella, aumentare la "dimensione consentita della query" lato server e la dimensione della pagina lato client. La "dimensione consentita della query" lato server viene modificata usando l'attributo EnableQuery:

[EnableQuery(PageSize = 500)]

Verificare che PageSize sia uguale o maggiore delle dimensioni richieste dal client. Per informazioni dettagliate sulla modifica delle dimensioni della pagina client, vedere la documentazione HOWTO del client specifica.

Procedura: Definire un controller API personalizzato

Il controller API personalizzato fornisce la funzionalità di base al back-end dell'app per dispositivi mobili esponendo un endpoint. È possibile registrare un controller API specifico per dispositivi mobili usando l'attributo [MobileAppController]. L'attributo MobileAppController registra la route, configura il serializzatore JSON delle app mobili, e attiva il controllo della versione del client .

In Visual Studio fare clic con il pulsante destro del mouse sulla cartella Controller, quindi scegliere Aggiungi>Controller, selezionare Controller API Web 2- Vuoto e fare clic su Aggiungi.
Specificare un nome controller , ad esempio CustomControllere fare clic su Aggiungi.
Nel nuovo file di classe del controller, aggiungere la seguente istruzione using:
```
 using Microsoft.Azure.Mobile.Server.Config;
```
Applicare l'attributo [MobileAppController] alla definizione della classe del controller API, come nell'esempio seguente:
```
 [MobileAppController]
 public class CustomController : ApiController
 {
       //...
 }
```
Nel file App_Start/Startup.MobileApp.cs aggiungere una chiamata al metodo di estensione MapApiControllers, come nell'esempio seguente:
```
 new MobileAppConfiguration()
     .MapApiControllers()
     .ApplyTo(config);
```

È anche possibile usare il metodo di estensione UseDefaultConfiguration() anziché MapApiControllers(). Tutti i controller che non dispongono di MobileAppControllerAttribute applicati possono comunque essere accessibili dai client, ma potrebbero non essere utilizzati correttamente dai client che usano qualsiasi SDK client dell'app per dispositivi mobili.

Come fare a: Lavorare con l'autenticazione

App per dispositivi mobili di Azure usa l'autenticazione/autorizzazione del servizio app per proteggere il back-end per dispositivi mobili. Questa sezione illustra come eseguire le attività correlate all'autenticazione seguenti nel progetto server back-end .NET:

Procedura: Aggiungere l'autenticazione a un progetto server
Procedura: Usare l'autenticazione personalizzata per l'applicazione
Procedura: Recuperare le informazioni utente autenticate
Procedura: Limitare l'accesso ai dati per gli utenti autorizzati

Procedura: Aggiungere l'autenticazione a un progetto server

È possibile aggiungere l'autenticazione al progetto server estendendo l'oggetto mobileAppConfiguration e configurando il middleware OWIN. Quando si installa il pacchetto di Microsoft.Azure.Mobile.Server.Quickstart e si chiama il metodo di estensione UseDefaultConfiguration, è possibile passare al passaggio 3.

In Visual Studio installare il pacchetto Microsoft.Azure.Mobile.Server.Authentication.
Nel file di progetto Startup.cs, aggiungere la seguente riga di codice all'inizio del metodo Configuration.
```
 app.UseAppServiceAuthentication(config);
```
Questo componente middleware OWIN convalida i token emessi dal gateway del servizio app associato.
Aggiungere l'attributo [Authorize] a qualsiasi controller o metodo che richiede l'autenticazione.

Per informazioni su come autenticare i client nel back-end delle app per dispositivi mobili, vedere Aggiungere l'autenticazione all'app.

Procedura: Usare l'autenticazione personalizzata per l'applicazione

Importante

Per abilitare l'autenticazione personalizzata, è prima necessario abilitare l'autenticazione del servizio app senza selezionare un provider per il servizio app nel portale di Azure. In questo modo verrà abilitata la variabile di ambiente WEBSITE_AUTH_SIGNING_KEY quando è ospitata.

Se non si vuole usare uno dei provider di autenticazione/autorizzazione del servizio app, è possibile implementare il proprio sistema di accesso. Installare il pacchetto Microsoft.Azure.Mobile.Server.Login per facilitare la generazione di token di autenticazione. Specificare il proprio codice per la convalida delle credenziali utente. Ad esempio, potresti verificare le password salate e cifrate in un database. Nell'esempio seguente il metodo isValidAssertion() (definito altrove) è responsabile di questi controlli.

L'autenticazione personalizzata viene esposta creando un ApiController ed esponendo azioni register e login. Il client deve usare un'interfaccia utente personalizzata per raccogliere le informazioni dall'utente. Le informazioni vengono quindi inviate all'API con una chiamata HTTP POST standard. Dopo che il server convalida l'asserzione, viene emesso un token usando il metodo AppServiceLoginHandler.CreateToken(). Il ApiController non deve usare l'attributo [MobileAppController].

Esempio di azione login:

    public IHttpActionResult Post([FromBody] JObject assertion)
    {
        if (isValidAssertion(assertion)) // user-defined function, checks against a database
        {
            JwtSecurityToken token = AppServiceLoginHandler.CreateToken(new Claim[] { new Claim(JwtRegisteredClaimNames.Sub, assertion["username"]) },
                mySigningKey,
                myAppURL,
                myAppURL,
                TimeSpan.FromHours(24) );
            return Ok(new LoginResult()
            {
                AuthenticationToken = token.RawData,
                User = new LoginResultUser() { UserId = userName.ToString() }
            });
        }
        else // user assertion was not valid
        {
            return this.Request.CreateUnauthorizedResponse();
        }
    }

Nell'esempio precedente LoginResult e LoginResultUser sono oggetti serializzabili che espongono le proprietà necessarie. Il client prevede che le risposte di accesso vengano restituite come oggetti JSON del modulo:

    {
        "authenticationToken": "<token>",
        "user": {
            "userId": "<userId>"
        }
    }

Il metodo AppServiceLoginHandler.CreateToken() include un gruppo di destinatari e un parametro dell'autorità emittente. Entrambi questi parametri sono impostati sull'URL della radice dell'applicazione, usando lo schema HTTPS. Analogamente, è necessario impostare secretKey come valore della chiave di firma dell'applicazione. Non distribuire la chiave di firma in un client perché può essere usata per coniare le chiavi e rappresentare gli utenti. È possibile ottenere la chiave di firma mentre è ospitata nel servizio app facendo riferimento alla variabile di ambiente WEBSITE_AUTH_SIGNING_KEY. Se necessario in un contesto di debug locale, seguire le istruzioni nella sezione Debug locale con autenticazione per recuperare la chiave e archiviarla come impostazione dell'applicazione.

Il token emesso può includere anche altre attestazioni e una data di scadenza. Minimamente, il token rilasciato deve includere un'attestazione subject (sub).

È possibile supportare il client standard loginAsync() realizzando un sovraccarico della route di autenticazione. Se il client chiama client.loginAsync('custom'); per accedere, la route deve essere /.auth/login/custom. È possibile impostare la route per il controller di autenticazione personalizzato usando MapHttpRoute():

config.Routes.MapHttpRoute("custom", ".auth/login/custom", new { controller = "CustomAuth" });

Suggerimento

L'uso dell'approccio loginAsync() garantisce che il token di autenticazione sia associato a ogni chiamata successiva al servizio.

Procedura: Recuperare le informazioni utente autenticate

Quando un utente viene autenticato dal servizio app, è possibile accedere all'ID utente assegnato e ad altre informazioni nel codice back-end .NET. Le informazioni utente possono essere usate per prendere decisioni di autorizzazione nel back-end. Il codice seguente ottiene l'ID utente associato a una richiesta:

// Get the SID of the current user.
var claimsPrincipal = this.User as ClaimsPrincipal;
string sid = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;

Il SID è derivato dall'ID utente specifico del provider ed è statico per un determinato utente e provider di accesso. Il SID è Null per i token di autenticazione non validi.

Il servizio app consente anche di richiedere attestazioni specifiche dal provider di accesso. Ogni provider di identità può fornire ulteriori informazioni utilizzando l'SDK del provider di identità. Ad esempio, è possibile usare l'API Graph di Facebook per informazioni sugli amici. È possibile specificare attestazioni richieste nel pannello del provider nel portale di Azure. Alcune richieste richiedono una configurazione aggiuntiva con il fornitore di identità.

Il codice seguente chiama il metodo di estensione GetAppServiceIdentityAsync per ottenere le credenziali di accesso, che includono il token di accesso necessario per effettuare richieste all'API Graph di Facebook:

// Get the credentials for the logged-in user.
var credentials =
    await this.User
    .GetAppServiceIdentityAsync<FacebookCredentials>(this.Request);

if (credentials.Provider == "Facebook")
{
    // Create a query string with the Facebook access token.
    var fbRequestUrl = "https://graph.facebook.com/me/feed?access_token="
        + credentials.AccessToken;

    // Create an HttpClient request.
    var client = new System.Net.Http.HttpClient();

    // Request the current user info from Facebook.
    var resp = await client.GetAsync(fbRequestUrl);
    resp.EnsureSuccessStatusCode();

    // Do something here with the Facebook user information.
    var fbInfo = await resp.Content.ReadAsStringAsync();
}

Aggiungere un'istruzione "using" per System.Security.Principal in modo da fornire il metodo di estensione GetAppServiceIdentityAsync.

Procedura: Limitare l'accesso ai dati per gli utenti autorizzati

Nella sezione precedente è stato illustrato come recuperare l'ID utente di un utente autenticato. È possibile limitare l'accesso ai dati e ad altre risorse in base a questo valore. Ad esempio, l'aggiunta di una colonna userId alle tabelle e il filtro dei risultati della query in base all'ID utente è un modo semplice per limitare i dati restituiti solo agli utenti autorizzati. Il codice seguente restituisce righe di dati solo quando il SID corrisponde al valore nella colonna UserId della tabella TodoItem:

// Get the SID of the current user.
var claimsPrincipal = this.User as ClaimsPrincipal;
string sid = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;

// Only return data rows that belong to the current user.
return Query().Where(t => t.UserId == sid);

Il metodo Query() restituisce un IQueryable che può essere modificato da LINQ per gestire il filtro.

Procedura: Aggiungere notifiche push a un progetto server

Aggiungere notifiche push al progetto server estendendo l'oggetto MobileAppConfiguration e creando un client di Notification Hubs.

In Visual Studio fare clic con il pulsante destro del mouse sul progetto server e scegliere Gestisci pacchetti NuGet, cercare Microsoft.Azure.Mobile.Server.Notifications, quindi fare clic su Installa.
Ripetere questo passaggio per installare il pacchetto Microsoft.Azure.NotificationHubs, che include la libreria client di Hub di notifica.
In App_Start/Startup.MobileApp.cs, e aggiungere una chiamata al metodo di estensione AddPushNotifications() durante l'inizializzazione.
```
 new MobileAppConfiguration()
     // other features...
     .AddPushNotifications()
     .ApplyTo(config);
```

Aggiungere il codice seguente che crea un client di Hub di notifica:

 // Get the settings for the server project.
 HttpConfiguration config = this.Configuration;
 MobileAppSettingsDictionary settings =
     config.GetMobileAppSettingsProvider().GetMobileAppSettings();

 // Get the Notification Hubs credentials for the Mobile App.
 string notificationHubName = settings.NotificationHubName;
 string notificationHubConnection = settings
     .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

 // Create a new Notification Hub client.
 NotificationHubClient hub = NotificationHubClient
     .CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

È ora possibile usare il client hub di notifica per inviare notifiche push ai dispositivi registrati. Per altre informazioni, vedere Aggiungere notifiche push all'app. Per altre informazioni su Hub di notifica, vedere Panoramica di Hub di notifica .

Procedura: Abilitare il push mirato usando tag

Hub di notifica consente di inviare notifiche mirate a registrazioni specifiche usando tag. Vengono creati automaticamente diversi tag:

L'ID di installazione identifica un dispositivo specifico.
L'ID utente basato sul SID autenticato identifica un utente specifico.

È possibile accedere all'ID di installazione dalla proprietà installationId nel MobileServiceClient. L'esempio seguente illustra come usare un ID di installazione per aggiungere un tag a un'installazione specifica in Hub di notifica:

hub.PatchInstallation("my-installation-id", new[]
{
    new PartialUpdateOperation
    {
        Operation = UpdateOperationType.Add,
        Path = "/tags",
        Value = "{my-tag}"
    }
});

Tutti i tag forniti dal client durante la registrazione delle notifiche push vengono ignorati dal back-end durante la creazione dell'installazione. Per consentire a un client di aggiungere tag all'installazione, è necessario creare un'API personalizzata che aggiunge tag usando il modello precedente.

Per un esempio, vedere tag di notifica push aggiunti al client nell'esempio di avvio rapido completato per app per dispositivi mobili del servizio app.

Procedura: Inviare notifiche push a un utente autenticato

Quando un utente autenticato esegue la registrazione per le notifiche push, alla registrazione viene aggiunto automaticamente un tag ID utente. Usando questo tag, è possibile inviare notifiche push a tutti i dispositivi registrati da tale persona. Il codice seguente ottiene il SID dell'utente che effettua la richiesta e invia una notifica push modello a ogni registrazione del dispositivo per tale persona:

// Get the current user SID and create a tag for the current user.
var claimsPrincipal = this.User as ClaimsPrincipal;
string sid = claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
string userTag = "_UserId:" + sid;

// Build a dictionary for the template with the item message text.
var notification = new Dictionary<string, string> { { "message", item.Text } };

// Send a template notification to the user ID.
await hub.SendTemplateNotificationAsync(notification, userTag);

Quando si esegue la registrazione per le notifiche push da un client autenticato, assicurarsi che l'autenticazione sia stata completata prima di tentare la registrazione. Per altre informazioni, vedere Eseguire il push agli utenti nell'esempio di avvio rapido completo per le app mobili del servizio app per il back-end .NET.

Procedura: Eseguire il debug e risolvere i problemi di .NET Server SDK

Servizio app di Azure offre diverse tecniche di debug e risoluzione dei problemi per le applicazioni ASP.NET:

Registrazione

È possibile scrivere ai log di diagnostica del Servizio App usando la scrittura di traccia standard ASP.NET. Prima di poter scrivere nei log, è necessario abilitare la diagnostica nel back-end dell'app per dispositivi mobili.

Per abilitare la diagnostica e scrivere nei log:

Seguire i passaggi descritti in Abilitare la registrazione delle applicazioni (Windows).
Aggiungere la seguente istruzione using nel file di codice:
```
 using System.Web.Http.Tracing;
```

Creare un writer di traccia per scrivere dal back-end .NET ai log diagnostici, come indicato di seguito:

 ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
 traceWriter.Info("Hello, World");

Ripubblica il progetto del server e accedi al back-end dell'app per dispositivi mobili per eseguire il flusso di codice includendo i log.
Scaricare e valutare i log, come descritto in Accedere ai file di log.

Debug locale con autenticazione

È possibile eseguire l'applicazione in locale per testare le modifiche prima di pubblicarle nel cloud. Per la maggior parte dei back-end di App per dispositivi mobili di Azure, premere F5 in Visual Studio. Esistono tuttavia alcune considerazioni aggiuntive quando si usa l'autenticazione.

È necessario avere un'app per dispositivi mobili basata sul cloud con l'autenticazione/autorizzazione del servizio app configurata e il client deve avere l'endpoint cloud specificato come host di accesso alternativo. Per i passaggi specifici necessari, vedere la documentazione relativa alla piattaforma client.

Assicurarsi che nel back-end per dispositivi mobili sia installato Microsoft.Azure.Mobile.Server. Authentication. Quindi, nella classe di avvio OWIN dell'applicazione aggiungere quanto segue, dopo che MobileAppConfiguration è stato applicato al HttpConfiguration:

    app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions()
    {
        SigningKey = ConfigurationManager.AppSettings["authSigningKey"],
        ValidAudiences = new[] { ConfigurationManager.AppSettings["authAudience"] },
        ValidIssuers = new[] { ConfigurationManager.AppSettings["authIssuer"] },
        TokenHandler = config.GetAppServiceTokenHandler()
    });

Nell'esempio precedente è necessario configurare le impostazioni dell'applicazione authAudience e authIssuer all'interno del file Web.config perché ciascuna sia l'URL della radice della vostra applicazione, usando lo schema HTTPS. Analogamente, è necessario impostare authSigningKey come valore della chiave di firma dell'applicazione. Per ottenere la chiave di firma:

Vai alla tua app all'interno del portale di Azure
Fare clic su Tools, Kudu, Go.
Nel sito di gestione Kudu fare clic su Ambiente.
Trova il valore per WEBSITE_AUTH_SIGNING_KEY.

Usare la chiave di firma per il parametro authSigningKey nella configurazione della tua applicazione locale. Il back-end mobile è ora in grado di convalidare i token durante l'esecuzione in locale; il client ottiene il token dall'endpoint basato sul cloud.

Condividi tramite