Offline-Enabled Canvas Apps with Collections

1. The Core of Offline: Collections, SaveData, and LoadData

At the heart of Power Apps' offline functionality are three key elements:

• Collections: In-memory tables that store your data within the app. You can think of these as analogous to a List<T> in C# or an array of objects in JavaScript. All offline data is staged in collections.
• SaveData(CollectionName, "FileName"): This function takes a collection and saves it to a file in the local storage of the device running the app.
• LoadData(CollectionName, "FileName", [IgnoreNonexistentFile]): This function reads a local file and loads its contents back into a collection.

A crucial point for development and testing: these functions are designed for the Power Apps mobile player (on iOS/Android) and the Power Apps for Windows player. They do not work in the browser-based App Studio by default.

Let's watch a video that introduces these concepts and shows how to use the fundamental functions.

As Shane emphasizes, the most robust pattern is to always call SaveData immediately after any function that alters your local collection. This ensures that even if the app crashes a moment later, the user's changes are persisted to the device.

2. A Standard Implementation Pattern

Now that you understand the core functions, let's assemble them into a standard pattern for loading, saving, and displaying data based on network connectivity. The logic generally follows this flow:

1. On App Load: Check if the device is online using the Connection.Connected property.
   • If Online: Load fresh data from the data source (e.g., Dataverse) into a local collection. Then, use SaveData to create a local cache of this fresh data.
   • If Offline: Use LoadData to populate the collection from the local cache file.
2. Saving a Record: When a user submits a form:
   • If Online: Patch the data directly to the data source.
   • If Offline: Collect or Patch the data into a local collection, and then immediately use SaveData to update the local cache file.

The following video demonstrates this entire flow in a practical example.

3. The Synchronization Process

You've successfully saved data offline. The final piece of the puzzle is synchronizing it back to the server when the user is back online. This is typically handled with a manual "Sync" button that becomes active only when Connection.Connected is true.

The sync logic involves:

1. Iterating through the collection of offline records using the ForAll function.
2. Inside the loop, using Patch to send each record to the data source.
3. After the loop completes successfully, clearing the local data to prevent duplicate submissions. This involves Clear() on the collection and, ideally, ClearData("FileName") to remove the local file.

Let's see how this is implemented.

4. Professional Patterns for Robustness

The standard pattern is great for simple "create" scenarios. However, your background in enterprise development tells you that real-world apps need to handle creates, updates, and deletes, often in a multi-user environment. Here are two advanced patterns that provide greater robustness.

Pattern 1: Handling New Records with an OfflineID

When a user creates a new record offline, it doesn't have a primary key from your data source (e.g., the Dataverse GUID). To manage this, you can add a custom text column to your table (e.g., crXXX_OfflineID).

When creating a record:

• Use the GUID() function in Power Fx to generate a unique ID.
• Store this in your local collection and the crXXX_OfflineID column.
• When syncing, you can use the Coalesce function to handle both creates and updates in a single Patch statement. It attempts to LookUp the record by its primary key; if it fails (i.e., it's a new record), it uses Defaults() to create it.

This pattern is well-documented in the following tutorial.

Pattern 2: Tracking Individual Changes

A more sophisticated approach, especially for complex apps, is to maintain a separate collection that tracks only the changes. Instead of saving the entire dataset every time, you Collect a record into a dedicated OfflineChanges collection. Each item in this collection should include metadata about the operation.

This pattern provides a clean, explicit way to manage your data synchronization logic and is highly recommended for applications with complex offline requirements.

Conclusion

You have now learned the essential techniques for building resilient, offline-capable Canvas Apps. This is a non-negotiable skill for many enterprise mobile solutions and a key topic for the PL-400 exam.

Key Takeaways:

• The Core Trio: SaveData, LoadData, and Collections are the foundation of all offline functionality in Canvas Apps.
• Save Immediately: To prevent data loss from app crashes or closures, always use SaveData immediately after any operation that modifies a collection holding user data.
• Check Connectivity: Use Connection.Connected to determine whether to operate against the live data source or the local cache.
• Sync Manually: A user-initiated sync button provides the most reliable and transparent experience for pushing offline changes back to the server.
• Use Robust Patterns: For production apps, adopt advanced patterns like using a temporary OfflineID for new records and tracking individual changes in a dedicated queue for reliable C/U/D (Create/Update/Delete) operations.

Up Next:

In the next lesson, we will explore another powerful integration technique: integrating Canvas Apps within Model-driven Apps using embedding and context passing. You'll learn how to combine the rich, flexible UI of a Canvas App with the structured, data-driven forms of a Model-driven App.