Vue d’ensemble de la navigation

Windows Presentation Foundation (WPF) prend en charge la navigation de style navigateur qui peut être utilisée dans deux types d’applications : applications autonomes et applications de navigateur XAML (XBAPs). Pour empaqueter le contenu de la navigation, WPF fournit la Page classe. Vous pouvez naviguer de l’un Page à l’autre de manière déclarative, à l’aide d’un Hyperlink, ou par programmation, à l’aide du NavigationService. WPF utilise le journal pour mémoriser les pages qui ont été parcourues et pour revenir à eux.

Page, Hyperlink, NavigationServiceet le journal forment le cœur de la prise en charge de navigation offerte par WPF. Cette vue d’ensemble explore ces fonctionnalités en détail avant de couvrir la prise en charge avancée de la navigation qui inclut la navigation vers des fichiers XAML (Extensible Application Markup Language), des fichiers HTML et des objets.

Navigation dans les applications WPF

Cette rubrique fournit une vue d’ensemble des fonctionnalités de navigation clés dans WPF. Ces fonctionnalités sont disponibles pour les applications autonomes et les XBAPs, bien que cette rubrique les présente dans le contexte d’un XBAP.

Cette section explique et illustre les aspects suivants de la navigation :

• Implémentation d’une page

• Configuration d’une page de démarrage

• Configuration du titre, de la largeur et de la hauteur de la fenêtre hôte

• Navigation par lien hypertexte

• Navigation par fragments

• Navigation Service

• Navigation par programmation avec le service de navigation

• Durée de vie de navigation

• Se souvenir de la navigation par le biais du journal

• Durée de vie de la page et journal

• Conservation de l’état du contenu avec l’historique de navigation

• Cookies

• Navigation structurée

Implémentation d’une page

Dans WPF, vous pouvez accéder à plusieurs types de contenu qui incluent des objets .NET Framework, des objets personnalisés, des valeurs d’énumération, des contrôles utilisateur, des fichiers XAML et des fichiers HTML. Toutefois, vous constaterez que le moyen le plus courant et le plus pratique de empaqueter le contenu consiste à utiliser Page. En outre, Page implémente des fonctionnalités spécifiques à la navigation pour améliorer leur apparence et simplifier le développement.

À l’aide de Page, vous pouvez implémenter de manière déclarative une page navigable de contenu XAML avec le balisage suivant.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />

Une Page qui est mise en œuvre dans le balisage XAML a Page comme élément racine et nécessite la déclaration de l'espace de noms XML WPF. L’élément Page contient le contenu auquel vous souhaitez accéder et afficher. Vous ajoutez du contenu en définissant l’élément Page.Content de propriété, comme indiqué dans le balisage suivant.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Page.Content>
    <!-- Page Content -->
    Hello, Page!
  </Page.Content>
</Page>

Page.Content ne peut contenir qu’un seul élément enfant ; dans l’exemple précédent, le contenu est une chaîne unique, « Hello, Page ! » Dans la pratique, vous utiliserez généralement un contrôle de disposition comme élément enfant (voir Layout) pour contenir et composer votre contenu.

Les éléments enfants d’un Page élément sont considérés comme étant le contenu d’un Page élément et, par conséquent, vous n’avez pas besoin d’utiliser la déclaration explicite Page.Content . Le balisage suivant est l’équivalent déclaratif de l’exemple précédent.

<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <!-- Page Content -->
  Hello, Page!
</Page>

Dans ce cas, Page.Content est automatiquement défini avec les éléments enfants de l’élément Page . Pour plus d’informations, consultez Modèle de contenu WPF.

Un balisage uniquement Page est utile pour afficher du contenu. Toutefois, un Page peut également afficher des éléments qui permettent aux utilisateurs d’interagir avec la page, et il peut répondre à l’interaction utilisateur en gérant les événements et en appelant la logique de l'application. Une interaction interactive Page est implémentée à l’aide d’une combinaison de balisage et de code-behind, comme illustré dans l’exemple suivant.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.HomePage">
  Hello, from the XBAP HomePage!
</Page>

using System.Windows.Controls;

namespace SDKSample
{
    public partial class HomePage : Page
    {
        public HomePage()
        {
            InitializeComponent();
        }
    }
}

Imports System.Windows.Controls

Namespace SDKSample
    Partial Public Class HomePage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Pour permettre à un fichier de balisage et un fichier code-behind de fonctionner ensemble, la configuration suivante est requise :

• Dans le balisage, l’élément Page doit inclure l’attribut x:Class . Lorsque l'application est générée, la présence de x:Class dans le fichier de balisage incite le moteur de build de Microsoft (MSBuild) à créer une classe partial qui hérite de Page et porte le nom spécifié par l'attribut x:Class. Cela nécessite l’ajout d’une déclaration d’espace de noms XML pour le schéma XAML ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). La classe générée partial implémente InitializeComponent, qui est appelée pour inscrire les événements et définir les propriétés implémentées dans le balisage.

• Dans code-behind, la classe doit être une partial classe portant le même nom que celui spécifié par l’attribut dans le x:Class balisage, et elle doit dériver de Page. Cela permet au fichier code-behind d’être associé à la partial classe générée pour le fichier de balisage lorsque l’application est générée (voir Génération d’une application WPF).

• Dans code-behind, la Page classe doit implémenter un constructeur qui appelle la InitializeComponent méthode. InitializeComponent est implémenté par la classe générée partial par le fichier de balisage pour inscrire des événements et définir des propriétés définies dans le balisage.

Une fois que vous avez un Page, vous pouvez y accéder. Pour spécifier la première destination Page à laquelle une application accède, vous devez configurer le point de départ Page.

Configuration d’une page de démarrage

Les applications XBAP nécessitent une infrastructure d'application pour être hébergées dans un navigateur. Dans WPF, la Application classe fait partie d’une définition d’application qui établit l’infrastructure d’application requise (voir Vue d’ensemble de la gestion des applications).

Une définition d’application est généralement implémentée à l’aide du balisage et du code-behind, avec le fichier de balisage configuré en tant qu’élément MSBuildApplicationDefinition . Voici une définition d’application pour un XBAP.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App" />

using System.Windows;

