Übersicht über die strukturierte Navigation
Inhalte, die von einer XAML-Browseranwendung (XBAP), einem Frame oder einem NavigationWindow gehostet werden können, bestehen aus Seiten, die durch Uniform Resource Identifiers (URIs) identifiziert und durch Hyperlinks angesteuert werden können. Die Struktur von Seiten und die Art und Weise, wie sie durch Hyperlinks definiert werden können, wird als Navigationstopologie bezeichnet. Eine solche Topologie eignet sich für eine Vielzahl von Anwendungstypen, insbesondere für solche, die durch Dokumente navigieren. Für solche Anwendungen kann der Benutzer von einer Seite zu einer anderen Seite navigieren, ohne dass beide Seiten etwas über die andere wissen müssen.
Andere Arten von Anwendungen verfügen jedoch über Seiten, die wissen müssen, wann zwischen ihnen navigiert wird. Ziehen Sie beispielsweise eine Personalanwendung in Betracht, die eine Seite enthält, um alle Mitarbeiter in einer Organisation auflisten – die Seite "Mitarbeiter auflisten". Auf dieser Seite können Benutzer auch einen neuen Mitarbeiter hinzufügen, indem Sie auf einen Link klicken. Wenn sie geklickt wird, navigiert die Seite zu einer Seite "Mitarbeiter hinzufügen", um die Details des neuen Mitarbeiters zu sammeln und sie zur Seite "Mitarbeiter auflisten" zurückzugeben, um den neuen Mitarbeiter zu erstellen und die Liste zu aktualisieren. Dieser Navigationsstil ähnelt dem Aufrufen einer Methode zum Ausführen einer Verarbeitung und Rückgabe eines Werts, der als strukturierte Programmierung bezeichnet wird. Dementsprechend wird diese Art der Navigation als strukturierte Navigation bezeichnet.
Die Page Klasse implementiert keine Unterstützung für die strukturierte Navigation. Stattdessen wird die PageFunction<T> Klasse von Page abgeleitet und mit den grundlegenden Konstrukten erweitert, die für die strukturierte Navigation erforderlich sind. In diesem Thema wird gezeigt, wie Sie mithilfe von PageFunction<T>strukturierte Navigation einrichten.
Strukturierte Navigation
Wenn eine Seite eine andere Seite in einer strukturierten Navigation aufruft, sind einige oder alle der folgenden Verhaltensweisen erforderlich:
Die aufrufende Seite navigiert zur aufgerufenen Seite und übergibt optional Parameter, die von der aufgerufenen Seite benötigt werden.
Die aufgerufene Seite kehrt zu der aufrufenden Seite zurück, wenn der Benutzer das Verwenden der aufrufenden Seite abgeschlossen hat. Optional:
Gibt Statusinformationen zurück, die beschreiben, wie die aufrufende Seite abgeschlossen wurde (z. B. ob ein Benutzer eine OK-Schaltfläche oder eine Schaltfläche "Abbrechen" gedrückt hat).
Rückgabe der Daten, die vom Benutzer erfasst wurden (z. B. Angaben zu neuen Mitarbeitern).
Wenn die aufrufende Seite zur aufgerufenen Seite zurückkehrt, wird die aufgerufene Seite aus dem Navigationsverlauf entfernt, um eine Instanz einer aufgerufenen Seite von einer anderen zu isolieren.
Diese Verhaltensweisen werden in der folgenden Abbildung veranschaulicht:
Sie können diese Verhaltensweisen implementieren, indem Sie PageFunction<T> als aufgerufene Seite verwenden.
Strukturierte Navigation mit PageFunction
In diesem Artikel wird gezeigt, wie Sie die grundlegende Funktionsweise der strukturierten Navigation mit einer einzelnen PageFunction<T> implementieren. In diesem Beispiel ruft Page PageFunction<T> auf, um einen String-Wert vom Benutzer zu erhalten und ihn zurückzugeben.
Erstellen einer aufrufenden Seite
Die Seite, die eine PageFunction<T> aufruft, kann entweder Page oder PageFunction<T> sein. In diesem Beispiel ist es ein Page, wie im folgenden Code dargestellt.
<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
Erstellen einer Seitenfunktion zum Aufrufen
Da die aufrufende Seite die aufgerufene Seite zum Sammeln und Zurückgeben von Daten vom Benutzer verwenden kann, wird PageFunction<T> als generische Klasse implementiert, deren Typargument den Typ des Werts angibt, den die aufgerufene Seite zurückgeben wird. Der folgende Code zeigt die anfängliche Implementierung der aufgerufenen Seite unter Verwendung von PageFunction<T>, die String zurückgibt.
<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
Die Deklaration einer PageFunction<T> ähnelt der Deklaration eines Page mit dem Hinzufügen der Typargumente. Wie Sie dem Codebeispiel entnehmen können, werden die Typargumente sowohl im XAML-Markup (mithilfe des x:TypeArguments-Attributs), als auch in CodeBehind (mithilfe der Standardsyntax für allgemeine Typargumente) angegeben.
Sie müssen nicht nur .NET Framework-Klassen als Typargumente verwenden. Sie können eine PageFunction<T> aufrufen, um domänenspezifische Daten zu erfassen, die als benutzerdefinierter Typ abstrahiert werden. Der folgende Code zeigt, wie man einen benutzerdefinierten Typ als Typargument für ein PageFunction<T>verwendet.
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
Die Typargumente für die PageFunction<T> sind die Grundlage für die Kommunikation zwischen einer aufrufenden Seite und einer aufgerufenen Seite, was in den folgenden Abschnitten näher erläutert wird.
Wie Sie sehen werden, spielt der Typ, der mit der Deklaration von PageFunction<T> identifiziert wird, eine wichtige Rolle bei der Rückgabe von Daten von PageFunction<T> an die aufrufende Seite.
Aufrufen einer PageFunction und Übergeben von Parametern
Um eine Seite aufzurufen, muss die aufrufende Seite die aufgerufene Seite instanziieren und mithilfe der Navigate-Methode dorthin navigieren. Auf diese Weise kann die aufrufende Seite anfängliche Daten an die aufgerufene Seite übergeben, z. B. Standardwerte für die von der aufgerufenen Seite gesammelten Daten.
Im folgenden Code ist die aufgerufene Seite mit einem anderen als dem Nichtparameterkonstruktor dargestellt, um Parameter aus der aufrufenden Seite zu übernehmen.
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
Der folgende Code zeigt die aufrufende Seite, die das Click-Ereignis von Hyperlink verarbeitet, um die aufgerufene Seite zu instanziieren und ihr einen anfänglichen Zeichenkettenwert zu übergeben.
<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
Sie müssen keine Parameter an die aufgerufene Seite übergeben. Stattdessen können Sie die folgenden Aktionen ausführen:
Auf der aufrufenden Seite:
Instanziieren Sie die aufgerufene PageFunction<T> mit dem parameterlosen Konstruktor.
Speichern Sie die Parameter in Properties.
Navigieren Sie zur aufgerufenen PageFunction<T>.
Von der aufgerufenen PageFunction<T>:
- Rufen Sie die in Propertiesgespeicherten Parameter ab und verwenden Sie sie.
Aber wie Sie gleich sehen werden, benötigen Sie weiterhin noch Code, um die aufgerufene Seite zu instanziieren, darauf zu navigieren und die zurückgegebenen Daten zu sammeln. Aus diesem Grund muss PageFunction<T> aktiv bleiben. Andernfalls instanziiert WPF das nächste Mal, wenn Sie zu PageFunction<T> navigieren, PageFunction<T> mit dem parameterlosen Konstruktor.
Bevor die aufgerufene Seite zurückgegeben werden kann, muss sie jedoch Daten zurückgeben, die von der aufrufenden Seite abgerufen werden können.
Zurückgeben von Aufgabenergebnissen und Aufgabendaten aus einer Aufgabe an eine aufrufende Seite
Nachdem die benutzende Person alle Aufgaben auf der aufgerufenen Seite beendet hat und wie in diesem Beispiel auf „OK“ oder „Abbrechen“ geklickt hat, muss die aufgerufene Seite wieder angezeigt werden. Da die aufrufende Seite die aufgerufene Seite zum Sammeln von Daten vom Benutzer verwendet hat, benötigt die aufrufende Seite zwei Arten von Informationen:
Gibt an, ob der Benutzer die aufgerufene Seite abgebrochen hat (durch Drücken der Schaltfläche "OK" oder der Schaltfläche "Abbrechen" in diesem Beispiel). Auf diese Weise kann die aufrufende Seite bestimmen, ob die Daten verarbeitet werden sollen, die die aufrufende Seite vom Benutzer gesammelt hat.
Die Vom Benutzer bereitgestellten Daten.
Um Informationen zurückzugeben, implementiert PageFunction<T> die OnReturn-Methode. Der folgende Code zeigt, wie sie aufgerufen wird.
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
Wenn der Benutzer in diesem Beispiel auf die Schaltfläche „Abbrechen“ klickt, wird der Wert null an die aufrufende Seite zurückgegeben. Wenn stattdessen die Schaltfläche "OK" gedrückt wird, wird der vom Benutzer bereitgestellte Zeichenfolgenwert zurückgegeben. OnReturn ist eine protected virtual-Methode, die Sie aufrufen, um Ihre Daten an die aufrufende Seite zurückzugeben. Ihre Daten müssen in eine Instanz des generischen Typs ReturnEventArgs<T> verpackt werden, dessen Typargument den Typ des Wertes angibt, den Result zurückgibt. Wenn Sie eine PageFunction<T> mit einem bestimmten Typargument deklarieren, geben Sie an, dass eine PageFunction<T> eine Instanz des durch das Typargument definierten Typs zurückgibt. In diesem Beispiel ist das Typargument und folglich der Rückgabewert vom Typ String.
Wenn OnReturn aufgerufen wird, muss die aufrufende Seite eine Möglichkeit haben, den Rückgabewert der PageFunction<T> zu empfangen. Aus diesem Grund implementiert PageFunction<T> das Return-Ereignis für den Aufruf von zu behandelnden Seiten. Wenn OnReturn aufgerufen wird, wird Return ausgelöst, sodass sich die aufrufende Seite bei Return registrieren kann, um die Benachrichtigung zu erhalten.
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
Entfernen von Vorgangsseiten, wenn eine Aufgabe abgeschlossen ist
Wenn eine aufgerufene Seite zurückkehrt und der Benutzer die aufgerufene Seite nicht abgebrochen hat, verarbeitet die aufrufende Seite die vom Benutzer bereitgestellten Daten sowie die von der aufgerufenen Seite zurückgegebenen. Eine solche Datengewinnung erfolgt zumeist isoliert. Wenn die aufgerufene Seite wieder angezeigt wird, muss die aufrufende Seite eine neue aufrufende Seite erstellen und zu dieser navigieren, um weitere Daten zu erfassen.
Die benutzende Person kann jedoch zu einer vorherigen Instanz der aufrufenden Seite zurück navigieren, sofern die aufgerufene Seite nicht aus dem Journal entfernt wurde. Ob eine PageFunction<T> im Journal bleibt, hängt von der RemoveFromJournal-Eigenschaft ab. Standardmäßig wird eine Seitenfunktion automatisch entfernt, wenn OnReturn aufgerufen wird, da RemoveFromJournal auf truefestgelegt ist. Um eine Seitenfunktion im Navigationsverlauf zu behalten, nachdem OnReturn aufgerufen wurde, legen Sie RemoveFromJournal auf false fest.
Andere Arten der strukturierten Navigation
In diesem Thema wird die grundlegende Verwendung einer PageFunction<T> veranschaulicht, um eine strukturierte Navigation für Aufruf/Rückgabe zu unterstützten. Diese Grundlage bietet Ihnen die Möglichkeit, komplexere Typen der strukturierten Navigation zu erstellen.
Manchmal werden mehrere Seiten von einer aufrufenden Seite benötigt, um genügend Daten von einem Benutzer zu sammeln oder eine Aufgabe auszuführen. Die Verwendung mehrerer Seiten wird als „Assistent“ bezeichnet.
In anderen Fällen können Anwendungen komplexe Navigationstopologien aufweisen, die von der strukturierten Navigation abhängig sind, um effektiv zu arbeiten. Weitere Informationen finden Sie unter Übersicht über Navigationstopologien.
Weitere Informationen
.NET Desktop feedback