.Net Maui Page Types Tabbedpage Flyoutpage Complete Guide

 Last Update:2025-06-23T00:00:00     .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION.    8 mins read      Difficulty-Level: beginner

Understanding the Core Concepts of .NET MAUI Page Types TabbedPage, FlyoutPage

.NET MAUI Page Types: TabbedPage and FlyoutPage

Introduction

TabbedPage

Overview TabbedPage is a container page that consists of multiple child pages, each accessible through a tab. This layout is ideal for applications where users need to switch between several distinct functionalities or views easily. TabbedPage typically provides a simple and straightforward way to organize content and is especially useful for scenarios like settings, profiles, and different features within the app.

Key Features

  • Tabs: Each child page in a TabbedPage gets represented by a tab. Users can switch between tabs to view different content.
  • Icons: Tabs can include icons alongside labels, which can help users identify each tab more easily.
  • Automatic Segmented Control: On iOS, TabbedPage uses a segmented control for tabs, providing an intuitive and visually appealing navigation experience.
  • Custom Tabbed Renderers: You can customize the appearance and behavior of tabs for each platform to better match the native design guidelines.

Usage Example

public class MainPage : TabbedPage
{
    public MainPage()
    {
        var homePage = new ContentPage
        {
            Title = "Home",
            IconImageSource = "home.png",
            Content = new StackLayout
            {
                Children =
                {
                    new Label
                    {
                        Text = "Welcome to the Home Page!"
                    }
                }
            }
        };

        var settingsPage = new ContentPage
        {
            Title = "Settings",
            IconImageSource = "settings.png",
            Content = new StackLayout
            {
                Children =
                {
                    new Label
                    {
                        Text = "Adjust your settings here."
                    }
                }
            }
        };

        Children.Add(homePage);
        Children.Add(settingsPage);
    }
}

FlyoutPage

Overview FlyoutPage offers a master-detail layout where a flyout (sidebar) is used to navigate between various detail pages. This pattern is highly adaptable and beneficial for complex applications with numerous features and sections. Flyout provides a clean and organized interface, especially beneficial on larger screens like tablets.

Key Features

  • Flyout (Sidebar): The flyout contains a list of options or items that users can tap to navigate to specific pages.
  • Detail (Main Content): The detail area displays the content corresponding to the selected item in the flyout.
  • Adaptive Layout: FlyoutPage adjusts automatically based on the screen size, showing the flyout as a sidebar on larger screens and hiding it to save space on smaller screens.
  • Customizable Flyout Header and Footer: You can add headers and footers to the flyout for branding, navigation options, or other additional content.
  • Icons and Images: Items in the flyout can be accompanied by icons, images, and other visual elements to enhance the user experience.

Usage Example

public class MainPage : FlyoutPage
{
    public MainPage()
    {
        FlyoutLayoutBehavior = FlyoutLayoutBehavior.Popover;
        Flyout = new NavigationPage(new FlyoutMenuPage());
        Detail = new NavigationPage(new HomePage());

        var navigationPage = Detail as NavigationPage;
        if (navigationPage != null)
        {
            ((FlyoutMenuPage)Flyout).Navigation = navigationPage.Navigation;
        }
    }
}

public class FlyoutMenuPage : ContentPage
{
    public FlyoutMenuPage()
    {
        ListView listView = new ListView
        {
            ItemsSource = new MenuItem[]
            {
                new MenuItem
                {
                    Title = "Home",
                    IconSource = "home.png",
                    TargetType = typeof(HomePage)
                },
                new MenuItem
                {
                    Title = "Settings",
                    IconSource = "settings.png",
                    TargetType = typeof(SettingsPage)
                }
            }
        };

        listView.ItemSelected += async (sender, e) =>
        {
            var item = (MenuItem)e.SelectedItem;
            if (item == null)
                return;

            IsPresented = false;

            var page = (Page)Activator.CreateInstance(item.TargetType);
            await Navigation.PushAsync(page);

            listView.SelectedItem = null;
        };

        Content = new StackLayout
        {
            Children =
            {
                listView
            }
        };
    }
}

public class MenuItem
{
    public string Title { get; set; }
    public string IconSource { get; set; }
    public Type TargetType { get; set; }
}

Conclusion

Both TabbedPage and FlyoutPage are powerful tools in .NET MAUI for creating well-organized and user-friendly applications. TabbedPage is perfect for applications with a few key features or sections, while FlyoutPage offers greater flexibility and is ideal for more complex applications. Understanding and utilizing these page types can significantly enhance the user experience and functionality of your app.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement .NET MAUI Page Types TabbedPage, FlyoutPage

Step-by-Step Guide: Creating a TabbedPage in .NET MAUI

Prerequisites

  • .NET 7 SDK installed
  • Visual Studio (2022 recommended) with .NET MAUI workload