namespace SDKSample
{
    public partial class App : Application { }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
    End Class
End Namespace

Un XBAP peut utiliser sa définition d’application pour spécifier un début Page, qui est celui Page automatiquement chargé lors du lancement de l'XBAP. Pour ce faire, définissez la StartupUri propriété avec l’URI (Uniform Resource Identifier) pour le fichier souhaité Page.

Vous pouvez définir StartupUri de manière déclarative dans le balisage, comme illustré dans l’exemple suivant.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="PageWithHyperlink.xaml" />

Dans cet exemple, l’attribut StartupUri est défini avec un URI de pack relatif qui identifie HomePage.xaml. Lorsque le XBAP est lancé, HomePage.xaml est automatiquement ouvert et affiché. Ceci est illustré par la figure suivante, qui montre un XBAP lancé à partir d’un serveur Web.

Configuration du titre, de la largeur et de la hauteur de la fenêtre hôte

Une chose que vous avez peut-être remarquée à partir de la figure précédente est que le titre du navigateur et du volet d’onglets est l’URI du XBAP. En plus d’être long, le titre n’est ni attrayant ni informatif. Pour cette raison, Page offre une possibilité de modifier le titre en définissant la propriété WindowTitle. En outre, vous pouvez configurer la largeur et la hauteur de la fenêtre du navigateur en définissant WindowWidth et WindowHeight, respectivement.

WindowTitle, WindowWidthet WindowHeight peut être défini de manière déclarative dans le balisage, comme illustré dans l’exemple suivant.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.HomePage"
    WindowTitle="Page Title"
    WindowWidth="500"
    WindowHeight="200">
  Hello, from the XBAP HomePage!
</Page>

Le résultat est illustré dans la figure suivante.

Navigation par lien hypertexte

Un XBAP classique comprend plusieurs pages. La façon la plus simple de naviguer d’une page à une autre consiste à utiliser un Hyperlink. Vous pouvez ajouter de manière déclarative un Hyperlink à un Page à l’aide de l’élément Hyperlink , qui est illustré dans le balisage suivant.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page With Hyperlink"
  WindowWidth="250"
  WindowHeight="250">

<Hyperlink NavigateUri="UriOfPageToNavigateTo.xaml">
  Navigate to Another Page
</Hyperlink>

</Page>

Un Hyperlink élément nécessite les éléments suivants :

• URI du pack du Page vers lequel naviguer, comme spécifié par l’attribut NavigateUri.

• Contenu qu’un utilisateur peut cliquer pour lancer la navigation, par exemple du texte et des images (pour le contenu que l’élément Hyperlink peut contenir, voir Hyperlink).

La figure suivante montre un XBAP avec un Page qui possède un Hyperlink.

Comme vous pouvez vous y attendre, le fait de cliquer sur le Hyperlink provoque la navigation de l'XBAP vers le Page identifié par l’attribut NavigateUri. En outre, le XBAP ajoute une entrée pour la précédente Page à la liste des Pages récentes dans Internet Explorer. Ce cas est illustré dans la figure suivante.

En plus de la prise en charge de la navigation d'un Page à un autre, Hyperlink prend également en charge la navigation par fragments.

Navigation par fragments

La navigation de fragments est la navigation vers un fragment de contenu dans l’élément actif Page ou un autre Page. Dans WPF, un fragment de contenu est le contenu contenu par un élément nommé. Un élément nommé est un élément qui a son Name jeu d’attributs. Le balisage suivant montre un élément nommé TextBlock qui contient un fragment de contenu.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowTitle="Page With Fragments" >

<!-- Content Fragment called "Fragment1" -->
<TextBlock Name="Fragment1">
  Ea vel dignissim te aliquam facilisis ...
</TextBlock>

</Page>

Pour qu'un Hyperlink puisse naviguer vers un fragment de contenu, l’attribut NavigateUri doit inclure les éléments suivants :

• L'URI du fragment de contenu de Page vers lequel naviguer.

• Caractère « # ».

• Nom de l’élément sur le Page fragment de contenu.

Un URI de fragment a le format suivant.

PageURI#ElementName

Voici un exemple d’un Hyperlink fragment de contenu configuré pour accéder à un fragment de contenu.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page That Navigates To Fragment" >

<Hyperlink NavigateUri="PageWithFragments.xaml#Fragment1">
  Navigate To pack Fragment
</Hyperlink>

</Page>

Navigation Service

Bien qu’il Hyperlink autorise un utilisateur à lancer la navigation vers un particulier Page, le travail de localisation et de téléchargement de la page est effectué par la NavigationService classe. En fait, NavigationService permet de traiter une demande de navigation pour le compte du code client, comme le Hyperlink. En outre, NavigationService implémente un support avancé pour le suivi et l'orientation d'une demande de navigation.

Lorsqu'on clique sur un Hyperlink, WPF appelle NavigationService.Navigate pour localiser et télécharger le pack spécifié à l'URI Page. Le téléchargement Page est converti en arborescence d’objets dont l’objet racine est une instance du téléchargement Page. Une référence à l’objet racine Page est stockée dans la NavigationService.Content propriété. L’URI du pack pour le contenu auquel l’accès a été accédé est stocké dans la NavigationService.Source propriété, tandis que le NavigationService.CurrentSource pack stocke l’URI du pack pour la dernière page à laquelle vous avez accédé.

Navigation par programmation avec le service de navigation

Vous n’avez pas besoin de savoir à propos de NavigationService si la navigation est implémentée de manière déclarative dans le balisage à l’aide de Hyperlink, car Hyperlink utilise le NavigationService en votre nom. Cela signifie que, tant que le parent direct ou indirect d’un Hyperlink hôte de navigation est un hôte de navigation (voir Hôtes de navigation), Hyperlink peut rechercher et utiliser le service de navigation de l’hôte de navigation pour traiter une demande de navigation.

Toutefois, il existe des situations où vous devez utiliser NavigationService directement, y compris les éléments suivants :

• Lorsque vous devez instancier un Page à l'aide d'un constructeur avec paramètres.

• Lorsque vous devez définir des propriétés sur le Page avant de naviguer vers lui.

• Lorsque l’élément Page vers lequel il faut naviguer ne peut être déterminé qu’au moment de l’exécution.

Dans ces situations, vous devez écrire du code pour lancer la navigation par programmation en appelant la Navigate méthode de l’objet NavigationService . Cela nécessite d’obtenir une référence à un NavigationService.

Obtention d’une référence à NavigationService

Pour des raisons couvertes dans la section Hôtes de navigation , une application WPF peut avoir plusieurs NavigationService. Cela signifie que votre code a besoin d’un moyen de trouver un NavigationService, qui est généralement celui NavigationService qui a accédé à l’actuel Page. Vous pouvez obtenir une référence à un NavigationService en appelant la staticNavigationService.GetNavigationService méthode. Pour obtenir l’élément NavigationService qui a navigué vers un Page particulier, vous passez une référence à l’argument Page de la méthode GetNavigationService. Le code suivant montre comment obtenir le NavigationService pour le Page actuel.

using System.Windows.Navigation;

// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = NavigationService.GetNavigationService(this);

' Get a reference to the NavigationService that navigated to this Page
Dim ns As NavigationService = NavigationService.GetNavigationService(Me)

En guise de raccourci pour rechercher la NavigationService propriété pour un Page, Page implémente la NavigationService propriété. Ceci est illustré dans l’exemple suivant.

using System.Windows.Navigation;

// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = this.NavigationService;

' Get a reference to the NavigationService that navigated to this Page
Dim ns As NavigationService = Me.NavigationService

Navigation programmatique vers un objet de page

L’exemple suivant montre comment utiliser l’option NavigationService pour accéder par programmation à un Page. La navigation par programmation est requise, car l’accès Page à celui-ci ne peut être instancié qu’à l’aide d’un seul constructeur sans paramètre. Le Page avec le constructeur qui n'est pas sans paramètre est illustré dans le balisage et le code suivants.

<Page
    x:Class="SDKSample.PageWithNonDefaultConstructor"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="PageWithNonDefaultConstructor">
  
