/maui-shell-navigation

name: maui-shell-navigation
description: >-
  Guide for implementing Shell-based navigation in .NET MAUI apps. Covers AppShell
  setup, visual hierarchy (FlyoutItem, TabBar, Tab, ShellContent), URI-based navigation
  with GoToAsync, route registration, query parameters, back navigation, flyout and
  tab configuration, navigation events, and navigation guards.
  Use when: setting up Shell navigation, adding tabs or flyout menus, navigating between
  pages with GoToAsync, passing parameters between pages, registering routes, customizing
  back button behavior, or guarding navigation with confirmation dialogs.
  Do not use for: deep linking from external URLs (see .NET MAUI deep linking
  documentation), data binding on pages (use maui-data-binding), dependency injection
  setup (use maui-dependency-injection), or NavigationPage-only apps that don't use Shell.
license: MIT

.NET MAUI Shell Navigation

Implement page navigation in .NET MAUI apps using Shell. Shell provides URI-based navigation, a flyout menu, tab bars, and a four-level visual hierarchy — all configured declaratively in XAML.

When to Use

• Setting up top-level app navigation with tabs or a flyout menu
• Navigating between pages programmatically with `GoToAsync`
• Passing data between pages via query parameters or object parameters
• Registering detail-page routes for push navigation
• Guarding navigation with confirmation dialogs (e.g., unsaved changes)
• Customizing back button behavior per page

When Not to Use

• Deep linking from external URLs or app links — see [.NET MAUI deep linking docs](https://learn.microsoft.com/dotnet/maui/fundamentals/app-links)
• Data binding on navigation target pages — use `maui-data-binding`
• Dependency injection for pages and view models — use `maui-dependency-injection`
• Apps using `NavigationPage` without Shell (different navigation API)

Inputs

• A .NET MAUI project with `AppShell.xaml` as the root shell
• Pages (`ContentPage`) to navigate between
• Route names for detail pages not in the visual hierarchy

Rules That Change the Answer

These are the Shell-specific decisions that are easy to get wrong. Apply them whenever they are relevant to what the user asked.

| Situation | Do this | Not this | |---|---|---| | Declaring pages in `AppShell.xaml` | With `xmlns:views="clr-namespace:MyApp.Views"` declared: `<ShellContent ContentTemplate="{DataTemplate views:MyPage}" />` — the page is created on first navigation | `<ShellContent><views:MyPage /></ShellContent>`, which constructs **every** page at startup | | Navigating to a page not in the visual hierarchy | `Routing.RegisterRoute("details", typeof(DetailsPage))` first | Calling `GoToAsync("details")` unregistered — it throws at runtime | | Receiving navigation parameters | Implement `IQueryAttributable` on the **ViewModel** | Implementing it on the Page, which splits state from the BindingContext | | Passing a whole object | `ShellNavigationQueryParameters` | Serialising the object into the query string | | Any `GoToAsync` call | `await` it | Fire-and-forget — exceptions are swallowed and navigation races | | Confirming before back navigation | `ShellNavigatingEventArgs.GetDeferral()` … `deferral.Complete()` | Blocking synchronously on the dialog task | | Detecting back navigation | Check `e.Source == ShellNavigationSource.Pop` | Assuming every navigation is a back action |

**Do not** propose `NavigationPage` / `PushAsync` solutions for a Shell app, and do not restructure a working `AppShell` hierarchy unless the user asked.

**Answer narrowly, but completely.** Staying on topic does not mean being terse. When you show a navigation change, include the pieces needed to run it: the `AppShell.xaml` markup *and* the `Routing.RegisterRoute` call, or the `GoToAsync` call *and* the receiving `IQueryAttributable` / `[QueryProperty]` code. Where two approaches are both valid (query string vs `ShellNavigationQueryParameters`), show both and say when each fits — a single snippet the user still has to complete is a worse answer.

Shell Visual Hierarchy

Shell uses a four-level hierarchy. Each level wraps the one below it:

Shell
 ├── FlyoutItem / TabBar          (top-level grouping)
 │    ├── Tab                     (bottom-tab grouping)
 │    │    ├── ShellContent        (page slot → ContentPage)
 │    │    └── ShellContent        (multiple = top tabs)
 │    └── Tab
 └── FlyoutItem / TabBar

• **FlyoutItem** — appears in the flyout menu; contains `Tab` children
• **TabBar** — bottom tab bar with no flyout entry
• **Tab** — groups `ShellContent`; multiple children produce top tabs
• **ShellContent** — each points to a `ContentPage`

Implicit Conversion

You can omit intermediate wrappers. Shell auto-wraps:

| You write | Shell creates | |------------------------------|---------------------------------------| | `ShellContent` only | `FlyoutItem > Tab > ShellContent` | | `Tab` only | `FlyoutItem > Tab` | | `ShellContent` in `TabBar` | `TabBar > Tab > ShellContent` |

Workflow: Set Up AppShell

1. Define `AppShell.xaml` inheriting from `Shell` 2. Add `FlyoutItem` or `TabBar` elements for top-level navigation 3. Add `Tab` elements for bottom tabs; nest multiple `ShellContent` for top tabs 4. **Always use `ContentTemplate`** with `DataTemplate` so pages load on demand 5. **Give every `ShellContent` an explicit `Route`** (see below) 6. Register detail-page routes in the `AppShell` constructor

> **Set `Route=` on every `ShellContent`.** If you omit it, MAUI auto-generates a > name from a shared counter — `Routing.cs` produces `D_FAULT_{TypeName}{n}`. A real > shell with three unnamed `ShellContent` elements yields routes like > `D_FAULT_ShellContent2` and `D_FAULT_ShellContent5`: the numbers are not > sequential, they depend on how many Shell elements were constructed first, and they > shift when you reorder or