Vue d’ensemble de la navigation structurée

Le contenu pouvant être hébergé par une application de navigateur XAML (XBAP), un Frameou un NavigationWindow est composé de pages qui peuvent être identifiées par des identifiants uniformes de ressources (URI) du pack et auxquelles on peut accéder via des liens hypertexte. La structure des pages et les façons dont elles peuvent être parcourues, telles que définies par les liens hypertexte, est appelée topologie de navigation. Une telle topologie convient à divers types d’applications, en particulier ceux qui parcourent les documents. Pour ces applications, l’utilisateur peut naviguer d’une page à une autre page sans avoir besoin de connaître quoi que ce soit sur l’autre.

Toutefois, d’autres types d’applications ont des pages qui doivent savoir quand elles ont été parcourues. Par exemple, considérez une application de ressources humaines qui a une page pour répertorier tous les employés d’une organisation : la page « Répertorier les employés ». Cette page peut également permettre aux utilisateurs d’ajouter un nouvel employé en cliquant sur un lien hypertexte. Lorsque vous cliquez sur ce bouton, la page accède à une page « Ajouter un employé » pour collecter les détails du nouvel employé et les renvoyer à la page « Répertorier les employés » pour créer le nouvel employé et mettre à jour la liste. Ce style de navigation est similaire à l’appel d’une méthode pour effectuer un traitement et retourner une valeur, appelée programmation structurée. Par conséquent, ce style de navigation est appelé navigation structurée.

La classe Page n’implémente pas la prise en charge de la navigation structurée. Au lieu de cela, la classe PageFunction<T> dérive de Page et l’étend avec les constructions de base requises pour la navigation structurée. Cette rubrique montre comment établir une navigation structurée à l’aide de PageFunction<T>.

Navigation structurée

Lorsqu’une page appelle une autre page dans une navigation structurée, certains ou tous les comportements suivants sont requis :

• La page appelante accède à la page appelée, en passant éventuellement des paramètres requis par la page appelée.

• La page appelée, quand un utilisateur a fini d’utiliser la page appelante, revient spécifiquement à la page appelante et, éventuellement :

  • Retour d’informations d’état qui décrivent la façon dont la page appelante a été terminée (par exemple, si un utilisateur a appuyé sur un bouton OK ou un bouton Annuler).

  • Renvoi de ces données collectées à partir de l’utilisateur (par exemple, les détails du nouvel employé).

• Lorsque la page appelante retourne à la page appelée, la page appelée est supprimée de l’historique de navigation pour isoler une instance d’une page appelée d’une autre.

Ces comportements sont illustrés par la figure suivante :

Vous pouvez implémenter ces comportements à l’aide d’un PageFunction<T> comme page appelée.

Navigation structurée avec PageFunction

Cette rubrique montre comment implémenter les mécanismes de base de la navigation structurée impliquant un seul PageFunction<T>. Dans cet exemple, un Page appelle un PageFunction<T> pour obtenir de l'utilisateur une valeur String et la retourner.

Création d’une page d’appel

La page qui appelle un PageFunction<T> peut être un Page ou un PageFunction<T>. Dans cet exemple, il s’agit d’un Page, comme illustré dans le code suivant.

<Page 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="StructuredNavigationSample.CallingPage"
    WindowTitle="Calling Page" 
    WindowWidth="250" WindowHeight="150">

</Page>

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

namespace StructuredNavigationSample
{
    public partial class CallingPage : Page
    {
        public CallingPage()
        {
            InitializeComponent();

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CallingPage
    Inherits Page
    Public Sub New()
        Me.InitializeComponent()

}

End Sub

    }
}

End Class

End Namespace

Création d’une fonction de page à appeler

Étant donné que la page appelante peut utiliser la page appelée pour collecter et retourner des données à partir de l’utilisateur, PageFunction<T> est implémentée en tant que classe générique dont l’argument de type spécifie le type de la valeur retournée par la page appelée. Le code suivant montre l’implémentation initiale de la page appelée, à l’aide d’un PageFunction<T>, qui renvoie un String.