  <!-- Content goes here -->
  
</Page>

using System.Windows.Controls;

namespace SDKSample
{
    public partial class PageWithNonDefaultConstructor : Page
    {
        public PageWithNonDefaultConstructor(string message)
        {
            InitializeComponent();

            this.Content = message;
        }
    }
}

Namespace SDKSample
    Partial Public Class PageWithNonDefaultConstructor
        Inherits Page
        Public Sub New(ByVal message As String)
            InitializeComponent()

            Me.Content = message
        End Sub
    End Class
End Namespace

Celui Page qui accède au Page constructeur sans paramètre est affiché dans le balisage et le code suivants.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSNavigationPage">

  <Hyperlink Click="hyperlink_Click">
    Navigate to Page with Non-Default Constructor
  </Hyperlink>

</Page>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class NSNavigationPage : Page
    {
        public NSNavigationPage()
        {
            InitializeComponent();
        }

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Instantiate the page to navigate to
            PageWithNonDefaultConstructor page = new PageWithNonDefaultConstructor("Hello!");

            // Navigate to the page, using the NavigationService
            this.NavigationService.Navigate(page);
        }
    }
}

Namespace SDKSample
    Partial Public Class NSNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Instantiate the page to navigate to
            Dim page As New PageWithNonDefaultConstructor("Hello!")

            ' Navigate to the page, using the NavigationService
            Me.NavigationService.Navigate(page)
        End Sub
    End Class
End Namespace

Lorsque le Hyperlink de ce Page est cliqué, la navigation commence en instanciant le Page à utiliser pour naviguer, en utilisant le constructeur avec des paramètres, et en appelant la méthode NavigationService.Navigate. Navigate accepte une référence à l’objet vers lequel accéder NavigationService , plutôt qu’un URI de pack.

Navigation programmée avec un URI de pack

Si vous devez construire un URI de pack par programmation (lorsque vous pouvez uniquement déterminer l’URI du pack au moment de l’exécution, par exemple), vous pouvez utiliser la NavigationService.Navigate méthode. Ceci est illustré dans l’exemple suivant.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSUriNavigationPage">
  <Hyperlink Click="hyperlink_Click">Navigate to Page by Pack URI</Hyperlink>
</Page>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class NSUriNavigationPage : Page
    {
        public NSUriNavigationPage()
        {
            InitializeComponent();
        }

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Create a pack URI
            Uri uri = new Uri("AnotherPage.xaml", UriKind.Relative);

            // Get the navigation service that was used to
            // navigate to this page, and navigate to
            // AnotherPage.xaml
            this.NavigationService.Navigate(uri);
        }
    }
}

Namespace SDKSample
    Partial Public Class NSUriNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Create a pack URI
            Dim uri As New Uri("AnotherPage.xaml", UriKind.Relative)

            ' Get the navigation service that was used to 
            ' navigate to this page, and navigate to 
            ' AnotherPage.xaml
            Me.NavigationService.Navigate(uri)
        End Sub
    End Class
End Namespace

Actualisation de la page en cours

Un Page n’est pas téléchargé s’il a le même URI pack que l’URI du pack stocké dans la NavigationService.Source propriété. Pour forcer WPF à télécharger à nouveau la page active, vous pouvez appeler la NavigationService.Refresh méthode, comme illustré dans l’exemple suivant.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSRefreshNavigationPage">
 <Hyperlink Click="hyperlink_Click">Refresh this page</Hyperlink>
</Page>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class NSRefreshNavigationPage : Page
    {

Namespace SDKSample
    Partial Public Class NSRefreshNavigationPage
        Inherits Page

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Refresh();
        }
    }
}

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Force WPF to download this page again
            Me.NavigationService.Refresh()
        End Sub
    End Class
End Namespace

Durée de vie de navigation

Il existe de nombreuses façons de lancer la navigation, comme vous l’avez vu. Lorsque la navigation est lancée et que la navigation est en cours, vous pouvez suivre et influencer la navigation à l’aide des événements suivants implémentés par NavigationService:

• Navigating. Se produit lorsqu’une nouvelle navigation est demandée. Peut être utilisé pour annuler la navigation.

• NavigationProgress. Se produit régulièrement pendant un téléchargement pour fournir des informations de progression de navigation.

• Navigated. Se produit lorsque la page a été localisée et téléchargée.

• NavigationStopped. Se produit lorsque la navigation est arrêtée (en appelant StopLoading) ou lorsqu’une nouvelle navigation est demandée pendant qu’une navigation actuelle est en cours.

• NavigationFailed. Se produit lorsqu’une erreur est déclenchée lors de la navigation vers le contenu demandé.

• LoadCompleted. Se produit lorsque le contenu auquel on a accédé est chargé et analysé, et que son rendu a commencé.

• FragmentNavigation. Se produit lorsque la navigation vers un fragment de contenu commence, ce qui se produit :

  • Immédiatement, si le fragment souhaité se trouve dans le contenu actuel.

  • Une fois le contenu source chargé, si le fragment souhaité se trouve dans un contenu différent.

Les événements de navigation sont déclenchés dans l’ordre illustré par la figure suivante.

En général, un Page ne se soucie pas de ces événements. Il est plus probable qu’une application les concerne et, pour cette raison, ces événements sont également déclenchés par la Application classe :

• Application.Navigating

• Application.NavigationProgress

• Application.Navigated

• Application.NavigationFailed

• Application.NavigationStopped

• Application.LoadCompleted

