Afficher plusieurs vues avec ApplicationView

Aidez vos utilisateurs à être plus productifs en leur permettant d’afficher des parties indépendantes de votre application dans des fenêtres distinctes. Lorsque vous créez plusieurs fenêtres pour une application, chaque fenêtre se comporte indépendamment. La barre des tâches affiche chaque fenêtre séparément. Les utilisateurs peuvent déplacer, redimensionner, afficher et masquer les fenêtres d’application indépendamment et basculer entre les fenêtres d’application comme s’ils étaient des applications distinctes. Chaque fenêtre fonctionne dans son propre thread.

API importantes : ApplicationViewSwitcher, CreateNewView

Qu’est-ce qu’une vue ?

Une vue d’application est le jumelage 1:1 d’un thread et d’une fenêtre utilisée par l’application pour afficher du contenu. Il est représenté par un objet Windows.ApplicationModel.Core.CoreApplicationView .

Les vues sont gérées par l’objet CoreApplication . Vous appelez CoreApplication.CreateNewView pour créer un objet CoreApplicationView . Le CoreApplicationView rassemble une CoreWindow et un CoreDispatcher (stockés dans les propriétés CoreWindow et Dispatcher). Vous pouvez considérer CoreApplicationView comme l’objet que Windows Runtime utilise pour interagir avec le système Windows principal.

En règle générale, vous ne travaillez pas directement avec le CoreApplicationView. Au lieu de cela, Windows Runtime fournit la classe ApplicationView dans l’espace de noms Windows.UI.ViewManagement . Cette classe fournit des propriétés, des méthodes et des événements que vous utilisez lorsque votre application interagit avec le système de fenêtrage. Pour utiliser un ApplicationView, appelez la méthode statique ApplicationView.GetForCurrentView, qui obtient une instance ApplicationView liée au thread du CoreApplicationViewactuel.

De même, l’infrastructure XAML encapsule l’objet CoreWindow dans un objet Windows.UI.XAML.Window . Dans une application XAML, vous interagissez généralement avec l’objet Window plutôt que d’utiliser directement l'CoreWindow .

Afficher une nouvelle vue

Bien que chaque disposition d’application soit unique, nous vous recommandons d’inclure un bouton « nouvelle fenêtre » dans un emplacement prévisible, tel que le coin supérieur droit du contenu qui peut être ouvert dans une nouvelle fenêtre. Envisagez également d’inclure une option de menu contextuel pour « Ouvrir dans une nouvelle fenêtre ».

Examinons les étapes de création d'une nouvelle vue. Ici, la nouvelle vue est lancée en réponse à un clic de bouton.

private async void Button_Click(object sender, RoutedEventArgs e)
{
    CoreApplicationView newView = CoreApplication.CreateNewView();
    int newViewId = 0;
    await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        Frame frame = new Frame();
        frame.Navigate(typeof(SecondaryPage), null);   
        Window.Current.Content = frame;
        // You have to activate the window in order to show it later.
        Window.Current.Activate();

        newViewId = ApplicationView.GetForCurrentView().Id;
    });
    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}

Pour afficher une nouvelle vue

1. Appelez CoreApplication.CreateNewView pour créer une nouvelle fenêtre et un thread pour le contenu de l’affichage.

   CoreApplicationView newView = CoreApplication.CreateNewView();
   

2. Suivez l’ID de la nouvelle vue. Vous l’utilisez pour afficher la vue ultérieurement.

   Vous pouvez envisager de créer une infrastructure dans votre application pour faciliter le suivi des vues que vous créez. Consultez la ViewLifetimeControl classe dans l’exemple MultipleViews pour obtenir un exemple.

   int newViewId = 0;
   