<PageFunction
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:sys="clr-namespace:System;assembly=mscorlib" 
    x:Class="StructuredNavigationSample.CalledPageFunction"
    x:TypeArguments="sys:String"
    Title="Page Function" 
    WindowWidth="250" WindowHeight="150">

  <Grid Margin="10">

    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="Auto" />
      <ColumnDefinition />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition />
    </Grid.RowDefinitions>

    <!-- Data -->
    <Label Grid.Column="0" Grid.Row="0">DataItem1:</Label>
    <TextBox Grid.Column="1" Grid.Row="0" Name="dataItem1TextBox"></TextBox>

    <!-- Accept/Cancel buttons -->
    <TextBlock Grid.Column="1" Grid.Row="1" HorizontalAlignment="Right">
      <Button Name="okButton" IsDefault="True" MinWidth="50">OK</Button>
      <Button Name="cancelButton" IsCancel="True" MinWidth="50">Cancel</Button>
    </TextBlock>

  </Grid>

</PageFunction>

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

namespace StructuredNavigationSample
{
    public partial class CalledPageFunction : PageFunction<String>
    {
        public CalledPageFunction()
        {
            InitializeComponent();
        }

Imports System.Windows
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CalledPageFunction
    Inherits PageFunction(Of String)
    Public Sub New()
        Me.InitializeComponent()
    End Sub

    }
}

End Class

End Namespace

La déclaration d’un PageFunction<T> est similaire à la déclaration d’un Page avec l’ajout des arguments de type. Comme vous pouvez le voir dans l’exemple de code, les arguments de type sont spécifiés dans le balisage XAML, à l’aide de l’attribut x:TypeArguments et du code-behind, à l’aide de la syntaxe d’argument de type générique standard.

Vous n’avez pas besoin d’utiliser uniquement des classes .NET Framework en tant qu’arguments de type. Un PageFunction<T> peut être appelé pour collecter des données spécifiques au domaine qui sont abstraites en tant que type personnalisé. Le code suivant montre comment utiliser un type personnalisé comme argument de type pour un PageFunction<T>.

namespace SDKSample
{
    public class CustomType
    {

Public Class CustomType

    }
}

End Class

<PageFunction
    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.CustomTypePageFunction"
    x:TypeArguments="local:CustomType">

</PageFunction>

using System.Windows.Navigation;

namespace SDKSample
{
    public partial class CustomTypePageFunction : PageFunction<CustomType>
    {

Partial Public Class CustomTypePageFunction
    Inherits System.Windows.Navigation.PageFunction(Of CustomType)

    }
}

End Class

Les arguments de type du PageFunction<T> fournissent la base de la communication entre une page appelante et la page appelée, qui sont abordés dans les sections suivantes.

Comme vous le verrez, le type qui est identifié par la déclaration d’un PageFunction<T> joue un rôle important dans le renvoi de données d’un PageFunction<T> à la page appelante.

Appel d’une PageFunction et passage des paramètres

Pour appeler une page, la page appelante doit instancier la page appelée et y accéder à l’aide de la méthode Navigate. Cela permet à la page appelante de transmettre les données initiales à la page appelée, telles que les valeurs par défaut des données collectées par la page appelée.

Le code suivant montre la page appelée avec un constructeur sans paramètre pour accepter les paramètres de la page appelante.

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

namespace StructuredNavigationSample
{
    public partial class CalledPageFunction : PageFunction<String>
    {

Imports System.Windows
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CalledPageFunction
    Inherits PageFunction(Of String)

public CalledPageFunction(string initialDataItem1Value)
{
    InitializeComponent();

Public Sub New(ByVal initialDataItem1Value As String)
    Me.InitializeComponent()

    // Set initial value
    this.dataItem1TextBox.Text = initialDataItem1Value;
}

    ' Set initial value
    Me.dataItem1TextBox.Text = initialDataItem1Value
End Sub

    }
}

End Class

End Namespace

Le code suivant montre la page appelante qui gère l’événement Click du Hyperlink pour instancier la page appelée et lui transmettre une valeur de chaîne initiale.

<Hyperlink Name="pageFunctionHyperlink">Call Page Function</Hyperlink>

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