• Application.FragmentNavigation

Chaque fois que NavigationService soulève un événement, la classe Application soulève l'événement correspondant. Frame et NavigationWindow offrent les mêmes événements pour détecter la navigation entre leurs périmètres respectifs.

Dans certains cas, un Page peut être intéressé par ces événements. Par exemple, un Page peut gérer l’événement pour déterminer s’il faut annuler ou non la NavigationService.Navigating navigation en dehors de lui-même. Ceci est illustré dans l’exemple suivant.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CancelNavigationPage">
  <Button Click="button_Click">Navigate to Another Page</Button>
</Page>

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class CancelNavigationPage : Page
    {
        public CancelNavigationPage()
        {
            InitializeComponent();

            // Can only access the NavigationService when the page has been loaded
            this.Loaded += new RoutedEventHandler(CancelNavigationPage_Loaded);
            this.Unloaded += new RoutedEventHandler(CancelNavigationPage_Unloaded);
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Navigate(new Uri("AnotherPage.xaml", UriKind.Relative));
        }

        void CancelNavigationPage_Loaded(object sender, RoutedEventArgs e)
        {
            this.NavigationService.Navigating += new NavigatingCancelEventHandler(NavigationService_Navigating);
        }

        void CancelNavigationPage_Unloaded(object sender, RoutedEventArgs e)
        {
            this.NavigationService.Navigating -= new NavigatingCancelEventHandler(NavigationService_Navigating);
        }

        void NavigationService_Navigating(object sender, NavigatingCancelEventArgs e)
        {
            // Does the user really want to navigate to another page?
            MessageBoxResult result;
            result = MessageBox.Show("Do you want to leave this page?", "Navigation Request", MessageBoxButton.YesNo);

            // If the user doesn't want to navigate away, cancel the navigation
            if (result == MessageBoxResult.No) e.Cancel = true;
        }
    }
}

Namespace SDKSample
    Partial Public Class CancelNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()

            ' Can only access the NavigationService when the page has been loaded
            AddHandler Loaded, AddressOf CancelNavigationPage_Loaded
            AddHandler Unloaded, AddressOf CancelNavigationPage_Unloaded
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Force WPF to download this page again
            Me.NavigationService.Navigate(New Uri("AnotherPage.xaml", UriKind.Relative))
        End Sub

        Private Sub CancelNavigationPage_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
            AddHandler NavigationService.Navigating, AddressOf NavigationService_Navigating
        End Sub

        Private Sub CancelNavigationPage_Unloaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
            RemoveHandler NavigationService.Navigating, AddressOf NavigationService_Navigating
        End Sub

        Private Sub NavigationService_Navigating(ByVal sender As Object, ByVal e As NavigatingCancelEventArgs)
            ' Does the user really want to navigate to another page?
            Dim result As MessageBoxResult
            result = MessageBox.Show("Do you want to leave this page?", "Navigation Request", MessageBoxButton.YesNo)

            ' If the user doesn't want to navigate away, cancel the navigation
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End Sub
    End Class
End Namespace

Si vous inscrivez un gestionnaire avec un événement de navigation à partir d’un Page, comme dans l’exemple précédent, vous devez également annuler l’inscription du gestionnaire d’événements. Si ce n’est pas le cas, il peut y avoir des effets secondaires en ce qui concerne la façon dont la navigation WPF se souvient de Page la navigation à l’aide du journal.

La mémorisation de la navigation avec le journal

WPF utilise deux piles pour mémoriser les pages que vous avez parcourues : une pile arrière et une pile vers l’avant. Lorsque vous naviguez du Page actuel vers un nouveau Page ou à un Page existant, le Page actuel est ajouté à la pile de navigation. Lorsque vous naviguez de l'actuel Page vers le précédent Page, l'actuel Page est ajouté à la pile vers l’avant. La pile arrière, la pile avant et la fonctionnalité pour les gérer sont collectivement appelées le journal. Chaque élément de la pile arrière et la pile vers l’avant est une instance de la JournalEntry classe, et est appelé entrée de journal.

Navigation dans le journal à partir d’Internet Explorer

Conceptuellement, le journal fonctionne de la même façon que les boutons Précédent et Avant dans Internet Explorer. Celles-ci sont illustrées dans la figure suivante.

Pour les adresses XBAP hébergées par Internet Explorer, WPF intègre le journal dans l’interface utilisateur de navigation d’Internet Explorer. Cela permet aux utilisateurs de parcourir des pages dans un XBAP à l’aide des boutons Précédent, Transfert et Pages récentes dans Internet Explorer.

Par défaut, le texte de chaque Page page qui apparaît dans la liste Pages récentes d’Internet Explorer est l’URI de l’objet Page. Dans de nombreux cas, cela n’est pas particulièrement significatif pour l’utilisateur. Heureusement, vous pouvez modifier le texte à l’aide de l’une des options suivantes :

1. Valeur d’attribut jointe JournalEntry.Name .

2. Valeur de l’attribut Page.Title .

3. Valeur de l’attribut Page.WindowTitle et URI pour le Page actuel.

4. URI pour le Page actuel. (Par défaut)

L’ordre dans lequel les options sont répertoriées correspond à l’ordre de priorité pour trouver le texte. Par exemple, si JournalEntry.Name elle est définie, les autres valeurs sont ignorées.

L’exemple suivant utilise l’attribut Page.Title pour modifier le texte qui apparaît pour une entrée de journal.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.PageWithTitle"
    Title="This is the title of the journal entry for this page.">

</Page>

using System.Windows.Controls;

namespace SDKSample
{
    public partial class PageWithTitle : Page
    {

Namespace SDKSample
    Partial Public Class PageWithTitle
        Inherits Page

    }
}

    End Class
End Namespace

Navigation dans le journal à l’aide de WPF

Bien qu’un utilisateur puisse naviguer dans le journal à l’aide des boutons Précédent, Suivant et Pages récentes dans Internet Explorer, vous pouvez également naviguer dans le journal à l'aide de mécanismes déclaratifs et programmatiques fournis par WPF. Pour cela, vous devez fournir des interfaces utilisateur de navigation personnalisées dans vos pages.

Vous pouvez ajouter la navigation de journal de manière déclarative à l’aide des commandes de navigation exposées par NavigationCommands. L’exemple suivant montre comment utiliser la commande de BrowseBack navigation.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NavigationCommandsPage">

<Hyperlink Command="NavigationCommands.BrowseBack">Back</Hyperlink>

<Hyperlink Command="NavigationCommands.BrowseForward">Forward</Hyperlink>

</Page>

