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 vers un fragment

• Service de navigation

• Navigation par programmation avec le service de navigation

• Durée de vie de la navigation

• Mémorisation de la navigation avec le journal

• Durée de vie d’une page et le 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 Pagede , vous pouvez implémenter de manière déclarative une page navigable de contenu XAML à l’aide du balisage comme suit.

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

Une Page implémentation dans le balisage XAML a Page comme élément racine et nécessite la déclaration d’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 contrôle peut également afficher des contrôles 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 d’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 nécessaire :

• Dans le balisage, l’élément Page doit inclure l’attribut x:Class. Lorsque l’application est générée, l’existence du fichier de x:Class balisage entraîne la création d’une partial classe qui dérive et Page porte le nom spécifié par l’attribut dans le x:Class moteur de build Microsoft (MSBuild). 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 du code-behind, la classe doit être une classe partial portant le nom spécifié par l’attribut x:Class dans le balisage, et 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 du code-behind, la classe Page doit implémenter un constructeur qui appelle la méthode InitializeComponent. InitializeComponent est implémenté par la classe générée partial du fichier de balisage pour inscrire les événements et définir les 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 Page à laquelle une application accède, vous devez configurer le démarrage Page.

Configuration d’une page de démarrage

Les adresses XBAP nécessitent l’hébergement d’une certaine quantité d’infrastructure d’application 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 Page automatiquement chargé lors du lancement du 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 accédé 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 vous pouvez modifier le titre en définissant la WindowTitle propriété. 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 affiché dans l’illustration 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 de pack de l’option Page à accéder, 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 a un Hyperlink.

Comme vous le souhaitez, le fait de cliquer sur les Hyperlink causes du XBAP pour accéder à celui Page identifié par l’attribut NavigateUri . En outre, le XBAP ajoute une entrée pour la Page liste Pages récentes dans Internet Explorer. Ce cas est illustré dans la figure suivante.

Ainsi que la prise en charge de la navigation d’un à l’autre Page , Hyperlink prend également en charge la navigation par fragments.

Navigation vers un fragment

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 accéder Hyperlink à un fragment de contenu, l’attribut NavigateUri doit inclure les éléments suivants :

• URI du fragment de Page contenu vers lequel accéder.

• un 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>

Service de navigation

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 une prise en charge de niveau supérieur pour le suivi et l’influence d’une demande de navigation.

Lorsqu’un Hyperlink clic est fait, WPF appelle NavigationService.Navigate pour localiser et télécharger l’URI Page du pack spécifié. 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 NavigationService si la navigation est implémentée de manière déclarative dans le balisage à l’aide Hyperlinkde , car Hyperlink elle utilise le NavigationService 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 constructeur sans paramètre à l’aide d’un constructeur sans paramètre.

• Lorsque vous devez définir des propriétés sur le Page serveur avant de l’accéder.

• Lorsque l’utilisateur Page doit accéder à celui-ci 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 accédé à un particulier Page, vous passez une référence à l’argument Page de la GetNavigationService méthode. Le code suivant montre comment obtenir le NavigationService code actuel Page.

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é. Cela est illustré par 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 par programmation vers un objet 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 constructeur 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 l’utilisateur clique dessus, la Hyperlink navigation est lancée en instanciant la Page navigation pour accéder à l’utilisation du constructeur sans paramètre et en appelant la NavigationService.Navigate Page méthode. Navigate accepte une référence à l’objet vers lequel accéder NavigationService , plutôt qu’un URI de pack.

Navigation par programmation avec un URI à en-tête 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. Cela est illustré par 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 active

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 la navigation

Comme vous l’avez vu, il existe de nombreuses façons de démarrer la navigation. 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 quand une nouvelle navigation est demandée. Permet d’annuler la navigation.

• NavigationProgress. Se produit périodiquement au cours d'un téléchargement, pour donner des informations sur la progression de la navigation.

• Navigated. Se produit quand 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 en cas d’erreur pendant la navigation vers le contenu demandé.

• LoadCompleted. Se produit quand le contenu cible de la navigation est chargé et analysé, et que son rendu a commencé.

• FragmentNavigation. Se produit au début de la navigation vers un fragment de contenu, c’est-à-dire :

  • immédiatement, si le fragment désiré est dans le contenu actuel ;

  • après le chargement du contenu source, si le fragment désiré est dans un autre contenu.

Les événements de navigation sont générés dans l’ordre indiqué sur la figure suivante.

