Übersicht über die strukturierte Navigation
Inhalte, die von einer XAML-Browser-Anwendung (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 der Seiten und die durch Links definierte Navigation in ihnen werden als Navigationstopologie bezeichnet. Eine solche Topologie kann für unterschiedliche Anwendungstypen eingesetzt werden, insbesondere für die Navigation in Dokumenten. In diesen Anwendungen kann der Benutzer von einer Seite zu einer anderen Seite navigieren, ohne dass die Seite Informationen zu der anderen Seite enthält.
In anderen Anwendungstypen ist es hingegen erforderlich, dass die Seiten Informationen über den Navigationsverlauf beinhalten. Beispiel: Eine Personalanwendung enthält eine Seite, auf der alle Mitarbeiter eines Unternehmens aufgelistet sind (die „Mitarbeiterliste“). Auf dieser Seite können Benutzer mithilfe eines Links einen neuen Mitarbeiter hinzufügen. Wenn der Benutzer auf diesen Link klickt, navigiert die Seite zu der Seite „Mitarbeiter hinzufügen“, auf der die Daten des neuen Mitarbeiters erfasst werden. Anschließend wird die Seite „Mitarbeiterliste“ wieder aufgerufen, um den neuen Mitarbeiter zu erstellen und die Liste zu aktualisieren. Diese Art der Navigation entspricht dem Aufruf einer Methode, um bestimmte Verarbeitungsschritte auszuführen und einen Wert zurückzugeben, was auch 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 leitet die PageFunction<T>-Klasse von Page ab und erweitert sie um die grundlegenden Konstrukte, die für eine strukturierte Navigation erforderlich sind. Dieses Thema zeigt, wie Sie eine strukturierte Navigation mit PageFunction<T> erstellen.
Strukturierte Navigation
Wenn eine Seite in einer strukturierten Navigation eine andere Seite aufruft, sind die folgenden Verhaltensweisen ganz oder teilweise erforderlich:
Die aufrufende Seite navigiert zu der aufgerufenen Seite und übergibt ggf. für die aufgerufene Seite erforderliche Parameter.
Die aufgerufene Seite kehrt zu der aufrufenden Seite zurück, wenn der Benutzer die Bearbeitung in der aufrufenden Seite abgeschlossen hat. Optional:
Es werden Zustandsinformationen zurückgegeben, die angeben, wie die aufrufende Seite beendet wurde (z. B. ob der Benutzer auf die Schaltfläche „OK“ oder „Abbrechen“ geklickt hat).
Die von dem Benutzer erfassten Daten werden zurückgegeben (z. B. die Daten eines neuen Mitarbeiters).
Wenn die aufrufende Seite die aufgerufene Seite erneut anzeigt, wird die aufgerufene Seite aus dem Navigationsverlauf entfernt, um eine Instanz einer aufgerufenen Seite von einer anderen Instanz zu trennen.
Diese Verhaltensweisen werden in der folgenden Abbildung dargestellt.
Sie können diese Verhaltensweisen implementieren, indem Sie PageFunction<T> als aufgerufene Seite verwenden.
Strukturierte Navigation mit PageFunction
In diesem Thema wird gezeigt, wie Sie die grundlegende Funktionsweise der strukturierten Navigation mit einer einzelnen PageFunction<T> implementieren. In diesem Beispiel ruft PagePageFunction<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 aufzurufenden Seitenfunktion
Da die aufrufende Seite mithilfe der aufgerufenen Seite Daten von dem Benutzer erfassen und zurückgeben kann, wird PageFunction<T> als allgemeine Klasse implementiert, durch deren Typargument die Art des Werts angegeben wird, den die aufgerufene Seite zurückgibt. 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 von PageFunction<T> ist ähnlich wie die Deklaration von Page mit dem Zusatz der Typargumente. Wie Sie dem Codebeispiel entnehmen können, werden die Typargumente sowohl im XAML-Markup (mithilfe des x:TypeArguments-Attributs), als auch im Code-Behind (mithilfe der standardmäßigen Syntax für allgemeine Typargumente) angegeben.
Sie müssen nicht immer .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. Im folgenden Code wird gezeigt, wie ein benutzerdefinierter Typ als Typargument für eine PageFunction<T> verwendet wird.
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 mit der Navigate-Methode zu ihr navigieren. Die aufrufende Seite kann so erste Daten an die aufgerufene Seite übergeben, darunter Standardwerte für die von der aufgerufenen Seite erfassten 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, wie die aufrufende Seite mit dem Click-Ereignis des Hyperlink, um die aufgerufene Seite zu instanziieren und ihr einen anfänglichen Zeichenfolgewert 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
Es ist nicht erforderlich, Parameter an die aufgerufene Seite zu übergeben. Sie können stattdessen auch die folgenden Schritte durchführen.
Auf der aufrufenden Seite:
Instanziieren Sie den aufgerufenen PageFunction<T> mit dem parameterlosen Konstruktor.
Speichern Sie die Parameter in Properties.
Navigieren Sie zu dem aufgerufenen PageFunction<T>.
Aus dem aufgerufenen PageFunction<T>:
- Abrufen und Verwenden der in Properties gespeicherten Parameter.
Sie müssen jedoch weiterhin Code verwenden, um die aufgerufene Seite zu instanzieren und zu dieser zu navigieren, sodass die von der aufgerufenen Seite zurückgegebenen Daten erfasst werden können (siehe Beschreibung weiter unten). Aus diesem Grund muss PageFunction<T> am Leben gehalten werden. Andernfalls instanziiert WPF das nächste Mal, wenn Sie zu dem PageFunction<T> navigieren, PageFunction<T> mit dem parameterlosen Konstruktor.
Bevor die aufgerufene Seite wieder angezeigt werden kann, muss sie die 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 der Benutzer 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 dazu verwendet hat, um Daten vom Benutzer zu erfassen, benötigt die aufrufende Seite zwei Arten von Informationen:
Ob der Benutzer die aufgerufene Seite abgebrochen hat (indem er wie in diesem Beispiel auf „OK“ oder „Abbrechen“ geklickt hat). Die aufrufende Seite ermittelt anhand dieser Informationen, ob die von der aufrufenden Seite erfassten Daten des Benutzers verarbeitet werden sollen.
Die Daten, die vom Benutzer angegeben wurden.
Um Informationen zurückzugeben, implementiert PageFunction<T> die OnReturn-Methode. Im folgenden Code wird veranschaulicht, wie diese 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. Wird stattdessen die Schaltfläche „OK“ ausgewählt, wird der vom Benutzer angegebene 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 ReturnEventArgs<T>-Typs verpackt werden, dessen Typ-Argument den Typ des Wertes angibt, der Result zurückgegeben wird. 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 entsprechen das Typargument und infolgedessen der Rückgabewert dem 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, damit 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 Aufgabenseiten nach Abschluss einer Aufgabe
Wenn eine aufgerufene Seite wieder angezeigt wird und der Benutzer diese nicht abgebrochen hat, verarbeitet die aufrufende Seite die von dem Benutzer angegebenen und von der aufgerufenen Seite zurückgegebenen Daten. Eine solche Datenerfassung 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.
Der Benutzer kann jedoch zu einer vorherigen Instanz der aufrufenden Seite zurück navigieren, sofern die aufgerufene Seite nicht aus dem Journal entfernt wurde. Ob ein PageFunction<T> im Journal festgehalten wird, hängt von der RemoveFromJournal-Eigenschaft ab. Standardmäßig wird eine Seitenfunktion automatisch entfernt, wenn OnReturn aufgerufen wird, weil RemoveFromJournal auf true festgelegt ist. Um eine Seitenfunktion im Navigationsverlauf zu behalten, nachdem OnReturn aufgerufen wurde, setzen Sie RemoveFromJournal auf false.
Andere Arten der strukturierten Navigation
In diesem Thema wird die grundlegende Verwendung einer PageFunction<T> veranschaulicht, um eine strukturierte Navigation mit Aufruf/Rückgabe zu unterstützten. Auf dieser Grundlage können Sie dann komplexere Typen der strukturierten Navigation erstellen.
In bestimmten Situationen benötigt eine aufrufende Seite beispielsweise mehrere Seiten, um genügend Daten zu einem Benutzer zu erfassen oder um eine Aufgabe auszuführen. Die Verwendung mehrerer Seiten wird als „Assistent“ bezeichnet.
In anderen Situationen weisen Anwendungen möglicherweise komplexe Navigationstopologien auf, für deren effektive Ausführung eine strukturierte Navigation erforderlich ist. Weitere Informationen finden Sie unter Übersicht über Navigationstopologien.
Siehe auch
.NET Desktop feedback