namespace StructuredNavigationSample
{
    public partial class CallingPage : Page
    {
        public CallingPage()
        {
            InitializeComponent();
            this.pageFunctionHyperlink.Click += new RoutedEventHandler(pageFunctionHyperlink_Click);
        }
        void pageFunctionHyperlink_Click(object sender, RoutedEventArgs e)
        {

            // Instantiate and navigate to page function
            CalledPageFunction CalledPageFunction = new CalledPageFunction("Initial Data Item Value");

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CallingPage
    Inherits Page
    Public Sub New()
        Me.InitializeComponent()
        AddHandler Me.pageFunctionHyperlink.Click, New RoutedEventHandler(AddressOf Me.pageFunctionHyperlink_Click)
    End Sub
    Private Sub pageFunctionHyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

}

End Sub

    }
}

End Class

End Namespace

Vous n’êtes pas obligé de passer des paramètres à la page appelée. Au lieu de cela, vous pouvez effectuer les opérations suivantes :

• À partir de la page appelante :

  1. Instanciez le PageFunction<T> appelé à l’aide du constructeur sans paramètre.

  2. Stockez les paramètres dans Properties.

  3. Accédez au PageFunction<T> appelé.

• Depuis le PageFunction<T> appelé :

  • Récupérez et utilisez les paramètres stockés dans Properties.

Toutefois, comme vous le verrez bientôt, vous aurez toujours besoin d’utiliser le code pour instancier et accéder à la page appelée pour collecter les données retournées par la page appelée. Pour cette raison, le PageFunction<T> doit être maintenu en vie ; sinon, la prochaine fois que vous accédez au PageFunction<T>, WPF instancie l'PageFunction<T> à l’aide du constructeur sans paramètre.

Avant que la page appelée puisse retourner, elle doit toutefois retourner des données qui peuvent être récupérées par la page appelante.

Renvoi du résultat et des données d'une tâche vers une page appelante

Une fois que l’utilisateur a terminé d’utiliser la page appelée, indiqué dans cet exemple en appuyant sur les boutons OK ou Annuler, la page appelée doit retourner. Étant donné que la page appelante a utilisé la page appelée pour collecter des données à partir de l’utilisateur, la page appelante nécessite deux types d’informations :

1. Indique si l’utilisateur a annulé la page appelée (en appuyant sur le bouton OK ou sur le bouton Annuler dans cet exemple). Cela permet à la page appelante de déterminer s’il faut traiter les données collectées par la page appelante auprès de l’utilisateur.

2. Données fournies par l’utilisateur.

Pour retourner des informations, PageFunction<T> implémente la méthode OnReturn. Le code suivant montre comment l’appeler.

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

namespace StructuredNavigationSample
{
    public partial class CalledPageFunction : PageFunction<String>
    {

Imports System.Windows
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CalledPageFunction
    Inherits PageFunction(Of String)

        void okButton_Click(object sender, RoutedEventArgs e)
        {
            // Accept when Ok button is clicked
            OnReturn(new ReturnEventArgs<string>(this.dataItem1TextBox.Text));
        }

        void cancelButton_Click(object sender, RoutedEventArgs e)
        {
            // Cancel
            OnReturn(null);
        }
    }
}

    Private Sub okButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        ' Accept when Ok button is clicked
        Me.OnReturn(New ReturnEventArgs(Of String)(Me.dataItem1TextBox.Text))
    End Sub

    Private Sub cancelButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        ' Cancel
        Me.OnReturn(Nothing)
    End Sub
End Class

End Namespace

Dans cet exemple, si un utilisateur appuie sur le bouton Annuler, une valeur de null est retournée à la page appelante. Si le bouton OK est appuyé à la place, la valeur de chaîne fournie par l’utilisateur est retournée. OnReturn est une méthode protected virtual que vous appelez pour renvoyer vos données à la page appelante. Vos données doivent être empaquetées dans une instance du type ReturnEventArgs<T> générique, dont l’argument de type spécifie le type de valeur qui Result retourne. De cette façon, lorsque vous déclarez un PageFunction<T> avec un argument de type particulier, vous indiquez qu’un PageFunction<T> retourne une instance du type spécifié par l’argument de type. Dans cet exemple, l’argument de type et, par conséquent, la valeur de retour est de type String.

