Abilitare la sincronizzazione offline per l'app per dispositivi mobili Xamarin.AndroidEnable offline sync for your Xamarin.Android mobile app

PanoramicaOverview

Questa esercitazione descrive la funzionalità di sincronizzazione offline di App per dispositivi mobili di Azure per Xamarin.Android.This tutorial introduces the offline sync feature of Azure Mobile Apps for Xamarin.Android. 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. Le modifiche vengono archiviate in un database locale.Changes are stored in a local database. Quando il dispositivo torna online, vengono sincronizzate con il servizio remoto.Once the device is back online, these changes are synced with the remote service.

In questa esercitazione viene aggiornato il progetto client creato nell'esercitazione Creare un'app per Xamarin.Android per supportare le funzionalità offline di App per dispositivi mobili di Azure.In this tutorial, you update the client project from the tutorial [Create a Xamarin Android app] to support the offline features of Azure Mobile Apps. Se non si usa il progetto server di avvio rapido scaricato, è necessario aggiungere al progetto il pacchetto di estensione per l'accesso ai dati.If you do not use the downloaded quick start server project, you must add the data access extension packages to your project. Per altre informazioni sui pacchetti di estensione server, vedere l'articolo relativo all' utilizzo dell'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.

Per altre informazioni sulla funzionalità di sincronizzazione offline, vedere l'argomento Sincronizzazione di dati offline nelle app per dispositivi mobili di Azure.To learn more about the offline sync feature, see the topic [Offline Data Sync in Azure Mobile Apps].

Aggiornare l'app client per supportare le funzionalità offlineUpdate the client app to support offline features

Le funzionalità offline delle app per dispositivi mobili di Azure consentono di interagire con un database locale in uno scenario offline.Azure Mobile App offline features allow you to interact with a local database when you are in an offline scenario. Per usare queste funzionalità nell'app, inizializzare SyncContext in un archivio locale.To use these features in your app, you initialize a SyncContext to a local store. Quindi, fare riferimento alla tabella tramite l'interfaccia di [IMobileServiceSyncTable][IMobileServiceSyncTable].Then reference your table through the [IMobileServiceSyncTable][IMobileServiceSyncTable] interface. SQLite viene usato come archivio locale nel dispositivo.SQLite is used as the local store on the device.

  1. In Visual Studio aprire Gestione pacchetti NuGet nel progetto completato nell'esercitazione Creare un'app per Xamarin.Android.In Visual Studio, open the NuGet package manager in the project that you completed in the [Create a Xamarin Android app] tutorial. Cercare e installare il pacchetto NuGet Microsoft.Azure.Mobile.Client.SQLiteStore.Search for and install the Microsoft.Azure.Mobile.Client.SQLiteStore NuGet package.
  2. Aprire il file ToDoActivity.cs e rimuovere i simboli di commendo dalla definizione #define OFFLINE_SYNC_ENABLED.Open the ToDoActivity.cs file and uncomment the #define OFFLINE_SYNC_ENABLED definition.
  3. In Visual Studio premere F5 per ricompilare ed eseguire l'app client.In Visual Studio, press the F5 key to rebuild and run the client app. L'app funziona esattamente come prima di attivare la sincronizzazione offline. Tuttavia, il database locale è ora popolato con dati che possono essere usati in uno scenario offline.The app works the same as it did before you enabled offline sync. However, the local database is now populated with data that can be used in an offline scenario.

Aggiornare l'app per disconnetterla dal back-endUpdate the app to disconnect from the backend