Step 1: Create a New .NET MAUI Project

  1. Open Visual Studio.
  2. Select "Create a new project".
  3. Search for "MAUI" and select the ".NET MAUI App" template.
  4. Click "Next".
  5. Configure your project with the desired name, location, and solution name.
  6. Click "Create".

Step 2: Create Individual Content Pages

You need at least two content pages to add to the TabbedPage.

  1. Right-click on the Pages folder (or the project root) in Solution Explorer.
  2. Select "Add" > "New Item".
  3. Choose "Content Page" and name it HomePage.xaml.
  4. Repeat the above steps to create another content page; name it SettingsPage.xaml.

Example: HomePage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="YourNamespace.Pages.HomePage"
             Title="Home">
    <StackLayout>
        <Label Text="Welcome to the Home Page!"
               FontSize="Large"
               VerticalOptions="Center"
               HorizontalOptions="Center"/>
    </StackLayout>
</ContentPage>

Example: SettingsPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="YourNamespace.Pages.SettingsPage"
             Title="Settings">
    <StackLayout>
        <Label Text="This is the Settings Page!"
               FontSize="Large"
               VerticalOptions="Center"
               HorizontalOptions="Center"/>
    </StackLayout>
</ContentPage>

Step 3: Create the TabbedPage

  1. Add a new ContentPage as before and name it MainTabPage.xaml.
  2. Remove the generated code behind (.cs) file.
  3. Modify MainTabPage.xaml to inherit from TabbedPage.

Example: MainTabPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<TabbedPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
            xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
            xmlns:local="clr-namespace:YourNamespace.Pages"
            x:Class="YourNamespace.Pages.MainTabPage">
    <local:HomePage />
    <local:SettingsPage />
</TabbedPage>

Step 4: Set the MainPage of the App to MainTabPage

Modify App.xaml.cs to set the MainPage of the application to the newly created TabbedPage.

Example: App.xaml.cs

namespace YourNamespace
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new Pages.MainTabPage();
        }
    }
}

Step 5: Run the Application

  • Press F5 or click on the Run button in Visual Studio to execute the project.
  • You should see a tabbed interface with the "Home" and "Settings" tabs.

Step-by-Step Guide: Creating a FlyoutPage in .NET MAUI

Step 1: Create the FlyoutPage

Similar to the TabbedPage example, create a content page for the main content and one for the navigation flyout.

  1. Create a new ContentPage named MainContentPage.xaml.
  2. Create another ContentPage named MenuPage.xaml.

Example: MainContentPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="YourNamespace.Pages.MainContentPage"
             Title="Main">
    <StackLayout>
        <Label Text="Welcome to the Main Content Page!"
               FontSize="Large"
               VerticalOptions="Center"
               HorizontalOptions="Center"/>
    </StackLayout>
</ContentPage>

Example: MenuPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="YourNamespace.Pages.MenuPage"
             Title="Menu">
    <StackLayout Padding="20">
        <Button Text="Home"
                Clicked="OnHomeButtonClicked"
                Margin="0,5,0,5" />
        <Button Text="Settings"
                Clicked="OnSettingsButtonClicked"
                Margin="0,5,0,5" />
    </StackLayout>
</ContentPage>

Example: MenuPage.xaml.cs

Add event handlers for the button clicks to navigate to different pages.

using Microsoft.Maui.Controls;

namespace YourNamespace.Pages
{
    public partial class MenuPage : ContentPage
    {
        public MenuPage()
        {
            InitializeComponent();
        }

        private void OnHomeButtonClicked(object sender, EventArgs e)
        {
            if (Parent is FlyoutPage flyoutPage)
            {
                flyoutPage.Detail = new NavigationPage(new MainContentPage());
                flyoutPage.IsPresented = false;
            }
        }

        private void OnSettingsButtonClicked(object sender, EventArgs e)
        {
            if (Parent is FlyoutPage flyoutPage)
            {
                flyoutPage.Detail = new NavigationPage(new SettingsPage());
                flyoutPage.IsPresented = false;
            }
        }
    }
}

Step 2: Create the Main FlyoutPage

Create a new FlyoutPage called MainFlyoutPage.xaml.

Example: MainFlyoutPage.xaml

<?xml version="1.0" encoding="utf-8" ?>
<FlyoutPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
            xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
            xmlns:local="clr-namespace:YourNamespace.Pages"
            x:Class="YourNamespace.Pages.MainFlyoutPage">
    <FlyoutPage.Flyout>
        <local:MenuPage />
    </FlyoutPage.Flyout>
    <FlyoutPage.Detail>
        <NavigationPage>
            <x:Arguments>
                <local:MainContentPage />
            </x:Arguments>
        </NavigationPage>
    </FlyoutPage.Detail>
</FlyoutPage>

Step 3: Update the App.xaml.cs

Set the MainPage of the application to the FlyoutPage.

Example: App.xaml.cs

namespace YourNamespace
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new Pages.MainFlyoutPage();
        }
    }
}

