Afficher plusieurs fenêtres pour votre application

S’applique à: ✅ WinUI, ✅ Windows App SDK

Dans votre application WinUI 3, vous pouvez afficher le contenu de votre application dans les fenêtres secondaires tout en travaillant sur le même thread d’interface utilisateur sur chaque fenêtre.

API importantes : espace de noms Microsoft.UI.Windowing, classe, classe

Ouvrez l’application galerie WinUI 3 et consultez plusieurs fenêtres en action

Icône galerie WinUI 3 L’application Galerie WinUI 3 inclut des exemples interactifs de contrôles et de fonctionnalités WinUI. Obtenez l’application à partir du Microsoft Store ou parcourez le code source sur GitHub.

Conseil / Astuce

Une raison courante d’utiliser plusieurs fenêtres consiste à permettre aux onglets TabView d’être déplacés dans une nouvelle fenêtre. Pour plus d’informations et d’exemples spécifiques à ce scénario, consultez le détachement d'onglet dans l'article la vue des onglets.

Présentation de l’API

Voici quelques-unes des API importantes que vous utilisez pour afficher du contenu dans plusieurs fenêtres.

XAML et

Les classes et peuvent être utilisées pour afficher une partie d'une application dans une fenêtre secondaire. Une fonctionnalité importante des fenêtres WinUI est que chaque instance partage le même thread de traitement de l’interface utilisateur (y compris le répartiteur d’événements) à partir duquel ils ont été créés, ce qui simplifie les applications multi-fenêtres.

Consultez Vue d’ensemble de WinUI et SDK d'application Windows pour obtenir une explication plus détaillée de Window et AppWindow.

AppWindowPresenter

L’API AppWindowPresenter vous permet de basculer facilement les fenêtres en configurations prédéfinies comme ou . Pour plus d’informations, consultez Gérer les fenêtres d’application.

XamlRoot

La classe XamlRoot contient une arborescence d’éléments XAML, la connecte à l’objet hôte de fenêtre et fournit des informations telles que la taille et la visibilité. Vous ne créez pas d’objet XamlRoot directement. Au lieu de cela, un élément XAML est créé lorsque vous attachez un élément XAML à un . Vous pouvez ensuite utiliser la propriété UIElement.XamlRoot pour récupérer xamlRoot.

WindowId

est un identificateur unique pour une fenêtre d’application. Il est créé automatiquement et identifie à la fois le et le HWND Win32 de niveau supérieur auquel il est associé.

À partir d’un élément visuel, vous pouvez accéder à UIElement.XamlRoot ; puis XamlRoot.ContentIslandEnvironment ; ensuite, la propriété ContentIslandEnvironment.AppWindowId contient l’ID de la fenêtre dans laquelle se trouve le UIElement.

Afficher une nouvelle fenêtre

Vous pouvez créer un nouveau en XAML ou dans le code. Si vous créez un code XAML, vous créez en fait une sous-classe de la classe. Par exemple, consultez MainWindow.xaml créé par le modèle d'application Visual Studio.

Examinons les étapes à suivre pour afficher le contenu dans une nouvelle fenêtre.

Pour créer une fenêtre avec XAML

Dans le volet Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, puis sélectionnez Add > Nouvel élément...
Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez WinUI dans la liste des modèles sur le côté gauche de la fenêtre.
Sélectionnez le modèle vide .
Nommez le fichier.
Appuyez sur Ajouter.

Pour afficher une nouvelle fenêtre

Instanciez une nouvelle instance de , ou une sous-classe si vous avez créé une sous-classe avec un fichier.
```
Window newWindow = new Window();
```
Créez le contenu de la fenêtre.

Si vous avez créé une sous-classe avec un fichier, vous pouvez ajouter le contenu de la fenêtre directement en XAML. Sinon, vous ajoutez le contenu dans le code, comme indiqué ici.