In questa sezione verrà interrotta la connessione al back-end dell'app per dispositivi mobili per simulare una situazione offline.In this section, you break the connection to your Mobile App backend to simulate an offline situation. Quando si aggiungono elementi di dati, il gestore di eccezioni informa che l'app è in modalità offline.When you add data items, your exception handler tells you that the app is in offline mode. In questo stato, nuovi elementi vengono aggiunti all'archivio locale e vengono sincronizzati con il back-end dell'app per dispositivi mobili la prima volta che viene eseguita un'operazione di push in presenza di uno stato di connessione.In this state, new items added in the local store and are synced to the mobile app backend when a push is executed in a connected state.

  1. Modificare il file ToDoActivity.cs nel progetto condiviso.Edit ToDoActivity.cs in the shared project. Modificare il valore applicationURL in modo che faccia riferimento a un URL non valido:Change the applicationURL to point to an invalid URL:

      const string applicationURL = @"https://your-service.azurewebsites.fail";
    

    È anche possibile illustrare il comportamento offline disabilitando le reti Wi-Fi e cellulare sul dispositivo o impostando la modalità aereo.You can also demonstrate offline behavior by disabling wifi and cellular networks on the device or using airplane mode.

  2. Premere F5 per compilare ed eseguire l'app.Press F5 to build and run the app. Si noti l'errore di sincronizzazione al momento dell'aggiornamento quando l'app viene avviata.Notice your sync failed on refresh when the app launched.
  3. Immettere nuovi elementi. Si noti che il push ha esito negativo con stato [CancelledByNetworkError] ogni volta che si fa clic su Salva.Enter new items and notice that push fails with a [CancelledByNetworkError] status each time you click Save. I nuovi elementi todo, tuttavia, sono presenti nell'archivio locale fino a quando non è possibile effettuarne il push al back-end dell'app per dispositivi mobili.However, the new todo items exist in the local store until they can be pushed to the mobile app backend. In un'app di produzione, se si eliminano queste eccezioni, l'app client si comporta come se fosse ancora connessa al back-end dell'app per dispositivi mobili.In a production app, if you suppress these exceptions the client app behaves as if it's still connected to the mobile app backend.
  4. Chiudere l'app e riavviarla per verificare che i nuovi elementi creati siano salvati in modo permanente nell'archivio locale.Close the app and restart it to verify that the new items you created are persisted to the local store.
  5. (Facoltativo) In Visual Studio aprire Esplora server.(Optional) In Visual Studio, open Server Explorer. Passare al database in Azure->Database SQL.Navigate to your database in Azure->SQL Databases. Fare clic con il pulsante destro del mouse sul database e scegliere Apri in Esplora oggetti di SQL Server.Right-click your database and select Open in SQL Server Object Explorer. È ora possibile passare alla tabella di database SQL e al relativo contenuto.Now you can browse to your SQL database table and its contents. Verificare che i dati nel database back-end non siano stati modificati.Verify that the data in the backend database has not changed.
  6. (Facoltativo) Usare uno strumento REST come Fiddler o Postman per eseguire una query sul back-end mobile, usando una query GET nel formato https://<your-mobile-app-backend-name>.azurewebsites.net/tables/TodoItem.(Optional) Use a REST tool such as Fiddler or Postman to query your mobile backend, using a GET query in the form https://<your-mobile-app-backend-name>.azurewebsites.net/tables/TodoItem.

Aggiornare l'app per la riconnessione al back-end dell'app per dispositivi mobiliUpdate the app to reconnect your Mobile App backend

In questa sezione viene effettuata la riconnessione dell'app al back-end dell'app per dispositivi mobili.In this section, reconnect the app to the mobile app backend. Alla prima esecuzione dell'applicazione, il gestore eventi OnCreate chiama OnRefreshItemsSelected.When you first run the application, the OnCreate event handler calls OnRefreshItemsSelected. Questo metodo chiama SyncAsync per sincronizzare l'archivio locale con il database back-end.This method calls SyncAsync to sync your local store with the backend database.

  1. Aprire il file ToDoActivity.cs nel progetto condiviso e annullare la modifica della proprietà applicationURL.Open ToDoActivity.cs in the shared project, and revert your change of the applicationURL property.
  2. Premere F5 per ricompilare ed eseguire l'app.Press the F5 key to rebuild and run the app. L'app sincronizza le modifiche locali con il back-end dell'app per dispositivi mobili di Azure usando operazioni push e pull quando viene eseguito il metodo OnRefreshItemsSelected.The app syncs your local changes with the Azure Mobile App backend using push and pull operations when the OnRefreshItemsSelected method executes.
  3. (Facoltativo) Visualizzare i dati aggiornati usando Esplora oggetti di SQL Server o uno strumento REST come Fiddler.(Optional) View the updated data using either SQL Server Object Explorer or a REST tool like Fiddler. Si noti che i dati sono stati sincronizzati tra il database back-end dell'app per dispositivi mobili di Azure e l'archivio locale.Notice the data has been synchronized between the Azure Mobile App backend database and the local store.
  4. Nell'app fare clic sulla casella di controllo accanto ad alcuni elementi da completare nell'archivio locale.In the app, click the check box beside a few items to complete them in the local store.

    CheckItem chiama SyncAsync per sincronizzare ogni elemento completato con il back-end dell'app per dispositivi mobili.CheckItem calls SyncAsync to sync each completed item with the Mobile App backend. SyncAsync chiama operazioni sia push che pull.SyncAsync calls both push and pull. Ogni volta che si esegue il pull su una tabella a cui il client ha apportato modifiche, viene sempre effettuato automaticamente il push.Whenever you execute a pull against a table that the client has made changes to, a push is always executed automatically. Ciò assicura che tutte le tabelle nell'archivio locale e le relazioni restino coerentiThis ensures all tables in the local store along with relationships remain consistent. e può determinare un'operazione push non prevista.This behavior may result in an unexpected push. Per altre informazioni su questo comportamento, vedere Sincronizzazione di dati offline nelle app per dispositivi mobili di Azure.For more information on this behavior, see [Offline Data Sync in Azure Mobile Apps].

Verificare il codice di sincronizzazione del clientReview the client sync code