Step 4: Run the Application

  • Press F5 or click on the Run button in Visual Studio to execute the project.
  • You should see a side menu with buttons to navigate to the "Main" and "Settings" pages.

Summary

In this guide, you learned how to create and use TabbedPage and FlyoutPage in .NET MAUI, providing a structured and detailed step-by-step process for beginners. Feel free to customize the UI and functionalities as per requirements.

Top 10 Interview Questions & Answers on .NET MAUI Page Types TabbedPage, FlyoutPage

1. What is a TabbedPage in .NET MAUI and how do I create one?

A TabbedPage in .NET MAUI is a page that displays a series of tabs, each representing a different subpage. Users can swipe between tabs or tap a tab to switch pages. To create a TabbedPage, you instantiate it and add Page objects to its Children collection.

var tabbedPage = new TabbedPage
{
    Children =
    {
        new ContentPage { Title = "First", IconImageSource = "first.png" },
        new ContentPage { Title = "Second", IconImageSource = "second.png" },
        new ContentPage { Title = "Third", IconImageSource = "third.png" }
    }
};

2. How do I customize the appearance of tabs in a TabbedPage?

You can customize the appearance of tabs by setting properties like Title, IconImageSource, and BackgroundColor. Additionally, you can define a custom renderer or use style sheets to further modify the look and feel.

new TabbedPage
{
    BarTextColor = Colors.White,
    BarBackgroundColor = Colors.DarkBlue,
    Children =
    {
        new ContentPage { Title = "Home", IconImageSource = "home.png" },
        new ContentPage { Title = "Account", IconImageSource = "account.png" }
    }
};

3. Can I dynamically add or remove tabs in a TabbedPage at runtime?

Yes, you can add or remove tabs dynamically using the Add and Remove methods on the TabbedPage.Children collection.

var newTabPage = new ContentPage { Title = "New Tab" };
tabbedPage.Children.Add(newTabPage); // Adding a new tab

var tabPageToRemove = tabbedPage.Children.FirstOrDefault(p => p.Title == "Old Tab");
if (tabPageToRemove != null)
{
    tabbedPage.Children.Remove(tabPageToRemove); // Removing an existing tab
}

4. What is a FlyoutPage in .NET MAUI?

A FlyoutPage in .NET MAUI displays a flyout menu and a detail area where the content of the selected menu item appears. The flyout menu typically slides in from the side, allowing navigation between different sections of your app.

5. How do I set up a FlyoutPage in .NET MAUI?

To create a FlyoutPage, you instantiate it and assign pages to its Flyout and Detail properties.

var flyoutPage = new FlyoutPage
{
    Flyout = new MenuPage(), // This could be a ContentPage or any other page
    Detail = new HomePage()   // This will show the content when an option is selected
};

Ensure you have a proper menu setup in the Flyout page for navigation.

6. Can I navigate within a FlyoutPage?

Yes, the detail area in a FlyoutPage can host any type of page, including navigation stacks. You can navigate within the detail area using standard navigation techniques like PushAsync.

await ((NavigationPage)flyoutPage.Detail).PushAsync(new SettingsPage());

7. How do I customize the flyout menu in a FlyoutPage to include icons?

To include icons in your flyout menu list, you can add them as images if your menu list items use layout controls, such as ListView or Grid.

<ListView.ItemTemplate>
    <DataTemplate>
        <FlexLayout Direction="Row" AlignItems="Center">
            <Image Source="{Binding Icon}" Margin="5"/>
            <Label Text="{Binding Title}" FontSize="Medium" Margin="5"/>
        </FlexLayout>
    </DataTemplate>
</ListView.ItemTemplate>

In your menu items, provide both the Icon and Title.

8. Is there a way to toggle the flyout menu programmatically in a FlyoutPage?

You can toggle the flyout menu programmatically using the FlyoutIsPresented property.

flyoutPage.FlyoutIsPresented = !flyoutPage.FlyoutIsPresented; // Toggles the menu’s visibility

9. What’s the difference between using a NavigationPage vs a TabbedPage for my main shell interface?

  • NavigationPage: Use this for a stack-based approach with a back button. Ideal for apps where users move through steps or levels sequentially.
  • TabbedPage: Use this for apps that logically group different features into tabs. It provides quick access to various sections and is useful for apps structured with parallel navigation paths.

10. When might I choose to nest a TabbedPage inside a FlyoutPage in .NET MAUI?

Nesting a TabbedPage inside a FlyoutPage is useful when your app has a high-level navigation menu (flyout) and each menu option corresponds to a tabbed set of content. This structure allows users to switch between major sections via a flyout menu and then navigate through related subsections using the tabs.

flyoutPage.Detail = new NavigationPage(new TabbedPage
{
    Children = 
    {
        new HomePage(),
        new ProfilePage(),
        new SettingsPage()
    }
});    

This configuration provides both a comprehensive navigation overview (through flyout) and refined navigation within specific sections (using tabs).

You May Like This Related .NET Topic

Login to post a comment.