En général, il Page n’est pas préoccupé par 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 NavigationService qu’il déclenche un événement, la Application classe déclenche l’événement correspondant. Frame et NavigationWindow offrent les mêmes événements pour détecter la navigation dans leurs étendues respectives.

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. Cela est illustré par 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.

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 accédez du courant Page à un nouveau Page ou vers un transfert vers un élément existant Page, le courant Page est ajouté à la pile arrière. Lorsque vous naviguez du retour actuel à l’ancienPage, le courant Page est ajouté à la pile vers l’avant.Page La pile Back, la pile Forward et les fonctionnalités qui permettent de les gérer représentent 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. Ces boutons sont représentés 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 explicite pour l’utilisateur. Heureusement, vous pouvez changer le texte à l’aide d’une des options suivantes :

1. Valeur d’attribut jointe JournalEntry.Name .

2. Valeur de l’attribut Page.Title .

3. Valeur Page.WindowTitle d’attribut et URI pour le fichier actif Page.

4. URI pour le Pagefichier actif . (Par défaut)

L’ordre dans lequel les options sont listées correspond à l’ordre de priorité de recherche du 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 pages Back, Forward et Recent 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 de manière déclarative la prise en charge de la navigation dans les journaux à 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

Vous pouvez également manipuler le journal par programmation, comme indiqué dans Conservation de l’état du contenu avec l’historique de navigation, plus loin dans cette rubrique.

Durée de vie d’une page et le journal

Considérez un XBAP avec plusieurs pages qui contiennent du contenu enrichi, notamment des graphiques, des animations et des supports. L’encombrement mémoire de pages comme celles-ci peut être assez important, en particulier si des médias audio et vidéo sont utilisés. Étant donné que le journal « mémorise » les pages qui ont été accédé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 accédée, ses Page métadonnées sont utilisées pour créer une nouvelle instance du fichier spécifié Page. Par conséquent, chaque Page navigation a la durée de vie illustrée par la figure suivante.

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 Page élément conservé est subtilement différente de celle qui n’est pas. La première fois qu’un Page qui est conservé en vie est accédé, il est instancié comme un Page qui n’est pas conservé en vie. Toutefois, étant donné qu’une instance du Page journal est conservée, 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’utilisateur Page est redirigé, vous devez le déplacer du constructeur vers un gestionnaire pour l’événement Loaded . Comme indiqué dans la figure suivante, les événements et Unloaded les Loaded événements sont toujours déclenchés chaque fois qu’un Page accès est à partir et à partir, respectivement.

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

• stocker une référence le concernant, même partiellement ;

• inscrire des gestionnaires d’événements auprès d’événements qu’il n’implémente pas.

L’une ou l’autre de ces références crée des références qui forcent la Page conservation en mémoire, même après sa suppression du journal.

En règle générale, vous devez préférer le comportement par défaut Page de ne pas conserver une Page vie. Toutefois, cela a des conséquences sur l’état, comme le décrit la section suivante.

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

Page S’il n’est pas conservé actif et qu’il a 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 à l’utilisateur Page? Du point de vue de l’expérience utilisateur, l’utilisateur s’attend à voir les données qu’il a entrées. Malheureusement, étant donné qu’une nouvelle instance de l’instance Page est créée avec chaque navigation, les contrôles qui ont collecté les données sont réintégé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 le courant 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 accédé.

Lorsque la page Page est renvoyée, à l’aide du 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 retour 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 contrôle utilise ces contrôles, les données entrées dans ces contrôles sont mémorisées dans Page les navigations, comme illustré par la couleurListBox favorite 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 vous Page devez mémoriser dans les navigations comprend plusieurs éléments de données, vous pouvez constater qu’il est moins gourmand en code pour 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 à stocker des cookies, qui sont créés, mis à jour et supprimés à l’aide des méthodes et GetCookie des SetCookie méthodes. 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.

Valeur de nom =

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 s’appelle un cookie de session.

Pour stocker un cookie dans des sessions d’application, vous devez lui ajouter une date d’expiration au format suivant.

VALEUR NAME = ; 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 cookie de ce type s’appelle un cookie persistant, car il persiste au fil des 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 adresses XBAPs et les pages HTML du même domaine peuvent créer et partager des cookies.

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

• Les XBAPs de niveau supérieur et les adresses XBAP hébergées dans 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 adresses XBAP tierces et tierces.

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 conserver la Page vie ; si ce n’est pas le cas, la prochaine fois que vous accédez à l’élément Page, WPF réinitie le Page à l’aide du constructeur sans paramètre.