Vous pouvez naviguer par programmation dans le journal à l’aide de l’un des membres suivants de la NavigationService classe :

• GoBack

• GoForward

• CanGoBack

• CanGoForward

Le journal peut également être manipulé par programmation, comme indiqué dans Conserver l’état du contenu avec l’historique de navigation plus loin dans cette rubrique.

Durée de vie de la page et journal

Considérez un XBAP avec plusieurs pages qui contiennent du contenu enrichi, notamment des graphiques, des animations et des supports. L’empreinte mémoire des pages comme celles-ci peut être assez volumineuse, en particulier si des médias vidéo et audio sont utilisés. Étant donné que le journal « mémorise » les pages auxquelles on a consultées, un XBAP peut rapidement consommer une quantité importante et notable de mémoire.

Pour cette raison, le comportement par défaut du journal consiste à stocker Page les métadonnées dans chaque entrée de journal plutôt qu’une référence à un Page objet. Lorsqu’une entrée de journal est consultée, ses Page métadonnées sont utilisées pour créer une nouvelle instance de l'élément spécifié Page. Par conséquent, chaque Page navigué a la durée de vie qui est illustrée par la figure suivante.

de

Bien que l’utilisation du comportement de journalisation par défaut puisse économiser sur la consommation de mémoire, les performances de rendu par page peuvent être réduites ; la réinitération d’un Page peut être gourmande en temps, en particulier si elle a beaucoup de contenu. Si vous devez conserver une Page instance dans le journal, vous pouvez tirer parti de deux techniques pour le faire. Tout d’abord, vous pouvez accéder par programmation à un Page objet en appelant la NavigationService.Navigate méthode.

Ensuite, vous pouvez spécifier que WPF conserve une instance d’un Page dans le journal en définissant la KeepAlive propriété true sur (la valeur par défaut est false). Comme illustré dans l’exemple suivant, vous pouvez définir KeepAlive de manière déclarative dans le balisage.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.KeepAlivePage"
    KeepAlive="True">
  
  An instance of this page is stored in the journal.
  
</Page>

La durée de vie d’un élément Page qui est conservé est subtilement différente de celle d’un élément qui ne l’est pas. La première fois qu’un Page qui est maintenu en vie est navigué, il est instancié comme un Page qui n’est pas maintenu en vie. Toutefois, étant donné qu’une instance de Page est conservée dans le journal, elle n'est jamais instanciée à nouveau tant qu'elle reste dans le journal. Par conséquent, si une logique d’initialisation Page doit être appelée chaque fois que l'on navigue vers le Page, vous devez la déplacer du constructeur vers un gestionnaire pour l’événement Loaded. Comme montré dans la figure suivante, les événements Loaded et Unloaded sont toujours déclenchés chaque fois qu'on navigue vers et depuis un Page, respectivement.

Lorsqu’un Page n’est pas conservé en vie, vous ne devez pas effectuer l’une des opérations suivantes :

• Stockez une référence à celle-ci ou une partie de celle-ci.

• Inscrivez des gestionnaires d’événements avec des événements qui ne sont pas implémentés par celui-ci.

Faire l'une ou l'autre de ces actions entraînera la création de références pour forcer Page à être conservé en mémoire, même après qu'il ait été retiré du journal.

En règle générale, vous devriez préférer le comportement par défaut Page de ne pas garder un Page en vie. Toutefois, cela a des implications d’état qui sont abordées dans la section suivante.

Conservation de l’état du contenu avec l’historique de navigation

S’il ne reste pas actif, et qu’il comporte des contrôles qui collectent des données auprès de l’utilisateur, que se passe-t-il pour les données si un utilisateur quitte et revient à PagePage? Du point de vue de l’expérience utilisateur, l’utilisateur doit s’attendre à voir les données qu’il a entrées précédemment. Malheureusement, étant donné qu'une nouvelle instance de Page est créée avec chaque navigation, les contrôles qui ont collecté les données sont réinstanciés et les données sont perdues.

Heureusement, le journal prend en charge la mémorisation des données entre Page les navigations, y compris les données de contrôle. Plus précisément, l’entrée de journal pour chacun Page agit comme un conteneur temporaire pour l’état associé Page . Les étapes suivantes décrivent l’utilisation de cette prise en charge lorsqu’un Page utilisateur navigue à partir de :

1. Une entrée pour l'actuel Page est ajoutée au journal.

2. L’état du fichier Page est stocké avec l’entrée de journal de cette page, qui est ajoutée à la pile arrière.

3. Le nouveau Page est accessible.

Lorsque l'on retourne à la page Page en utilisant le journal, les étapes suivantes se produisent :

1. L’instanciation Page (l’entrée de journal supérieure sur la pile arrière) est instanciée.

2. L’état Page est actualisé avec l’état stocké avec l’entrée de journal pour le Page.

3. Le Page est retourné à.

WPF utilise automatiquement cette prise en charge lorsque les contrôles suivants sont utilisés sur un Page:

• CheckBox

• ComboBox

• Expander

• Frame

• ListBox

• ListBoxItem

• MenuItem

• ProgressBar

• RadioButton

• Slider

• TabControl

• TabItem

• TextBox

Si un Page utilise ces contrôles, les données saisies sont mémorisées d'une navigation à l'autre, comme le montre la Page dans la figure suivante.

Lorsqu’un Page contrôle a des contrôles autres que ceux de la liste précédente ou quand l’état est stocké dans des objets personnalisés, vous devez écrire du code pour que le journal mémorise l’état entre Page les navigations.

Si vous devez mémoriser de petits éléments d’état dans les Page navigations, vous pouvez utiliser des propriétés de dépendance (voir DependencyProperty) configurées avec l’indicateur FrameworkPropertyMetadata.Journal de métadonnées.

Si l’état que votre Page doit mémoriser à travers les navigations comprend plusieurs éléments de données, vous pouvez constater qu’il est moins coûteux en code d'encapsuler votre état dans une seule classe et implémenter l’interface IProvideCustomContentState.

Si vous avez besoin de parcourir différents états d’un seul Page, sans naviguer depuis le Page lui-même, vous pouvez utiliser IProvideCustomContentState et NavigationService.AddBackEntry.

Cookies

Une autre façon dont les applications WPF peuvent stocker des données consiste à utiliser des cookies, qui sont créés, mis à jour et supprimés à l’aide des méthodes SetCookie et GetCookie. Les cookies que vous pouvez créer dans WPF sont les mêmes cookies que les autres types d’applications web utilisent ; les cookies sont des éléments arbitraires de données stockés par une application sur une machine cliente pendant ou entre des sessions d’application. Les données de cookie prennent généralement la forme d’une paire nom/valeur au format suivant.

