Aggiungere l'autenticazione all'app Xamarin.FormsAdd authentication to your Xamarin Forms app

OverviewOverview

Questo argomento descrive come autenticare gli utenti di un'app mobile del servizio app dall'applicazione client.This topic shows you how to authenticate users of an App Service Mobile App from your client application. In questa esercitazione verrà aggiunta l'autenticazione al progetto di guida introduttiva Xamarin.Forms tramite un provider di identità supportato dal servizio app.In this tutorial, you add authentication to the Xamarin Forms quickstart project using an identity provider that is supported by App Service. Dopo l'autenticazione e l'autorizzazione da parte dell'app per dispositivi mobili, viene visualizzato il valore dell'ID utente e si potrà accedere ai dati della tabella con restrizioni.After being successfully authenticated and authorized by your Mobile App, the user ID value is displayed, and you will be able to access restricted table data.

PrerequisitiPrerequisites

Per ottenere risultati ottimali con questa esercitazione, è consigliabile completare prima di tutto l'esercitazione Creare un'app Xamarin.Forms.For the best result with this tutorial, we recommend that you first complete the Create a Xamarin Forms app tutorial. Al termine di questa esercitazione, sarà disponibile un progetto Xamarin.Forms che corrisponde a un'app TodoList multipiattaforma.After you complete this tutorial, you will have a Xamarin Forms project that is a multi-platform TodoList app.

Se non si usa il progetto server di avvio rapido scaricato, è necessario aggiungere il pacchetto di estensione di autenticazione al progetto.If you do not use the downloaded quick start server project, you must add the authentication extension package to your project. Per altre informazioni sui pacchetti di estensione server, vedere l'articolo Usare l'SDK del server back-end .NET per App per dispositivi mobili di Azure.For more information about server extension packages, see Work with the .NET backend server SDK for Azure Mobile Apps.

Registrare l'app per l'autenticazione e configurare i servizi appRegister your app for authentication and configure App Services

Innanzitutto, è necessario registrare l'app nel sito di un provider di identità e quindi impostare le credenziali generate dal provider nel back-end dell'app per dispositivi mobili.First, you need to register your app at an identity provider's site, and then you will set the provider-generated credentials in the Mobile Apps back end.

  1. Configurare il provider di identità preferito seguendo le istruzioni specifiche del provider:Configure your preferred identity provider by following the provider-specific instructions:

  2. Ripetere i passaggi precedenti per ogni provider di cui si desidera il supporto nell'app.Repeat the previous steps for each provider you want to support in your app.

Aggiungere l'app agli URL di reindirizzamento esterni consentitiAdd your app to the Allowed External Redirect URLs

L'autenticazione sicura richiede la definizione di un nuovo schema URL per l'app.Secure authentication requires that you define a new URL scheme for your app. In questo modo il sistema di autenticazione reindirizza all'app al termine del processo di autenticazione.This allows the authentication system to redirect back to your app once the authentication process is complete. In questa esercitazione si usa lo schema URL appname.In this tutorial, we use the URL scheme appname throughout. È tuttavia possibile usare QUALSIASI schema URL.However, you can use any URL scheme you choose. Lo schema deve essere univoco per l'applicazione per dispositivi mobili.It should be unique to your mobile application. Per abilitare il reindirizzamento sul lato server:To enable the redirection on the server side:

  1. Nel portale di Azure selezionare il servizio app.In the Azure portal, select your App Service.

  2. Fare clic sull'opzione di menu Autenticazione/Autorizzazione.Click the Authentication / Authorization menu option.

  3. In URL di reindirizzamento esterni consentiti specificare url_scheme_of_your_app://easyauth.callback.In the Allowed External Redirect URLs, enter url_scheme_of_your_app://easyauth.callback. Il valore url_scheme_of_your_app in questa stringa è lo schema URL per l'applicazione per dispositivi mobili.The url_scheme_of_your_app in this string is the URL Scheme for your mobile application. Deve seguire le normale specifica URL per un protocollo, ovvero usare solo lettere e numeri e iniziare con una lettera.It should follow normal URL specification for a protocol (use letters and numbers only, and start with a letter). È opportuno prendere nota della stringa scelta perché sarà necessario modificare il codice dell'applicazione per dispositivi mobili con lo schema URL in diverse posizioni.You should make a note of the string that you choose as you will need to adjust your mobile application code with the URL Scheme in several places.

  4. Fare clic su OK.Click OK.

  5. Fare clic su Salva.Click Save.