Lorsque OnReturn est appelée, la page appelante a besoin d’un moyen de recevoir la valeur de retour du PageFunction<T>. Pour cette raison, PageFunction<T> implémente l’événement Return afin que les pages appelantes puissent le gérer. Lorsque OnReturn est appelée, Return est déclenchée, de sorte que la page d’appel peut s’inscrire auprès de Return pour recevoir la notification.

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

namespace StructuredNavigationSample
{
    public partial class CallingPage : Page
    {

Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Navigation

Namespace StructuredNavigationSample

Public Class CallingPage
    Inherits Page

        void pageFunctionHyperlink_Click(object sender, RoutedEventArgs e)
        {

            // Instantiate and navigate to page function
            CalledPageFunction CalledPageFunction = new CalledPageFunction("Initial Data Item Value");
            CalledPageFunction.Return += pageFunction_Return;
            this.NavigationService.Navigate(CalledPageFunction);
        }
        void pageFunction_Return(object sender, ReturnEventArgs<string> e)
        {
            this.pageFunctionResultsTextBlock.Visibility = Visibility.Visible;

            // Display result
            this.pageFunctionResultsTextBlock.Text = (e != null ? "Accepted" : "Canceled");

            // If page function returned, display result and data
            if (e != null)
            {
                this.pageFunctionResultsTextBlock.Text += "\n" + e.Result;
            }
        }
    }
}

    Private Sub pageFunctionHyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        ' Instantiate and navigate to page function
        Dim calledPageFunction As New CalledPageFunction("Initial Data Item Value")
        AddHandler calledPageFunction.Return, New ReturnEventHandler(Of String)(AddressOf Me.calledPageFunction_Return)
        MyBase.NavigationService.Navigate(calledPageFunction)
    End Sub
    Private Sub calledPageFunction_Return(ByVal sender As Object, ByVal e As ReturnEventArgs(Of String))

        Me.pageFunctionResultsTextBlock.Visibility = Windows.Visibility.Visible

        ' Display result
        Me.pageFunctionResultsTextBlock.Text = IIf((Not e Is Nothing), "Accepted", "Canceled")

        ' If page function returned, display result and data
        If (Not e Is Nothing) Then
            Me.pageFunctionResultsTextBlock.Text = (Me.pageFunctionResultsTextBlock.Text & ChrW(10) & e.Result)
        End If

    End Sub
End Class

End Namespace

Suppression des pages de tâches lorsqu’une tâche se termine

Lorsqu’une page appelée est retournée et que l’utilisateur n’a pas annulé la page appelée, la page appelante traite les données fournies par l’utilisateur et est également retournée à partir de la page appelée. L’acquisition de données de cette façon est généralement une activité isolée ; lorsque la page appelée est retournée, la page appelante doit créer et accéder à une nouvelle page appelante pour capturer plus de données.

Toutefois, sauf si une page appelée est supprimée du journal, un utilisateur pourra revenir à une instance précédente de la page appelante. La propriété RemoveFromJournal détermine si un PageFunction<T> est conservé dans le journal. Par défaut, une fonction de page est automatiquement supprimée lorsque OnReturn est appelée, car RemoveFromJournal est défini sur true. Pour conserver une fonction de page dans l’historique de navigation après que OnReturn a été appelée, définissez RemoveFromJournal sur false.

Autres types de navigation structurée

Cette rubrique illustre l’utilisation la plus simple d’un PageFunction<T> pour prendre en charge la navigation structurée par appel/retour. Cette base vous offre la possibilité de créer des types plus complexes de navigation structurée.

Par exemple, parfois plusieurs pages sont requises par une page appelante pour collecter suffisamment de données auprès d’un utilisateur ou pour effectuer une tâche. En cas d’utilisation de plusieurs pages, on emploie le terme « Assistant ».

Dans d’autres cas, les applications peuvent avoir des topologies de navigation complexes qui dépendent de la navigation structurée pour fonctionner efficacement. Pour plus d’informations, consultez Vue d’ensemble des topologies de navigation.

Voir aussi

• PageFunction<T>
• NavigationService
• Vue d’ensemble des topologies de navigation