Il progetto client Xamarin scaricato dopo aver completato l'esercitazione Creare un'app per Xamarin.Android contiene già il codice che supporta la sincronizzazione offline mediante un database SQLite locale.The Xamarin client project that you downloaded when you completed the tutorial [Create a Xamarin Android app] already contains code supporting offline synchronization using a local SQLite database. Ecco un breve riepilogo degli elementi già inclusi nel codice dell'esercitazione.Here is a brief overview of what is already included in the tutorial code. Per una panoramica concettuale della funzionalità, vedere Sincronizzazione di dati offline nelle app per dispositivi mobili di Azure.For a conceptual overview of the feature, see [Offline Data Sync in Azure Mobile Apps].

  • Prima di poter eseguire qualsiasi operazione su tabella, è necessario inizializzare l'archivio locale.Before any table operations can be performed, the local store must be initialized. Il database di archiviazione locale viene inizializzato quando ToDoActivity.OnCreate() esegue ToDoActivity.InitLocalStoreAsync().The local store database is initialized when ToDoActivity.OnCreate() executes ToDoActivity.InitLocalStoreAsync(). Questo metodo comporta la creazione di un database SQLite locale usando la classe MobileServiceSQLiteStore fornita dall'SDK del client delle app per dispositivi mobili di Azure.This method creates a local SQLite database using the MobileServiceSQLiteStore class provided by the Azure Mobile Apps client SDK.

    Il metodo DefineTable crea nell'archivio locale una tabella corrispondente ai campi del tipo specificato, ToDoItem in questo caso.The DefineTable method creates a table in the local store that matches the fields in the provided type, ToDoItem in this case. Il tipo non deve necessariamente includere tutte le colonne presenti nel database remoto.The type doesn't have to include all the columns that are in the remote database. È possibile archiviare solo un subset di colonne.It is possible to store just a subset of columns.

      // ToDoActivity.cs
      private async Task InitLocalStoreAsync()
      {
          // new code to initialize the SQLite store
          string path = Path.Combine(System.Environment
              .GetFolderPath(System.Environment.SpecialFolder.Personal), localDbFilename);
    
          if (!File.Exists(path))
          {
              File.Create(path).Dispose();
          }
    
          var store = new MobileServiceSQLiteStore(path);
          store.DefineTable<ToDoItem>();
    
          // Uses the default conflict handler, which fails on conflict
          // To use a different conflict handler, pass a parameter to InitializeAsync.
          // For more details, see http://go.microsoft.com/fwlink/?LinkId=521416.
          await client.SyncContext.InitializeAsync(store);
      }
    
  • Il membro toDoTable di ToDoActivity è di tipo IMobileServiceSyncTable invece che IMobileServiceTable.The toDoTable member of ToDoActivity is of the IMobileServiceSyncTable type instead of IMobileServiceTable. IMobileServiceSyncTable indirizza tutte le operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD, Create, Read, Update, Delete) sulle tabelle al database di archiviazione locale.The IMobileServiceSyncTable directs all create, read, update, and delete (CRUD) table operations to the local store database.

    Decidere quando viene eseguito il push delle modifiche al back-end delle app per dispositivi mobili di Azure chiamando IMobileServiceSyncContext.PushAsync().You decide when changes are pushed to the Azure Mobile App backend by calling IMobileServiceSyncContext.PushAsync(). Il contesto di sincronizzazione aiuta a mantenere le relazioni tra tabelle rilevando le modifiche apportate da un'app client in tutte le tabelle ed eseguendone il push quando viene chiamato PushAsync .The sync context helps preserve table relationships by tracking and pushing changes in all tables a client app has modified when PushAsync is called.

    Il codice fornito chiama ToDoActivity.SyncAsync() per eseguire la sincronizzazione ogni volta che l'elenco todoitem viene aggiornato o un oggetto todoitem viene aggiunto o completato.The provided code calls ToDoActivity.SyncAsync() to sync whenever the todoitem list is refreshed or a todoitem is added or completed. Il codice viene sincronizzato dopo ogni modifica locale.The code syncs after every local change.

    Nel codice fornito viene eseguita una query su tutti i record presenti nella tabella TodoItem remota, ma è anche possibile filtrare i record passando un ID di query e una query a PushAsync.In the provided code, all records in the remote TodoItem table are queried, but it is also possible to filter records by passing a query id and query to PushAsync. Per altre informazioni, vedere la sezione Sincronizzazione incrementale in Sincronizzazione di dati offline nelle app per dispositivi mobili di Azure.For more information, see the section Incremental Sync in [Offline Data Sync in Azure Mobile Apps].

      // ToDoActivity.cs
      private async Task SyncAsync()
      {
          try {
              await client.SyncContext.PushAsync();
              await toDoTable.PullAsync("allTodoItems", toDoTable.CreateQuery()); // query ID is used for incremental sync
          } catch (Java.Net.MalformedURLException) {
              CreateAndShowDialog (new Exception ("There was an error creating the Mobile Service. Verify the URL"), "Error");
          } catch (Exception e) {
              CreateAndShowDialog (e, "Error");
          }
      }
    

Risorse aggiuntiveAdditional Resources