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

PanoramicaOverview

Questa esercitazione descrive la funzionalità di sincronizzazione offline di App per dispositivi mobili di Azure per Xamarin.iOS.This tutorial introduces the offline sync feature of Azure Mobile Apps for Xamarin.iOS. 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 app Xamarin.iOS dell'esercitazione Creare un'app Xamarin iOS per supportare le funzionalità offline delle app per dispositivi mobili di Azure.In this tutorial, update the Xamarin.iOS app project from [Create a Xamarin iOS 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, initialize a SyncContext to a local store. Fare riferimento alla tabella tramite l'interfaccia di [IMobileServiceSyncTable].Reference your table through the [IMobileServiceSyncTable] interface. SQLite viene usato come archivio locale nel dispositivo.SQLite is used as the local store on the device.

  1. Aprire Gestione pacchetti NuGet nel progetto completato nell'esercitazione Creare un'app Xamarin iOS, quindi cercare e installare il pacchetto NuGet Microsoft.Azure.Mobile.Client.SQLiteStore.Open the NuGet package manager in the project that you completed in the [Create a Xamarin iOS app] tutorial, then search for and install the Microsoft.Azure.Mobile.Client.SQLiteStore NuGet package.
  2. Aprire il file QSTodoService.cs e rimuovere i simboli di commento dalla definizione #define OFFLINE_SYNC_ENABLED.Open the QSTodoService.cs file and uncomment the #define OFFLINE_SYNC_ENABLED definition.
  3. Ricompilare ed eseguire l'app client.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 verranno aggiunti all'archivio locale che verranno sincronizzati con il back-end dell'app per dispositivi mobili la prima volta che verrà eseguita un'operazione di push in presenza di uno stato di connessione.In this state, new items added in the local store and will be synced to the mobile app backend when push is next run in a connected state.

  1. Modificare il file QSToDoService.cs nel progetto condiviso.Edit QSToDoService.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. Compilare ed eseguire l'app.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) Se Visual Studio è installato in un computer, aprire Esplora server.(Optional) If you have Visual Studio installed on a PC, 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. Viene simulato il passaggio dell'app dallo stato offline allo stato online con il back-end dell'app per dispositivi mobili.This simulates the app moving from an offline state to an online state with the mobile app backend. Se l'interruzione della rete è stata simulata disattivando la connettività di rete, non sono necessarie modifiche al codice.If you simulated the network breakage by turning off network connectivity, no code changes are needed. Riattivare la rete.Turn the network on again. Alla prima esecuzione dell'applicazione viene chiamato il metodo RefreshDataAsync,When you first run the application, the RefreshDataAsync method is called. che sua volta chiama SyncAsync per sincronizzare l'archivio locale con il database back-end.This in turn calls SyncAsync to sync your local store with the backend database.

  1. Aprire il file QSToDoService.cs nel progetto condiviso e annullare la modifica della proprietà applicationURL.Open QSToDoService.cs in the shared project, and revert your change of the applicationURL property.
  2. Ricompilare ed eseguire l'app.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.

    CompleteItemAsync chiama SyncAsync per sincronizzare ogni elemento completato con il back-end dell'app per dispositivi mobili.CompleteItemAsync 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 un'operazione pull in una tabella in cui il client ha apportato modifiche, viene sempre eseguita prima un'operazione push automatica nel contesto di sincronizzazione del client.Whenever you execute a pull against a table that the client has made changes to, a push on the client sync context is always executed first automatically. Il push implicito assicura che tutte le tabelle nell'archivio locale e le relazioni restino coerenti.The implicit push ensures all tables in the local store along with relationships remain consistent. 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 Xamarin iOS 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 iOS 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 QSTodoListViewController.ViewDidLoad() esegue QSTodoService.InitializeStoreAsync().The local store database is initialized when QSTodoListViewController.ViewDidLoad() executes QSTodoService.InitializeStoreAsync(). Questo metodo comporta la creazione di un nuovo database SQLite locale usando la classe MobileServiceSQLiteStore fornita dall'SDK del client dell'app per dispositivi mobili di Azure.This method creates a new local SQLite database using the MobileServiceSQLiteStore class provided by the Azure Mobile App 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.

      // QSTodoService.cs
    
      public async Task InitializeStoreAsync()
      {
          var store = new MobileServiceSQLiteStore(localDbPath);
          store.DefineTable<ToDoItem>();
    
          // Uses the default conflict handler, which fails on conflict
          await client.SyncContext.InitializeAsync(store);
      }
    
  • Il membro todoTable di QSTodoService è di tipo IMobileServiceSyncTable invece che IMobileServiceTable.The todoTable member of QSTodoService 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 those 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 QSTodoService.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 QSTodoService.SyncAsync() to sync whenever the todoitem list is refreshed or a todoitem is added or completed. L'app viene sincronizzata dopo ogni modifica locale.The app syncs after every local change. Se viene effettuato il pull in una tabella con aggiornamenti locali in sospeso rilevati dal contesto, tale operazione attiva prima di tutto automaticamente un'operazione push nel contesto.If a pull is executed against a table that has pending local updates tracked by the context, that pull operation will automatically trigger a context push first.

    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].

      // QSTodoService.cs
      public async Task SyncAsync()
      {
          try
          {
              await client.SyncContext.PushAsync();
              await todoTable.PullAsync("allTodoItems", todoTable.CreateQuery()); // query ID is used for incremental sync
          }
    
          catch (MobileServiceInvalidOperationException e)
          {
              Console.Error.WriteLine(@"Sync Failed: {0}", e.Message);
          }
      }
    

Risorse aggiuntiveAdditional Resources