Nom=Valeur

Lorsque les données sont transmises SetCookie, ainsi que l’emplacement Uri pour lequel le cookie doit être défini, un cookie est créé en mémoire et il est disponible uniquement pendant la durée de la session d’application active. Ce type de cookie est appelé cookie de session.

Pour stocker un cookie entre les sessions d’application, une date d’expiration doit être ajoutée au cookie à l’aide du format suivant.

NOM=VALEUR; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

Un cookie avec une date d’expiration est stocké dans le dossier Fichiers Internet temporaires de l’installation windows actuelle jusqu’à l’expiration du cookie. Un tel cookie est appelé cookie persistant, car il persiste entre les sessions d’application.

Vous récupérez les cookies de session et persistants en appelant la GetCookie méthode, en passant l’emplacement Uri où le cookie a été défini avec la SetCookie méthode.

Voici quelques-unes des façons dont les cookies sont pris en charge dans WPF :

• Les applications autonomes WPF et les XBAPs peuvent créer et gérer des cookies.

• Les cookies créés par un XBAP sont accessibles à partir du navigateur.

• Les adresses XBAP du même domaine peuvent créer et partager des cookies.

• Les XBAPs et les pages HTML du même domaine peuvent créer et partager des cookies.

• Les cookies sont distribués lorsque les XBAPs et les pages XAML indépendantes effectuent des requêtes web.

• Les XBAPs de niveau supérieur et les XBAP hébergés dans des IFRAMES peuvent accéder aux cookies.

• La prise en charge des cookies dans WPF est la même pour tous les navigateurs pris en charge.

• Dans Internet Explorer, la stratégie P3P relative aux cookies est respectée par WPF, en particulier en ce qui concerne les applications XBAP de premières parties et de tierces parties.

Navigation structurée

Si vous devez passer des données d’un Page à l’autre, vous pouvez transmettre les données en tant qu’arguments à un constructeur sans paramètre du Page. Notez que si vous utilisez cette technique, vous devez garder la Page en vie ; si ce n’est pas le cas, la prochaine fois que vous accédez à l’élément Page, WPF réinstantie le Page en utilisant le constructeur sans paramètres.

Page Vous pouvez également implémenter des propriétés définies avec les données qui doivent être passées. Les choses deviennent compliquées, cependant, quand un Page a besoin de transmettre des données au Page qui a navigué vers lui. Le problème est que la navigation ne prend pas en charge de manière native les mécanismes garantissant qu'un Page soit de retour après en être parti. Essentiellement, la navigation ne prend pas en charge la sémantique des appels/retours. Pour résoudre ce problème, WPF fournit la PageFunction<T> classe que vous pouvez utiliser pour vous assurer qu’une valeur Page est retournée de manière prévisible et structurée. Pour plus d’informations, consultez Vue d’ensemble de la navigation structurée.

La classe NavigationWindow

À ce stade, vous avez vu la gamme des services de navigation que vous êtes le plus susceptible d’utiliser pour créer des applications avec du contenu navigable. Ces services ont été abordés dans le contexte des XBAPs, bien qu’ils ne soient pas limités aux XBAPs. Les systèmes d’exploitation modernes et les applications Windows tirent parti de l’expérience de navigateur des utilisateurs modernes pour incorporer la navigation de style navigateur dans des applications autonomes. Voici quelques exemples courants :

• Thésaurus Word : Naviguer parmi les choix de mots.

• Explorateur de fichiers : naviguez dans les fichiers et les dossiers.

• Assistants : Décomposer une tâche complexe en plusieurs pages entre lesquelles on peut naviguer. Par exemple, l’Assistant Composants Windows qui gère l’ajout et la suppression des fonctionnalités Windows.

Pour incorporer la navigation de style navigateur dans vos applications autonomes, vous pouvez utiliser la NavigationWindow classe. NavigationWindow dérive de Window et l'étend avec la même prise en charge de la navigation que celle fournie par les XBAPs. Vous pouvez utiliser NavigationWindow comme fenêtre principale de votre application autonome ou en tant que fenêtre secondaire, comme une boîte de dialogue.

Pour implémenter un NavigationWindow, comme avec la plupart des classes de niveau supérieur dans WPF (Windowet Pageainsi de suite), vous utilisez une combinaison de balisage et de code-behind. Ceci est illustré dans l’exemple suivant.

<NavigationWindow
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MainWindow" 
    Source="HomePage.xaml"/>

using System.Windows.Navigation;