Il est courant de créer un code XAML , puis de naviguer vers un code XAML [](/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.page où vous avez défini le contenu de votre application. Pour plus d’informations sur les frames et les pages, consultez Navigation pair à pair entre deux pages.
```
Frame contentFrame = new Frame();
contentFrame.Navigate(typeof(SecondaryPage));
```
Toutefois, vous pouvez afficher n’importe quel contenu XAML dans le , pas seulement un et . Par exemple, vous pouvez afficher un seul contrôle, comme ColorPicker, comme illustré plus tard.
Définissez votre contenu XAML sur la propriété Content de l’objet .
```
newWindow.Content = contentFrame;
```
Appelez le . Activez la méthode pour afficher la nouvelle fenêtre.
```
newWindow.Activate();
```

Suivre les instances de

Vous pouvez avoir accès aux instances d'autres parties de votre application, mais après avoir créé une instance d'un , il n'existe aucun moyen d'y accéder à partir d'un autre code, sauf si vous conservez une référence à celle-ci. Par exemple, vous souhaiterez peut-être gérer l'événement SizeChanged dans pour réorganiser les éléments de l'interface utilisateur lorsque la fenêtre est redimensionnée, ou vous pourriez avoir un bouton "tout fermer" qui ferme toutes les instances suivies de .

Dans ce cas, vous devez utiliser l’identificateur unique pour suivre les instances de fenêtre dans un , avec la valeur comme et l’instance en tant que . (TabView les API de détachement de tabulation utilisent également WindowId pour suivre Windows.)

Dans votre classe, créez l’objet en tant que propriété statique. Ensuite, ajoutez chaque page au moment où vous le créez et supprimez-la lorsque la page est fermée.

// App.xaml.cs
public partial class App : Application
{
    private Window? _window;
    public static Dictionary<WindowId, Window> ActiveWindows { get; set; } = new Dictionary<WindowId, Window>();

    // ...

    protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args)
    {
        _window = new MainWindow();
        _window.Activate();
        // Track the new window in the dictionary.
        ActiveWindows.Add(_window.AppWindow.Id, _window);
    }
}

Le code suivant crée une nouvelle fenêtre lorsqu’un bouton est cliqué dans . ajoute la nouvelle fenêtre au , et gère l'événement .Closed pour le supprimer de lorsque la fenêtre est fermée.

// MainPage.xaml.cs
private Window CreateWindow()
{
    Window newWindow = new Window();

    // Configure the window.
    newWindow.AppWindow.Resize(new SizeInt32(1200, 800));
    newWindow.Title = "Window " + newWindow.AppWindow.Id.Value.ToString();
    newWindow.SystemBackdrop = new MicaBackdrop();

    TrackWindow(newWindow);
    return newWindow;
}

private void TrackWindow(Window window)
{
    window.Closed += (sender, args) => {
        App.ActiveWindows.Remove(window.AppWindow.Id, out window);
    };
    App.ActiveWindows.Add(window.AppWindow.Id, window);
}

Obtenez une fenêtre avec suivi depuis le code de votre application

Pour accéder à une instance à partir de votre code d’application, vous devez obtenir le pour la fenêtre actuelle afin de la récupérer à partir du membre statique dans votre classe . Vous devez le faire dans le gestionnaire d’événements Loaded de la page plutôt que dans le constructeur afin que XamlRoot ne soit pas .

public sealed partial class SecondaryPage : Page
{
    Window window;

    public SecondaryPage()
    {
        InitializeComponent();
        Loaded += AppWindowPage_Loaded;
    }

    private void AppWindowPage_Loaded(object sender, RoutedEventArgs e)
    {
        // Get the reference to this Window that was stored when it was created.
        // Do this in the Page Loaded handler rather than the constructor to
        // ensure that the XamlRoot is created and attached to the Window.
        WindowId windowId = this.XamlRoot.ContentIslandEnvironment.AppWindowId;

        if (App.ActiveWindows.ContainsKey(windowId))
        {
            window = App.ActiveWindows[windowId];
        }
    }
}

Vue d’ensemble du fenêtrage
Gérer les fenêtres d’application
Vue par onglets
Afficher plusieurs vues (UWP)

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-05