Page Vous pouvez également implémenter des propriétés définies avec les données qui doivent être passées. Les choses deviennent difficiles, cependant, quand un Page besoin de transmettre des données à l’accès Page à celui-ci. Le problème est que la navigation ne prend pas en charge les mécanismes de prise en charge en mode natif pour garantir qu’une Page personne sera retournée après avoir accédé à partir de. Pour l’essentiel, la navigation ne prend pas en charge la sémantique d’appel/de retour. 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.

NavigationWindow, classe

À ce stade, vous avez découvert la gamme des services de navigation que vous êtes le plus susceptible d’utiliser pour générer des applications au contenu navigable. Ces services ont été abordés dans le contexte de XBAPs, bien qu’ils ne soient pas limités aux adresses 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 :

• Dictionnaire des synonymes : pour naviguer parmi des choix de mots.

• Explorateur de fichiers : pour naviguer parmi des fichiers et des dossiers.

• Assistants : pour décomposer une tâche complexe en plusieurs pages parmi lesquelles il est possible de 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. NavigationWindowWindow dérive et l’étend avec la même prise en charge de la navigation que les XBAPs fournissent. 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. Cela est illustré par 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 fenêtre d’application principale est la fenêtre principale, vous pouvez utiliser l’attribut pour le StartupUri lancer. Ce cas de figure 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 titre a un titre, même s’il n’a pas été défini dans le NavigationWindow code d’implémentation 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>

La définition des WindowWidth propriétés 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 Pagefichier . Le balisage suivant montre comment y parvenir.

<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()

L’illustration suivante montre 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 le montre la figure suivante.

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

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

Frame, classe

Le navigateur et NavigationWindow les fenêtres hébergent du contenu navigable. Dans certains cas, les applications ont un contenu qui n’a pas besoin d’être hébergé par une fenêtre entière. À la place, ce contenu est hébergé dans un autre contenu. 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 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 balisage définit l’attribut Source de l’élément Frame avec un URI de pack pour celui auquel il Page Frame doit d’abord accéder. La figure suivante montre un XBAP avec un Page qui a une Frame navigation 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 contenu à l’intérieur d’un Window.

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

Dans ce cas, vous pouvez configurer l’option Frame pour utiliser son propre journal en définissant la JournalOwnership propriété sur OwnsJournalFrame . Ce cas de figure 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 naviguer dans un Frame journal 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 de Frame fournir son propre journal sans afficher l’interface utilisateur de navigation, vous pouvez masquer l’interface utilisateur de navigation en définissant la NavigationUIVisibility Hiddenvaleur . Ce cas de figure 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 naviguer vers un contenu et l’afficher. Pour ce faire, chaque hôte de navigation utilise son propre NavigationService 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.

Outre l’utilisation NavigationService et un journal, les hôtes de navigation implémentent les mêmes membres que ceux qui NavigationService implémentent. Cela est illustré par la figure suivante.

Cela vous permet de programmer la prise en charge de la navigation directement par rapport à 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 cela a déjà été mentionné, plusieurs journaux peuvent exister dans une application. L’exemple suivant illustre ce cas de figure.

Navigation vers un autre contenu que des 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 élément compilé dans une application n’est pas le seul type de contenu qui peut être accédé, et les XBAPs de pack ne sont pas la seule façon 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 libre

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

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

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

• Son nom de fichier porte l’extension .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>

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

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

• site web sur la machine locale, un 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 de WPF.

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

Comme vous pouvez vous 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 une Frame page HTML qui accède à 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 le bac à sable de sécurité de confiance partielle de la zone Internet. Pour plus d’informations, consultez Sécurité de confiance partielle de WPF.

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

Le contrôle prend en charge l’interopérabilité WebBrowser entre l’hébergement, la navigation et le script et le code managé HTML. Pour plus d’informations sur le WebBrowser contrôle, consultez WebBrowser.

Par exemple Frame, la navigation au format HTML nécessite WebBrowser 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 de 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). En revanche, si vous n’avez pas besoin de la charge de traitement supplémentaire liée à la création d’une page entière juste pour afficher les objets, vous pouvez naviguer directement vers ces derniers.

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

L’illustration suivante montre le résultat.

Dans cette illustration, 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 ToString Person ; 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 Person type à l’aide de l’extension de x:Type balisage 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 .

Cette technique présente un avantage, elle vous permet d’afficher vos objets de manière cohérente dans la totalité de votre application grâce à la réutilisation du modèle de données.

Pour plus d’informations sur les modèles de données, consultez Vue d’ensemble des 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 d’applications
• URI à en-tête pack dans WPF
• Vue d’ensemble de la navigation structurée
• Vue d’ensemble des topologies de navigation
• Guides pratiques
• Déploiement d’une application WPF