Vue d’ensemble de la navigation structurée

  • Article

Contenu pouvant être hébergé par une application de navigateur XAML (XBAP), un Frameou un NavigationWindow contenu composé de pages qui peuvent être identifiées par des URI (Uniform Resource Identifiers) de pack et qui sont redirigées par des liens hypertexte. La structure des pages et comment elles sont accessibles, tel que défini par des liens hypertexte, porte le nom de topologie de navigation. Une telle topologie convient à différents types d’applications, notamment celles permettant de parcourir des documents. Pour de telles applications, l’utilisateur peut naviguer d’une page à une autre page sans qu’une page ait besoin de savoir quoi que ce soit sur l’autre page.

Toutefois, d’autres types d’applications ont des pages qui ont besoin de savoir quand une navigation parmi les pages a eu lieu. Par exemple, considérez une application de ressources humaines ayant une page pour répertorier tous les employés d’une organisation, la page « Liste des employés ». Cette page pourrait également permettre aux utilisateurs d’ajouter un nouvel employé en cliquant sur un lien hypertexte. En cas de clic sur ce lien, l’utilisateur accède à une page « Ajouter un employé » pour recueillir les détails du nouvel employé et les retourner à la page « Liste des employés » afin de créer le nouvel employé et de mettre à jour la liste. Ce style de navigation s’apparente à l’appel d’une méthode pour effectuer un traitement et retourner une valeur, ce qui porte le nom de programmation structurée. Ce style de navigation est appelé navigation structurée.

La classe n’implémente pas la Page prise en charge de la navigation structurée. Au lieu de Page cela, la PageFunction<T> classe dérive 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 PageFunction<T>de .

Navigation structurée

Quand une page en appelle une autre dans une navigation structurée, certains ou tous les comportements suivants sont nécessaires :

  • La page appelante accède à la page appelée, éventuellement en passant les paramètres exigés par cette dernière.

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

    • Retourne des informations d’état qui décrivent comment la page appelante a été terminée (par exemple, si un utilisateur a appuyé sur un bouton OK ou Annuler)

    • Retourne les données recueillies auprès de l’utilisateur (par exemple, les détails du nouvel employé)

  • Quand la page appelante revient à la page appelée, celle-ci est supprimée de l’historique de navigation afin d’isoler une instance d’une page appelée d’une autre.

Ces comportements sont illustrés par la figure suivante :

Screenshot shows the flow between calling page and called page.

Vous pouvez implémenter ces comportements à l’aide d’une PageFunction<T> 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 appel PageFunction<T> a pour obtenir une String valeur de l’utilisateur et le retourner.

Création d’une page appelante

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> elle 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 retourne 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 pour fournir PageFunction<T> 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 identifié avec la déclaration d’un joue un PageFunction<T> rôle important dans le retour des données d’une PageFunction<T> page d’appel.

Appel de PageFunction et passage de paramètres

Pour appeler une page, la page appelante doit instancier la page appelée et y accéder à l’aide de la Navigate méthode. Cela permet à la page appelante de passer les données initiales à la page appelée, par exemple les valeurs par défaut des données recueillies 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 de l’instanciation Hyperlink de la page appelée et lui transmet 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 procéder comme suit :

Toutefois, comme vous le verrez bientôt, vous devrez quand même utiliser du code pour instancier et accéder à la page appelée afin de recueillir les données qu’elle a retournées. Pour cette raison, les PageFunction<T> besoins doivent être conservés en vie ; sinon, la prochaine fois que vous accédez au PageFunction<T>, WPF instancie l’utilisation PageFunction<T> du constructeur sans paramètre.

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

Retour de résultat de tâche et de données de tâche à une page appelante

Une fois que l’utilisateur a fini d’utiliser la page appelée, ce qui est indiqué dans cet exemple par un appui sur le bouton Annuler ou OK, la page appelée doit retourner. Étant donné que la page appelante a utilisé la page appelée pour recueillir des données auprès de l’utilisateur, la page appelante nécessite deux types d’informations :

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

  2. Les données qui ont été fournies par l’utilisateur.

Pour retourner des informations, PageFunction<T> implémente la OnReturn méthode. L’exemple de 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 l’utilisateur appuie sur le bouton Annuler, une valeur null est retournée à la page appelante. Si en revanche il appuie sur le bouton OK, la valeur de chaîne fournie par l’utilisateur est retournée. OnReturn est une protected virtual méthode que vous appelez pour renvoyer vos données à la page appelante. Vos données doivent être empaquetées dans une instance du type générique ReturnEventArgs<T> , 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> argument de type particulier, vous indiquez qu’une PageFunction<T> instance du type spécifiée par l’argument de type retourne une instance du type. Dans cet exemple, l’argument de type et, par conséquent, la valeur de retour est de type String.

Quand OnReturn elle 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 pour appeler des pages à gérer. Lorsque OnReturn l’appel est déclenché, Return la page appelante peut donc s’inscrire pour Return 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 de pages de tâche quand une tâche se termine

Quand une page appelée est retournée, et que l’utilisateur ne l’a pas annulée, la page appelante traite les données fournies par l’utilisateur et retournées par la page appelée. L’acquisition de données de cette manière est généralement une opération isolée. Quand la page appelée est retournée, la page appelante doit créer et naviguer vers une nouvelle page appelante pour capturer davantage 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. Indique si une PageFunction<T> valeur est conservée dans le journal est déterminée par la RemoveFromJournal propriété. Par défaut, une fonction de page est automatiquement supprimée lorsqu’elle OnReturn est appelée, car RemoveFromJournal elle est définie sur true. Pour conserver une fonction de page dans l’historique de navigation après OnReturn avoir été appelée, définie sur RemoveFromJournalfalse.

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 d’appel/retour. Cette base vous permet de créer des types de navigation structurée plus complexes.

Par exemple, parfois plusieurs pages sont requises par une page appelante pour recueillir 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