namespace SDKSample
{
    public partial class MainWindow : NavigationWindow
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

Namespace SDKSample
    Partial Public Class MainWindow
        Inherits NavigationWindow
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Ce code crée un NavigationWindow qui accède automatiquement à un Page (HomePage.xaml) lors de l’ouverture NavigationWindow . Si la NavigationWindow est la fenêtre d’application principale, vous pouvez utiliser l’attribut StartupUri pour le lancer. Ceci est illustré dans le balisage suivant.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="MainWindow.xaml" />

La figure suivante montre la NavigationWindow fenêtre principale d’une application autonome.

Dans la figure, vous pouvez voir que le NavigationWindow a un titre, même s’il n’a pas été défini dans le code d’implémentation NavigationWindow de l’exemple précédent. Au lieu de cela, le titre est défini à l’aide de la WindowTitle propriété, qui est illustrée dans le code suivant.

<Page 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Home Page"
    WindowTitle="NavigationWindow">

</Page>

Le réglage des propriétés WindowWidth et WindowHeight affecte également le NavigationWindow.

En règle générale, vous implémentez votre propre NavigationWindow lorsque vous devez personnaliser son comportement ou son apparence. Si vous ne faites ni l’un ni l’autre, vous pouvez utiliser un raccourci. Si vous spécifiez l’URI de pack d’un Page comme StartupUri dans une application autonome, Application crée automatiquement un NavigationWindow pour héberger le Page. Le balisage suivant montre comment activer cela.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="HomePage.xaml" />

Si vous souhaitez qu’une fenêtre d’application secondaire, telle qu’une boîte de dialogue soit une NavigationWindow, vous pouvez utiliser le code dans l’exemple suivant pour l’ouvrir.

// Open a navigation window as a dialog box
NavigationWindowDialogBox dlg = new NavigationWindowDialogBox();
dlg.Source = new Uri("HomePage.xaml", UriKind.Relative);
dlg.Owner = this;
dlg.ShowDialog();

' Open a navigation window as a dialog box
Dim dlg As New NavigationWindowDialogBox()
dlg.Source = New Uri("HomePage.xaml", UriKind.Relative)
dlg.Owner = Me
dlg.ShowDialog()

La figure suivante présente le résultat.

Comme vous pouvez le voir, NavigationWindow affiche les boutons Précédent et Avant de style Internet Explorer qui permettent aux utilisateurs de naviguer dans le journal. Ces boutons fournissent la même expérience utilisateur, comme illustré dans la figure suivante.

Si vos pages fournissent leur propre prise en charge de la navigation dans les journaux et de l’interface utilisateur, vous pouvez masquer les boutons Précédent et Suivant affichés par NavigationWindow en définissant la valeur de la propriété ShowsNavigationUI sur false.

Vous pouvez également utiliser la prise en charge de la personnalisation dans WPF pour remplacer l’interface utilisateur du NavigationWindow lui-même.

La classe Frame

Le navigateur et NavigationWindow sont des fenêtres qui hébergent du contenu navigable. Dans certains cas, les applications ont du contenu qui n’a pas besoin d’être hébergé par une fenêtre entière. Au lieu de cela, ce contenu doit être hébergé à l’intérieur d’autres contenus. Vous pouvez insérer du contenu navigable dans d’autres contenus à l’aide de la Frame classe. Frame fournit la même prise en charge que NavigationWindow et les XBAPs.

L’exemple suivant montre comment ajouter un Frame à un Page élément de manière déclarative à l’aide de l’élément Frame .

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page that Hosts a Frame"
  WindowWidth="250"
  WindowHeight="250">

<Frame Source="FramePage1.xaml" />

</Page>

Ce marquage définit l’attribut Source de l’élément Frame avec un URI de pack pour le Page vers lequel le Frame doit initialement naviguer. La figure suivante montre un XBAP avec un Page qui a un Frame ayant navigué entre plusieurs pages.

Vous n’avez pas seulement à utiliser Frame à l’intérieur du contenu d’un Page. Il est également courant d'héberger un Frame à l'intérieur du contenu d'un Window.

Par défaut, Frame utilise uniquement son propre journal en l’absence d’un autre journal. Si un Frame fait partie du contenu qui est hébergé à l’intérieur soit d’un NavigationWindow soit d’un XBAP, Frame utilise le journal qui appartient au NavigationWindow ou au XBAP. Parfois, cependant, il Frame peut être nécessaire d’être responsable de son propre journal. L'une des raisons de le faire est de permettre la navigation du journal dans les pages hébergées par un Frame. Ceci est illustré par la figure suivante.

Dans ce cas, vous pouvez configurer Frame pour utiliser son propre journal en définissant la propriété JournalOwnership de Frame sur OwnsJournal. Ceci est illustré dans le balisage suivant.

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page that Hosts a Frame"
  WindowWidth="250"
  WindowHeight="250">

<Frame Source="FramePage1.xaml" JournalOwnership="OwnsJournal" />

</Page>

La figure suivante illustre l'effet de la navigation au sein d'un Frame qui utilise son propre journal.

Notez que les entrées de journal sont affichées par l’interface utilisateur de navigation dans l’explorateur FrameInternet, plutôt que par Internet Explorer.

Si votre expérience utilisateur nécessite qu’un Frame fournisse son propre journal sans afficher l'interface de navigation, vous pouvez masquer l'interface de navigation en définissant NavigationUIVisibility sur Hidden. Ceci est illustré dans le balisage suivant.

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page that Hosts a Frame"
  WindowWidth="250"
  WindowHeight="250">

<Frame 
  Source="FramePage1.xaml" 
  JournalOwnership="OwnsJournal" 
  NavigationUIVisibility="Hidden" />

</Page>

Hôtes de navigation

Frame et NavigationWindow sont des classes appelées hôtes de navigation. Un hôte de navigation est une classe qui peut accéder au contenu et l’afficher. Pour ce faire, chaque hôte de navigation utilise son propre NavigationService et journal. La construction de base d’un hôte de navigation est illustrée dans la figure suivante.

Essentiellement, cela permet NavigationWindow et Frame de fournir la même prise en charge de navigation qu’un XBAP fournit lorsqu’il est hébergé dans le navigateur.

En plus d'utiliser NavigationService et un journal, les hôtes de navigation implémentent les mêmes membres que NavigationService. Ceci est illustré par la figure suivante.

Cela vous permet de programmer la prise en charge de la navigation directement contre eux. Vous pouvez envisager cela si vous devez fournir une interface utilisateur de navigation personnalisée pour un Frame hébergé dans un Window. En outre, les deux types implémentent des membres supplémentaires liés à la navigation, notamment BackStack (NavigationWindow.BackStack, Frame.BackStack) et ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), qui vous permettent d’énumérer les entrées de journal dans la pile arrière et la pile avant, respectivement.

Comme mentionné précédemment, plusieurs journaux peuvent exister dans une application. La figure suivante fournit un exemple de cas où cela peut se produire.

Navigation vers le contenu autre que les pages XAML

Tout au long de cette rubrique, Page les XBAPs de pack ont été utilisés pour illustrer les différentes fonctionnalités de navigation de WPF. Toutefois, un Page, lorsqu'il est compilé dans une application, n'est pas le seul type de contenu auquel il est possible de naviguer, et les XBAPs empaquetés ne sont pas le seul moyen d'identifier le contenu.

Comme le montre cette section, vous pouvez également accéder à des fichiers XAML libres, des fichiers HTML et des objets.

Navigation vers des fichiers XAML libres

Un fichier XAML libre est un fichier présentant les caractéristiques suivantes :

• Contient uniquement du code XAML (autrement dit, aucun code).

• A une déclaration d’espace de noms appropriée.

• Possède l'extension de nom de fichier .xaml.

Par exemple, considérez le contenu suivant stocké sous la forme d’un fichier XAML libre, Person.xaml.

<!-- Person.xaml -->
<TextBlock xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <TextBlock FontWeight="Bold">Name:</TextBlock>
  <TextBlock>Nancy Davolio</TextBlock>
  <LineBreak />
  <TextBlock FontWeight="Bold">Favorite Color:</TextBlock>
  <TextBlock>Yellow</TextBlock>
</TextBlock>

Lorsque vous double-cliquez sur le fichier, le navigateur s’ouvre et navigue vers et affiche le contenu. Ce cas est illustré dans la figure suivante.

Vous pouvez afficher un fichier XAML libre à partir des éléments suivants :

• Site Web sur l’ordinateur local, l’intranet ou Internet.

• Un partage de fichiers UNC (Universal Naming Convention).