Limitare le autorizzazioni agli utenti autenticatiRestrict permissions to authenticated users

Per impostazione predefinita, le API in un back-end dell'app per dispositivi mobili possono essere richiamate in modo anonimo.By default, APIs in a Mobile Apps back end can be invoked anonymously. È necessario limitare l'accesso solo ai client autenticati.Next, you need to restrict access to only authenticated clients.

  • Back-end Node. js nuovamente fine (tramite il Portale di Azure) :Node.js back end (via the Azure portal) :

    Nelle impostazioni dell'app per dispositivi mobili fare clic su Tabelle semplici e selezionare la tabella.In your Mobile Apps settings, click Easy Tables and select your table. Fare clic su Modifica autorizzazioni, selezionare Authenticated access only (Solo accesso con autenticazione) per tutte le autorizzazioni e quindi fare clic su Salva.Click Change permissions, select Authenticated access only for all permissions, and then click Save.

  • Back-end. NET (C#):.NET back end (C#):

    Nel progetto server passare a Controller > TodoItemController.cs.In the server project, navigate to Controllers > TodoItemController.cs. Aggiungere l'attributo [Authorize] alla classe TodoItemController, come indicato di seguito.Add the [Authorize] attribute to the TodoItemController class, as follows. Per limitare l'accesso solo a metodi specifici, è inoltre possibile applicare questo attributo solo a tali metodi anziché alla classe.To restrict access only to specific methods, you can also apply this attribute just to those methods instead of the class. Pubblicare di nuovo il progetto server.Republish the server project.

      [Authorize]
      public class TodoItemController : TableController<TodoItem>
    
  • Back-end Node.js (tramite codice Node.js) :Node.js backend (via Node.js code) :

    Per richiedere l'autenticazione per l'accesso alla tabella, aggiungere la riga seguente allo script del server Node.js:To require authentication for table access, add the following line to the Node.js server script:

      table.access = 'authenticated';
    

    Per altre informazioni, vedere Procedura: Richiedere l'autenticazione per l'accesso alle tabelle.For more details, see How to: Require authentication for access to tables. Per informazioni su come scaricare il progetto di codice di avvio rapido dal sito, vedere Procedura: Scaricare il progetto di codice di avvio rapido del back-end Node.js tramite Git.To learn how to download the quickstart code project from your site, see How to: Download the Node.js backend quickstart code project using Git.

Aggiungere l'autenticazione alla libreria di classi portabileAdd authentication to the portable class library

L'app per dispositivi mobili usa il metodo di estensione LoginAsync in MobileServiceClient per eseguire l'accesso di un utente con l'autenticazione del servizio app.Mobile Apps uses the LoginAsync extension method on the MobileServiceClient to sign in a user with App Service authentication. Questo esempio usa un flusso di autenticazione gestito dal server che mostra l'interfaccia di accesso del provider nell'app.This sample uses a server-managed authentication flow that displays the provider's sign-in interface in the app. Per altre informazioni, vedere Autenticazione gestita dal server.For more information, see Server-managed authentication. Per offrire un'esperienza utente migliore nell'app di produzione, è consigliabile prendere invece in considerazione l'uso dell'autenticazione gestita dal client.To provide a better user experience in your production app, you should consider instead using Client-managed authentication.

Per eseguire l'autenticazione con un progetto Xamarin.Forms, definire un'interfaccia IAuthenticate nella libreria di classi portabile per l'app.To authenticate with a Xamarin Forms project, define an IAuthenticate interface in the Portable Class Library for the app. Aggiungere quindi un pulsante di accesso all'interfaccia utente definita nella libreria di classi portabile, su cui fare clic per avviare l'autenticazione.Then add a Sign-in button to the user interface defined in the Portable Class Library, which you click to start authentication. Al completamento dell'autenticazione, i dati vengono caricati dal back-end dell'app per dispositivi mobili.Data is loaded from the mobile app backend after successful authentication.

Implementare l'interfaccia IAuthenticate per ogni piattaforma supportata dall'app.Implement the IAuthenticate interface for each platform supported by your app.

  1. In Visual Studio o Xamarin Studio aprire il file App.cs dal progetto che include Portable nel nome, che corrisponde al progetto di libreria di classi portabile, quindi aggiungere l'istruzione using seguente:In Visual Studio or Xamarin Studio, open App.cs from the project with Portable in the name, which is Portable Class Library project, then add the following using statement:

     using System.Threading.Tasks;
    
  2. In App.cs aggiungere la definizione dell'interfaccia IAuthenticate seguente immediatamente prima della definizione della classe App.In App.cs, add the following IAuthenticate interface definition immediately before the App class definition.

     public interface IAuthenticate
     {
         Task<bool> Authenticate();
     }
    
  3. Per inizializzare l'interfaccia con un'implementazione specifica per la piattaforma, aggiungere i membri statici seguenti alla classe App.To initialize the interface with a platform-specific implementation, add the following static members to the App class.

     public static IAuthenticate Authenticator { get; private set; }
    
     public static void Init(IAuthenticate authenticator)
     {
         Authenticator = authenticator;
     }
    
  4. Aprire il file TodoList.xaml dal progetto della libreria di classi portabile, aggiungere l'elemento Button seguente nell'elemento di layout buttonsPanel , dopo il pulsante esistente:Open TodoList.xaml from the Portable Class Library project, add the following Button element in the buttonsPanel layout element, after the existing button:

       <Button x:Name="loginButton" Text="Sign-in" MinimumHeightRequest="30"
         Clicked="loginButton_Clicked"/>
    

    Questo pulsante attiva l'autenticazione gestita dal server con il back-end dell'app per dispositivi mobili.This button triggers server-managed authentication with your mobile app backend.

  5. Aprire il file TodoList.xaml.cs dal progetto della libreria di classi portabile, quindi aggiungere il campo seguente alla classe TodoList :Open TodoList.xaml.cs from the Portable Class Library project, then add the following field to the TodoList class:

     // Track whether the user has authenticated.
     bool authenticated = false;
    
  6. Sostituire il metodo OnAppearing con il codice seguente:Replace the OnAppearing method with the following code:

     protected override async void OnAppearing()
     {
         base.OnAppearing();
    
         // Refresh items only when authenticated.
         if (authenticated == true)
         {
             // Set syncItems to true in order to synchronize the data
             // on startup when running in offline mode.
             await RefreshItems(true, syncItems: false);
    
             // Hide the Sign-in button.
             this.loginButton.IsVisible = false;
         }
     }
    

    Questo codice fa in modo che i dati vengano aggiornati dal servizio solo dopo l'autenticazione dell'utente.This code makes sure that data is only refreshed from the service after you have been authenticated.

  7. Aggiungere il gestore seguente per l'evento Clicked alla classe TodoList:Add the following handler for the Clicked event to the TodoList class:

     async void loginButton_Clicked(object sender, EventArgs e)
     {
         if (App.Authenticator != null)
             authenticated = await App.Authenticator.Authenticate();
    
         // Set syncItems to true to synchronize the data on startup when offline is enabled.
         if (authenticated == true)
             await RefreshItems(true, syncItems: false);
     }
    
  8. Salvare le modifiche e ricompilare il progetto della libreria di classi portabile, senza che si verifichino errori.Save your changes and rebuild the Portable Class Library project verifying no errors.

Aggiungere l'autenticazione all'app AndroidAdd authentication to the Android app

Questa sezione illustra come implementare l'interfaccia IAuthenticate nel progetto di app Android.This section shows how to implement the IAuthenticate interface in the Android app project. Se i dispositivi Android non sono supportati, ignorare questa sezione.Skip this section if you are not supporting Android devices.

  1. In Visual Studio o Xamarin Studio fare clic con il pulsante destro del mouse sul progetto droid, quindi scegliere Imposta come progetto di avvio.In Visual Studio or Xamarin Studio, right-click the droid project, then Set as StartUp Project.
  2. Premere F5 per avviare il progetto nel debugger, quindi verificare che venga generata un'eccezione non gestita con codice di stato 401 (Non autorizzato) dopo l'avvio dell'app.Press F5 to start the project in the debugger, then verify that an unhandled exception with a status code of 401 (Unauthorized) is raised after the app starts. La risposta 401 viene generata perché l'accesso al back-end è limitato solo agli utenti autorizzati.The 401 code is produced because access on the backend is restricted to authorized users only.
  3. Aprire il file MainActivity.cs nel progetto Android e aggiungere le istruzioni using seguenti:Open MainActivity.cs in the Android project and add the following using statements:

     using Microsoft.WindowsAzure.MobileServices;
     using System.Threading.Tasks;
    
  4. Aggiornare la classe MainActivity per implementare l'interfaccia IAuthenticate, come illustrato di seguito:Update the MainActivity class to implement the IAuthenticate interface, as follows:

     public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsApplicationActivity, IAuthenticate
    
  5. Aggiornare la classe MainActivity aggiungendo un campo MobileServiceUser e un metodo Authenticate, necessario per l'interfaccia IAuthenticate, come illustrato di seguito:Update the MainActivity class by adding a MobileServiceUser field and an Authenticate method, which is required by the IAuthenticate interface, as follows:

     // Define a authenticated user.
     private MobileServiceUser user;
    
     public async Task<bool> Authenticate()
     {
         var success = false;
         var message = string.Empty;
         try
         {
             // Sign in with Facebook login using a server-managed flow.
             user = await TodoItemManager.DefaultManager.CurrentClient.LoginAsync(this, 
                 MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
             if (user != null)
             {
                 message = string.Format("you are now signed-in as {0}.",
                     user.UserId);
                 success = true;
             }
         }
         catch (Exception ex)
         {
             message = ex.Message;
         }
    
         // Display the success or failure message.
         AlertDialog.Builder builder = new AlertDialog.Builder(this);
         builder.SetMessage(message);
         builder.SetTitle("Sign-in result");
         builder.Create().Show();
    
         return success;
     }
    

    Se si usa un provider di identità diverso da Facebook, scegliere un valore diverso per MobileServiceAuthenticationProvider.If you are using an identity provider other than Facebook, choose a different value for MobileServiceAuthenticationProvider.

  6. Aggiornare il file AndroidManifest.xml aggiungendo il codice XML seguente all'interno dell'elemento <application>:Update the AndroidManifest.xml file by adding the following XML inside the <application> element:

    <activity android:name="com.microsoft.windowsazure.mobileservices.authentication.RedirectUrlActivity" android:launchMode="singleTop" android:noHistory="true">
      <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="{url_scheme_of_your_app}" android:host="easyauth.callback" />
      </intent-filter>
    </activity>
    

    Sostituire {url_scheme_of_your_app} con lo schema URL.Replace {url_scheme_of_your_app} with your URL scheme.

  7. Aggiungere il codice seguente al metodo OnCreate della classe MainActivity prima della chiamata a LoadApplication():Add the following code to the OnCreate method of the MainActivity class before the call to LoadApplication():

     // Initialize the authenticator before loading the app.
     App.Init((IAuthenticate)this);
    

    Questo codice fa in modo che l'autenticatore venga inizializzato prima del caricamento dell'app.This code ensures the authenticator is initialized before the app loads.

  8. Ricompilare l'app, eseguirla, quindi accedere con il provider di autenticazione selezionato e verificare se è possibile accedere ai dati come utente autenticato.Rebuild the app, run it, then sign in with the authentication provider you chose and verify you are able to access data as an authenticated user.

Aggiungere l'autenticazione all'app iOSAdd authentication to the iOS app

Questa sezione illustra come implementare l'interfaccia IAuthenticate nel progetto di app iOS.This section shows how to implement the IAuthenticate interface in the iOS app project. Se i dispositivi iOS non sono supportati, ignorare questa sezione.Skip this section if you are not supporting iOS devices.

  1. In Visual Studio o Xamarin Studio fare clic con il pulsante destro del mouse sul progetto iOS, quindi scegliere Imposta come progetto di avvio.In Visual Studio or Xamarin Studio, right-click the iOS project, then Set as StartUp Project.
  2. Premere F5 per avviare il progetto nel debugger, quindi verificare che venga generata un'eccezione non gestita con codice di stato 401 (Non autorizzato) dopo l'avvio dell'app.Press F5 to start the project in the debugger, then verify that an unhandled exception with a status code of 401 (Unauthorized) is raised after the app starts. La risposta 401 viene generata perché l'accesso al back-end è limitato solo agli utenti autorizzati.The 401 response is produced because access on the backend is restricted to authorized users only.
  3. Aprire il file AppDelegate.cs nel progetto iOS e aggiungere le istruzioni using seguenti:Open AppDelegate.cs in the iOS project and add the following using statements:

     using Microsoft.WindowsAzure.MobileServices;
     using System.Threading.Tasks;
    
  4. Aggiornare la classe AppDelegate per implementare l'interfaccia IAuthenticate, come illustrato di seguito:Update the AppDelegate class to implement the IAuthenticate interface, as follows:

     public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate, IAuthenticate
    
  5. Aggiornare la classe AppDelegate aggiungendo un campo MobileServiceUser e un metodo Authenticate, necessario per l'interfaccia IAuthenticate, come illustrato di seguito:Update the AppDelegate class by adding a MobileServiceUser field and an Authenticate method, which is required by the IAuthenticate interface, as follows:

     // Define a authenticated user.
     private MobileServiceUser user;
    
     public async Task<bool> Authenticate()
     {
         var success = false;
         var message = string.Empty;
         try
         {
             // Sign in with Facebook login using a server-managed flow.
             if (user == null)
             {
                 user = await TodoItemManager.DefaultManager.CurrentClient
                     .LoginAsync(UIApplication.SharedApplication.KeyWindow.RootViewController,
                     MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
                 if (user != null)
                 {
                     message = string.Format("You are now signed-in as {0}.", user.UserId);
                     success = true;
                 }
             }
         }
         catch (Exception ex)
         {
            message = ex.Message;
         }
    
         // Display the success or failure message.
         UIAlertView avAlert = new UIAlertView("Sign-in result", message, null, "OK", null);
         avAlert.Show();
    
         return success;
     }
    

    Se si usa un provider di identità diverso da Facebook, scegliere un valore diverso per [MobileServiceAuthenticationProvider].If you are using an identity provider other than Facebook, choose a different value for [MobileServiceAuthenticationProvider].

  6. Aggiornare la classe AppDelegate aggiungendo l'overload del metodo OpenUrl, come indicato di seguito:Update the AppDelegate class by adding the OpenUrl method overload, as follows:

     public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
     {
         return TodoItemManager.DefaultManager.CurrentClient.ResumeWithURL(url);
     }
    
  7. Aggiungere la riga di codice seguente al metodo FinishedLaunching prima della chiamata a LoadApplication():Add the following line of code to the FinishedLaunching method before the call to LoadApplication():

     App.Init(this);
    

    Questo codice fa in modo che l'autenticatore venga inizializzato prima del caricamento dell'app.This code ensures the authenticator is initialized before the app is loaded.

  8. Aprire Info.plist e aggiungere un valore in Tipo di URL.Open Info.plist and add a URL Type. Immettere il nome desiderato nel campo Identificatore, impostare Schemi URL sullo schema URL dell'app in uso e impostare Ruolo su Nessuno.Set the Identifier to a name of your choosing, the URL Schemes to the URL scheme for your app, and the Role to None.

  9. Ricompilare l'app, eseguirla, quindi accedere con il provider di autenticazione selezionato e verificare se è possibile accedere ai dati come utente autenticato.Rebuild the app, run it, then sign in with the authentication provider you chose and verify you are able to access data as an authenticated user.

Aggiungere l'autenticazione a progetti di app Windows 10 (Windows Phone incluso)Add authentication to Windows 10 (including Phone) app projects

Questa sezione illustra come implementare l'interfaccia IAuthenticate nei progetti di app Windows 10.This section shows how to implement the IAuthenticate interface in the Windows 10 app projects. La stessa procedura si applica ai progetti piattaforma UWP (Universal Windows Platform), ma usando il progetto UWP con le modifiche indicate.The same steps apply for Universal Windows Platform (UWP) projects, but using the UWP project (with noted changes). Se i dispositivi Windows non sono supportati, ignorare questa sezione.Skip this section if you are not supporting Windows devices.

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto UWP e quindi scegliere Imposta come progetto di avvio.In Visual Studio, right-click the UWP project, then Set as StartUp Project.
  2. Premere F5 per avviare il progetto nel debugger, quindi verificare che venga generata un'eccezione non gestita con codice di stato 401 (Non autorizzato) dopo l'avvio dell'app.Press F5 to start the project in the debugger, then verify that an unhandled exception with a status code of 401 (Unauthorized) is raised after the app starts. La risposta 401 viene generata perché l'accesso al back-end è limitato solo agli utenti autorizzati.The 401 response happens because access on the backend is restricted to authorized users only.
  3. Aprire il file MainPage.xaml.cs per il progetto di app Windows, quindi aggiungere le istruzioni using seguenti:Open MainPage.xaml.cs for the Windows app project and add the following using statements:

     using Microsoft.WindowsAzure.MobileServices;
     using System.Threading.Tasks;
     using Windows.UI.Popups;
     using <your_Portable_Class_Library_namespace>;
    

    Sostituire <your_Portable_Class_Library_namespace> con lo spazio dei nomi per la libreria di classi portabile.Replace <your_Portable_Class_Library_namespace> with the namespace for your portable class library.

  4. Aggiornare la classe MainPage per implementare l'interfaccia IAuthenticate, come illustrato di seguito:Update the MainPage class to implement the IAuthenticate interface, as follows:

     public sealed partial class MainPage : IAuthenticate
    
  5. Aggiornare la classe MainPage aggiungendo un campo MobileServiceUser e un metodo Authenticate, necessario per l'interfaccia IAuthenticate, come illustrato di seguito:Update the MainPage class by adding a MobileServiceUser field and an Authenticate method, which is required by the IAuthenticate interface, as follows:

     // Define a authenticated user.
     private MobileServiceUser user;
    
     public async Task<bool> Authenticate()
     {
         string message = string.Empty;
         var success = false;
    
         try
         {
             // Sign in with Facebook login using a server-managed flow.
             if (user == null)
             {
                 user = await TodoItemManager.DefaultManager.CurrentClient
                     .LoginAsync(MobileServiceAuthenticationProvider.Facebook, "{url_scheme_of_your_app}");
                 if (user != null)
                 {
                     success = true;
                     message = string.Format("You are now signed-in as {0}.", user.UserId);
                 }
             }
    
         }
         catch (Exception ex)
         {
             message = string.Format("Authentication Failed: {0}", ex.Message);
         }
    
         // Display the success or failure message.
         await new MessageDialog(message, "Sign-in result").ShowAsync();
    
         return success;
     }
    

    Se si usa un provider di identità diverso da Facebook, scegliere un valore diverso per MobileServiceAuthenticationProvider.If you are using an identity provider other than Facebook, choose a different value for MobileServiceAuthenticationProvider.

  6. Aggiungere la riga di codice seguente nel costruttore per la classe MainPage prima della chiamata a LoadApplication():Add the following line of code in the constructor for the MainPage class before the call to LoadApplication():

     // Initialize the authenticator before loading the app.
     <your_Portable_Class_Library_namespace>.App.Init(this);
    

    Sostituire <your_Portable_Class_Library_namespace> con lo spazio dei nomi per la libreria di classi portabile.Replace <your_Portable_Class_Library_namespace> with the namespace for your portable class library.

  7. Se si usa UWP, aggiungere l'override del metodo OnActivated seguente alla classe App:If you are using UWP, add the following OnActivated method override to the App class:

    protected override void OnActivated(IActivatedEventArgs args)
    {
        base.OnActivated(args);
    
         if (args.Kind == ActivationKind.Protocol)
         {
             ProtocolActivatedEventArgs protocolArgs = args as ProtocolActivatedEventArgs;
             TodoItemManager.DefaultManager.CurrentClient.ResumeWithURL(protocolArgs.Uri);
         }
    }
    
  8. Aprire Package.appxmanifest e aggiungere una dichiarazione per Protocol.Open Package.appxmanifest and add a Protocol declaration. Impostare DisplayName sul nome desiderato e Name sullo schema URL per l'app.Set the Display name to a name of your choosing, and the Name to the URL scheme for you app.

  9. Ricompilare l'app, eseguirla, quindi accedere con il provider di autenticazione selezionato e verificare se è possibile accedere ai dati come utente autenticato.Rebuild the app, run it, then sign in with the authentication provider you chose and verify you are able to access data as an authenticated user.

Passaggi successiviNext steps

Dopo aver completato questa esercitazione sull'autenticazione di base, provare a continuare fino a una delle esercitazioni seguenti:Now that you completed this basic authentication tutorial, consider continuing on to one of the following tutorials:

  • Aggiungere notifiche push all'app Xamarin.FormsAdd push notifications to your app

    : informazioni su come aggiungere il supporto per le notifiche push all'app e configurare il back-end dell'app per dispositivi mobili per usare Hub di notifica di Azure per l'invio di notifiche push.Learn how to add push notifications support to your app and configure your Mobile App backend to use Azure Notification Hubs to send push notifications.

  • Abilitare la sincronizzazione offline per l'app per dispositivi mobili Xamarin.FormsEnable offline sync for your app

    Informazioni su come aggiungere il supporto offline all'app usando il back-end di un'app per dispositivi mobili.Learn how to add offline support your app using a Mobile App backend. La sincronizzazione offline consente agli utenti finali di interagire con un'app, visualizzando, aggiungendo e modificando i dati, anche se non è disponibile una connessione di rete.Offline sync allows end users to interact with a mobile app - viewing, adding, or modifying data - even when there is no network connection.