Managing State: Collections and Variables

Understanding Variables in Power Apps

Variables are containers for storing information. In Power Apps, we primarily work with two types: global variables and context variables. The key difference between them is their scope.

To get a practical, hands-on introduction, we'll start with a video that clearly explains the differences, syntax, and common use cases for each.

Global Variables (Set)

As you saw in the video, global variables are created using the Set function and are available throughout your entire app.

• Syntax: Set(VariableName, Value)
• Scope: App-wide. Accessible from any screen.
• Common Uses:
  • Storing user information after login (e.g., Set(gblCurrentUser, User())).
  • App-wide settings, like a theme or user preferences.
  • Storing a record retrieved from a data source that needs to be referenced on multiple screens.

While powerful, overusing global variables can make your app difficult to debug and can negatively impact performance by cluttering memory. A good rule of thumb is to ask: "Does this data truly need to be accessible everywhere?" If not, a context variable is likely a better choice.

Context Variables (UpdateContext)

Context variables are scoped to a single screen, making them ideal for managing temporary state within that screen.

• Syntax: UpdateContext({VariableName: Value, VariableName2: Value2})
  • Note the curly braces {}. UpdateContext accepts a record, allowing you to set or update multiple context variables on that screen at once.
• Scope: Local to the screen where they are defined. They are automatically cleared when the user navigates away from the screen.

• Common Uses:
  • Toggling the visibility of a popup, panel, or loading spinner (UpdateContext({showPopup: true})).
  • Storing temporary user input on a form before it's processed.
  • Managing the state of controls on a specific screen.

You can also pass data to a destination screen during navigation, which creates context variables on that screen. This is the preferred method for passing data between screens, as it avoids creating unnecessary global variables.

// On Screen1, navigate to Screen2 and pass a record ID as a context variable
Navigate(Screen2, ScreenTransition.None, {selectedRecordId: 123})

// On Screen2, 'selectedRecordId' is now available as a context variable.

Managing Tabular Data with Collections

While variables are great for single values (text, numbers, booleans, records), collections are used to store tables of data in memory. They are essential for caching data to improve performance and for staging data before writing it to a data source.

The core functions for managing collections are:

• Collect(CollectionName, Item): Adds a record to a collection. If the collection doesn't exist, it is created.
• Clear(CollectionName): Removes all records from a collection, leaving it empty.
• ClearCollect(CollectionName, Items): Clears all existing records and then adds a new set of records. This is very common for refreshing a local cache of data.

Let's watch a video that demonstrates these functions and their most important use cases.

Key Use Cases for Collections

1. Staging Data (Shopping Cart Pattern):
   Imagine an expense report app where a user adds multiple line items before submitting the whole report. Each line item can be added to a colExpenseItems collection. When the user clicks "Submit," you can then use the ForAll and Patch functions to write every record from the collection to your data source at once. We'll cover this bulk update pattern in our next lesson.

   // On 'Add Item' button click
   Collect(
       colExpenseItems,
       {
           ItemName: txtItemName.Text,
           Cost: Value(txtCost.Text),
           Date: dpDate.SelectedDate
       }
   )
   

2. Caching Data for Performance:
   If you have a small-to-medium sized list of data that doesn't change often (e.g., a list of departments, categories, or statuses), it's much more efficient to load it into a collection once when the app starts.

   App.OnStart property:

   // Load all records from the 'Departments' table into a collection
   ClearCollect(colDepartments, Departments)
   

   Now, any time you need to look up a department name in your app, you can reference the colDepartments collection instead of making a new call to the data source. This makes your app feel much faster, as in-memory operations are nearly instantaneous compared to network requests.

   Warning: ClearCollect is not delegable. This means it can only retrieve up to the data row limit for non-delegable queries (default is 500, max is 2,000). This pattern is not suitable for large data sources.

A Modern Alternative: Named Formulas

Recently, Microsoft introduced Named Formulas, a powerful alternative to using global variables for values that should not change during the app session. They are defined once in the App.Formulas property and behave like declarative constants or expressions that automatically recalculate if their dependencies change.

From a developer's perspective, they offer several advantages over setting global variables in App.OnStart.

Key advantages include:

• Always available: No timing dependency on App.OnStart to run first.
• Always up-to-date: Automatically recalculates when dependencies change.
• Immutable: The definition is the single source of truth and cannot be changed by other code, preventing bugs.
• Improved App Load Time: Their calculation can be deferred until the value is actually needed, which can speed up your app's initial load.

Example: Instead of Set(gblUserEmail, User().Email) in App.OnStart, you define this in App.Formulas:
UserEmail = User().Email;

Now, UserEmail is available throughout the app just like a global variable, but with the added benefits of being declarative and optimized.

Conclusion

You have now learned the essential techniques for managing temporary data and state within your Canvas Apps. This is a fundamental skill that separates simple apps from sophisticated, high-performance applications.

Key Takeaways:

• Use context variables (UpdateContext) for temporary, screen-specific state like UI visibility.
• Use global variables (Set) sparingly for truly app-wide information like user settings.
• Use collections (Collect, ClearCollect, Clear) to manage in-memory tables of data, perfect for caching and staging.
• Consider Named Formulas as a modern, declarative, and performant alternative to global variables for static or derived values.

Up Next:
Now that you know how to build a collection of records (like the "shopping cart" or "order items" examples), the next logical step is to save that entire collection to your data source. In our next lesson, "Implement bulk data operations by combining the ForAll and Patch functions," we will do exactly that, exploring one of the most powerful and efficient data-writing patterns in Power Apps.