3. Sur le nouveau thread, renseignez la fenêtre.

   Vous utilisez la méthode CoreDispatcher.RunAsync pour planifier le travail sur le thread d’interface utilisateur pour la nouvelle vue. Vous utilisez une expression lambda pour passer une fonction en tant qu’argument à la méthode RunAsync . Le travail que vous effectuez dans la fonction lambda se produit sur le thread de la nouvelle vue.

   En XAML, vous ajoutez généralement une Frame à la propriété Contenu, puis accédez à la Frame à un de page XAML où vous avez défini le contenu de votre application. Pour plus d’informations sur les cadres et les pages, consultez la navigation pair à pair entre deux pages.

   Une fois la nouvelle Window renseignée, vous devez appeler la méthodeActiver pour afficher la Fenêtre ultérieurement. Ce travail se produit sur le thread de la nouvelle vue, donc la nouvelle Fenêtre est activée.

   Enfin, obtenez l’ID de de la nouvelle vue que vous utilisez pour afficher la vue plus tard. Là encore, ce travail se trouve sur le thread de la nouvelle vue. Par conséquent, ApplicationView.GetForCurrentView obtient l’ID de de la nouvelle vue.

   await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
   {
       Frame frame = new Frame();
       frame.Navigate(typeof(SecondaryPage), null);   
       Window.Current.Content = frame;
       // You have to activate the window in order to show it later.
       Window.Current.Activate();
   
       newViewId = ApplicationView.GetForCurrentView().Id;
   });
   

4. Affichez la nouvelle vue en appelant ApplicationViewSwitcher.TryShowAsStandaloneAsync.

   Après avoir créé une vue, vous pouvez l’afficher dans une nouvelle fenêtre en appelant la méthode ApplicationViewSwitcher.TryShowAsStandaloneAsync . Le paramètre viewId de cette méthode est un entier qui identifie de manière unique chacune des vues de votre application. Vous récupérez la vue Id en utilisant soit la propriété ApplicationView.Id soit la méthode ApplicationView.GetApplicationViewIdForWindow.

   bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
   

Vue principale

La première vue créée au démarrage de votre application est appelée vue principale. Cette vue est stockée dans la propriété CoreApplication.MainView, et sa propriété IsMain est vraie. Vous ne créez pas cette vue ; il est créé par l’application. Le thread de la vue principale sert de gestionnaire pour l’application, et tous les événements d'activation des applications sont remis sur ce thread.

Si les vues secondaires sont ouvertes, la fenêtre de l’affichage principal peut être masquée, par exemple en cliquant sur le bouton fermer (x) dans la barre de titre de la fenêtre, mais son thread reste actif. L'appel Close sur la fenêtre de la vue principale Window entraîne une InvalidOperationException . (Utilisez Application.Exit pour fermer votre application.) Si le thread de la vue principale est arrêté, l’application se ferme.

Vues secondaires

D’autres vues, y compris toutes les vues que vous créez en appelant CreateNewView dans le code de votre application, sont des vues secondaires. La vue principale et les vues secondaires sont stockées dans la collection CoreApplication.Views . En règle générale, vous créez des vues secondaires en réponse à une action utilisateur. Dans certains cas, le système crée des vues secondaires pour votre application.

Passer d’une vue à une autre

Envisagez de fournir un moyen à l’utilisateur de naviguer d’une fenêtre secondaire vers sa fenêtre parente. Pour ce faire, utilisez la méthode ApplicationViewSwitcher.SwitchAsync . Vous appelez cette méthode à partir du thread de la fenêtre à partir de laquelle vous basculez et passez l’ID d’affichage de la fenêtre vers laquelle vous basculez.

await ApplicationViewSwitcher.SwitchAsync(viewIdToShow);

Lorsque vous utilisez SwitchAsync, vous pouvez choisir si vous souhaitez fermer la fenêtre initiale et la supprimer de la barre des tâches en spécifiant la valeur d’ApplicationViewSwitchingOptions.

Rubriques connexes

• Afficher plusieurs vues
• Afficher plusieurs vues avec AppWindow
• CommutateurDeVueD'Application
• CréerNouvelleVue