• Disque local.

Un fichier XAML libre peut être ajouté aux favoris du navigateur ou être la page d’accueil du navigateur.

L’une des limitations relatives au code XAML libre est que vous ne pouvez héberger que du contenu sécurisé pour s’exécuter dans une confiance partielle. Par exemple, Window ne peut pas être l’élément racine d’un fichier XAML libre. Pour plus d’informations, consultez Sécurité de confiance partielle WPF.

Navigation vers des fichiers HTML à l’aide d’un frame

Comme vous pouvez vous y attendre, vous pouvez également accéder au code HTML. Vous devez simplement fournir un URI qui utilise le schéma http. Par exemple, le code XAML suivant montre un Frame qui navigue vers une page HTML.

<Frame Source="http://www.microsoft.com/default.aspx" />

La navigation vers HTML nécessite des autorisations spéciales. Par exemple, vous ne pouvez pas naviguer à partir d'un XBAP qui s'exécute dans la sandbox de sécurité de la zone Internet à confiance partielle. Pour plus d’informations, consultez Sécurité de confiance partielle WPF.

Navigation vers des fichiers HTML à l’aide du contrôle WebBrowser

Le WebBrowser contrôle prend en charge l'hébergement de documents HTML, la navigation et l'interopérabilité entre les scripts et les codes managés. Pour plus d’informations sur le WebBrowser contrôle, consultez WebBrowser.

Comme Frame, la navigation vers HTML à l'aide de WebBrowser nécessite des autorisations spéciales. Par exemple, à partir d’une application de confiance partielle, vous ne pouvez accéder qu’au code HTML situé sur le site d’origine. Pour plus d’informations, consultez Sécurité de confiance partielle WPF.

Navigation vers des objets personnalisés

Si vous avez des données stockées en tant qu’objets personnalisés, une façon d’afficher ces données consiste à créer un Page contenu lié à ces objets (voir Vue d’ensemble de la liaison de données). Si vous n’avez pas besoin de la surcharge de création d’une page entière pour afficher les objets, vous pouvez y accéder directement.

Considérez la Person classe implémentée dans le code suivant.

using System.Windows.Media;

namespace SDKSample
{
    public class Person
    {
        string name;
        Color favoriteColor;

        public Person() { }
        public Person(string name, Color favoriteColor)
        {
            this.name = name;
            this.favoriteColor = favoriteColor;
        }

        public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }

        public Color FavoriteColor
        {
            get { return this.favoriteColor; }
            set { this.favoriteColor = value; }
        }
    }
}

Namespace SDKSample
    Public Class Person
        Private _name As String
        Private _favoriteColor As Color

        Public Sub New()
        End Sub
        Public Sub New(ByVal name As String, ByVal favoriteColor As Color)
            Me._name = name
            Me._favoriteColor = favoriteColor
        End Sub

        Public Property Name() As String
            Get
                Return Me._name
            End Get
            Set(ByVal value As String)
                Me._name = value
            End Set
        End Property

        Public Property FavoriteColor() As Color
            Get
                Return Me._favoriteColor
            End Get
            Set(ByVal value As Color)
                Me._favoriteColor = value
            End Set
        End Property
    End Class
End Namespace

Pour y accéder, vous appelez la NavigationWindow.Navigate méthode, comme illustré par le code suivant.

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.HomePage"
  WindowTitle="Page that Navigates to an Object">

<Hyperlink Name="hyperlink" Click="hyperlink_Click">
  Navigate to Nancy Davolio
</Hyperlink>

</Page>

using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace SDKSample
{
    public partial class HomePage : Page
    {
        public HomePage()
        {
            InitializeComponent();
        }

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            Person person = new Person("Nancy Davolio", Colors.Yellow);
            this.NavigationService.Navigate(person);
        }
    }
}

Namespace SDKSample
    Partial Public Class HomePage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            Dim person As New Person("Nancy Davolio", Colors.Yellow)
            Me.NavigationService.Navigate(person)
        End Sub
    End Class
End Namespace

La figure suivante présente le résultat.

À partir de cette figure, vous pouvez voir que rien d’utile n’est affiché. En fait, la valeur affichée est la valeur de retour de la méthode pour l’objet ToStringPerson ; par défaut, il s’agit de la seule valeur que WPF peut utiliser pour représenter votre objet. Vous pouvez remplacer la ToString méthode pour retourner des informations plus significatives, bien qu’elle ne soit toujours qu’une valeur de chaîne. Une technique que vous pouvez utiliser qui tire parti des fonctionnalités de présentation de WPF consiste à utiliser un modèle de données. Vous pouvez implémenter un modèle de données que WPF peut associer à un objet d’un type particulier. Le code suivant montre un modèle de données pour l’objet Person .

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample" 
    x:Class="SDKSample.App"
    StartupUri="HomePage.xaml">

  <Application.Resources>

    <!-- Data Template for the Person Class -->
    <DataTemplate DataType="{x:Type local:Person}">
      <TextBlock xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
        <TextBlock FontWeight="Bold">Name:</TextBlock>
        <TextBlock Text="{Binding Path=Name}" />
        <LineBreak />
        <TextBlock FontWeight="Bold">Favorite Color:</TextBlock>
        <TextBlock Text="{Binding Path=FavoriteColor}" />
      </TextBlock>
    </DataTemplate>
    
  </Application.Resources>

</Application>

Ici, le modèle de données est associé au type Person par l’intermédiaire de l'extension de balisage x:Type dans l’attribut DataType. Le modèle de données lie ensuite des TextBlock éléments (voir TextBlock) aux propriétés de la Person classe. La figure suivante montre l’apparence mise à jour de l’objet Person .

L’avantage de cette technique est la cohérence que vous gagnez en étant en mesure de réutiliser le modèle de données pour afficher vos objets de manière cohérente n’importe où dans votre application.

Pour plus d’informations sur les modèles de données, consultez Vue d’ensemble de la création de modèles de données.

Sécurité

La prise en charge de la navigation WPF permet aux XBAPs d’être accessibles sur Internet et permet aux applications d’héberger du contenu tiers. Pour protéger les applications et les utilisateurs contre le comportement dangereux, WPF fournit une variété de fonctionnalités de sécurité décrites dans Security et WPF Partial Trust Security.

Voir aussi

• SetCookie
• GetCookie
• Vue d’ensemble de la gestion des applications
• URI à en-tête pack dans WPF
• Vue d’ensemble de la navigation structurée
• Vue d’ensemble des topologies de navigation
• Sujets de type "comment faire"
• déploiement d’une application WPF