Übersicht über die Navigation

Aktualisiert: Juli 2008

Windows Presentation Foundation (WPF) unterstützt die Navigation im Browserstil, die in zwei Anwendungstypen verwendet werden kann: eigenständige Anwendungen und XAML-Browseranwendungen (XBAPs). Um Inhalt für die Navigation zu packen, stellt WPF die Page-Klasse zur Verfügung. Sie können deklarativ von einer Page zur anderen navigieren, entweder unter Verwendung von Hyperlink oder programmgesteuert unter Verwendung von NavigationService. WPF verwendet das Journal, um Seiten zu speichern, von denen weg navigiert wurde, und um wieder zu den Seiten zurück zu navigieren.

Page, Hyperlink, NavigationService und das Journal bilden den Kern der Navigationsunterstützung, die von WPF angeboten wird. In dieser Übersicht werden diese Features ausführlich untersucht, bevor die erweiterte Navigationsunterstützung behandelt wird, die die Navigation zu Loose Extensible Application Markup Language (XAML)-Dateien, HTML-Dateien und -Objekten umfasst.

Dieses Thema enthält folgende Abschnitte.

• Navigation in WPF-Anwendungen
• Die NavigationWindow-Klasse
• Die Frame-Klasse
• Navigationshosts
• Navigieren zu anderem Inhalt als XAML-Seiten
• Sicherheit
• Verwandte Abschnitte

Navigation in WPF-Anwendungen

In diesem Thema erhalten Sie eine Übersicht über die entscheidenden Navigationsfunktionen in WPF. Diese Funktionen sind sowohl für eigenständige Anwendungen als auch für XBAPs verfügbar, obwohl sie in diesem Thema im Kontext von XBAP vorgestellt werden.

In diesem Abschnitt werden die folgenden Aspekte der Navigation erklärt und veranschaulicht:

• Implementieren einer Seite

• Konfigurieren einer Startseite

• Konfigurieren von Titel, Breite und Höhe des Hostfensters

• Linknavigation

• Fragmentnavigation

• Navigationsdienst

• Programmgesteuerte Navigation mit dem Navigationsdienst

• Navigationslebensdauer

• Aufzeichnung der Navigation mithilfe des Journals

• Seitenlebensdauer und das Journal

• Beibehalten des Inhaltszustands über den Navigationsverlauf

• Cookies

• Strukturierte Navigation

Implementieren einer Seite

In WPF können Sie zu mehreren Inhaltstypen navigieren, die .NET Framework-Objekte, benutzerdefinierte Objekte, Enumerationswerte, Benutzersteuerelemente, XAML-Dateien und HTML-Dateien umfassen. Sie werden jedoch merken, dass die Verwendung von Page die gebräuchlichste und bequemste Methode zum Packen von Inhalt ist. Außerdem implementiert Page navigationsspezifische Features, um deren Darstellung zu verbessern und die Entwicklung zu vereinfachen.

Die Verwendung von Page ermöglicht Ihnen das deklarative Implementieren einer navigierbaren Seite von XAML-Inhalt, indem Sie folgendes Markup verwenden.

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

Eine in XAML implementierte Page verfügt über Page als Stammelement und erfordert die WPF XML-Namespacedeklaration. Das Page-Element enthält den Inhalt, zu dem Sie navigieren und den Sie anzeigen möchten. Sie fügen Inhalt hinzu, indem Sie das Page.Content-Eigenschaftenelement festlegen, wie im folgenden Markup gezeigt.

<Page xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <Page.Content>
    <!-- Page Content -->
    Hello, Page!
  </Page.Content>
</Page>

Page.Content kann nur ein untergeordnetes Element enthalten. Im vorherigen Beispiel besteht der Inhalt aus einer einzelnen Zeichenfolge, "Hello, Page!". In der Praxis verwenden Sie normalerweise ein Layoutsteuerelement als untergeordnetes Element (siehe Das Layoutsystem), um den Inhalt zu speichern und zu erstellen.

Die untergeordneten Elemente eines Page-Elements gelten als Inhalt von Page. Folglich müssen Sie die explizite Page.Content-Deklaration nicht verwenden. Das folgende Markup stellt die deklarative Entsprechung zum vorherigen Beispiel dar.

<Page xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <!-- Page Content -->
  Hello, Page!
</Page>

In diesem Fall wird Page.Content automatisch mit den untergeordneten Elementen des Page-Elements festgelegt. Weitere Informationen finden Sie unter WPF-Inhaltsmodell.

Eine Markup-Page ist hilfreich zum Anzeigen von Inhalt. Allerdings kann Page auch Steuerelemente anzeigen, mit deren Hilfe Benutzer mit der Seite interagieren. Außerdem kann die Klasse auf Benutzerinteraktionen reagieren, indem Ereignisse behandelt und Anwendungslogik aufgerufen wird. Eine interaktive Page wird durch eine Kombination aus Markup und Code-Behind implementiert, wie im folgenden Beispiel dargestellt.

Damit eine Markup- und eine Code-Behind-Datei zusammenarbeiten können, ist die folgende Konfiguration erforderlich:

• Im Markup muss das Page-Element das x:Class-Attribut enthalten. Beim Erstellen der Anwendung führt das Vorhandensein von x:Class in der Markupdatei dazu, dass Microsoft-Buildmodul (MSBuild) eine partial-Klasse erstellt, die aus Page abgeleitet wird und den durch das x:Class-Attribut festgelegten Namen hat. Dies erfordert das Hinzufügen einer XML-Namespacedeklaration für das XAML-Schema (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). Die erzeugte partial-Klasse implementiert InitializeComponent, die zum Registrieren der Ereignisse und Festlegen der im Markup implementierten Eigenschaften aufgerufen wird.

• Bei Code-Behind muss die Klasse eine partial-Klasse mit demselben Namen sein, der im Markup durch das x:Class-Attribut angegeben ist, und sie muss von Page abgeleitet werden. Auf diese Weise kann die Code-Behind-Datei mit der partial-Klasse verknüpft werden, die beim Erstellen der Anwendung (siehe Erstellen einer WPF-Anwendung (WPF)) für die Markupdatei generiert wird.

• Bei Code-Behind muss die Page-Klasse einen Konstruktor implementieren, der die InitializeComponent-Methode aufruft. InitializeComponent wird durch die generierte partial-Klasse der Markupdatei implementiert, um Ereignisse zu registrieren und im Markup definierte Eigenschaften festzulegen.

Wenn Page vorhanden ist, können Sie dorthin navigieren. Um die erste Page anzugeben, zu der eine Anwendung navigiert, müssen Sie die Start-Page konfigurieren.

Konfigurieren einer Startseite

XBAPs erfordern einen gewissen Umfang an Anwendungsinfrastruktur, um in einem Browser gehostet zu werden. In WPF ist die Application-Klasse Teil einer Anwendungsdefinition, die die erforderliche Anwendungsinfrastruktur (siehe Übersicht über die Anwendungsverwaltung) festlegt.

Eine Anwendungsdefinition wird normalerweise mithilfe von Markup und Code-Behind implementiert. Dabei wird die Markupdatei als ein MSBuild ApplicationDefinition-Element konfiguriert. Das folgende Beispiel ist eine Anwendungsdefinition für XBAP.

Eine XBAP kann die Anwendungsdefinition zum Angeben einer Start-Page verwenden. Diese entspricht der Page, die beim Start von XBAP automatisch geladen wird. Zu diesem Zweck legen Sie die StartupUri-Eigenschaft mit dem Uniform Resource Identifier (URI) für die gewünschte Page fest.

Sie können StartupUri deklarativ in Markup festlegen, wie im folgenden Beispiel veranschaulicht.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="PageWithHyperlink.xaml" />

In diesem Beispiel wird das StartupUri-Attribut mit einem relativen Paket-URI festgelegt, der HomePage.xaml identifiziert. Wenn XBAP gestartet wird, wird automatisch zu HomePage.xaml navigiert und diese Datei angezeigt. Dies wird in der folgenden Abbildung veranschaulicht, in der eine XBAP gezeigt wird, die von einem Webserver gestartet wird.

Konfigurieren von Titel, Breite und Höhe des Hostfensters

In der vorherigen Abbildung ist Ihnen möglicherweise aufgefallen, dass der Titel sowohl des Browsers als auch des Registerkartenbereichs dem URI für eine XBAP entspricht. Der Titel ist zum einen lang und zum anderen weder ansprechend noch informativ. Daher bietet Page eine Möglichkeit zum Ändern des Titels, indem die WindowTitle-Eigenschaft festgelegt wird. Darüber hinaus können Sie die Breite und Höhe des Browserfensters durch Festlegen von WindowWidth bzw. WindowHeight konfigurieren.

WindowTitle, WindowWidth und WindowHeight können deklarativ in Markup festgelegt werden, wie im folgenden Beispiel veranschaulicht.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.HomePage"
    WindowTitle="Page Title"
    WindowWidth="500"
    WindowHeight="200">
  Hello, from the XBAP HomePage!
</Page>

Das Ergebnis wird in der folgenden Abbildung dargestellt.

Linknavigation

Eine typische XBAP umfasst mehrere Seiten. Mithilfe von Hyperlink kann am einfachsten von einer Seite zur nächsten navigiert werden. Sie können einer Page einen Hyperlink deklarativ hinzufügen, indem Sie das Link-Element verwenden, das im folgenden Markup veranschaulicht wird.

<Page
  xmlns="https://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>

Für ein Link-Element benötigen Sie Folgendes:

• Den Paket-URI der Page, zu der Sie navigieren, wie vom NavigateUri-Attribut angegeben.

• Inhalt, auf den ein Benutzer zum Einleiten der Navigation klicken kann, z. B. Text und Bilder (Informationen zum Inhalt, den das Link-Element enthalten kann, finden Sie unter Hyperlink).

In der folgenden Abbildung wird eine XBAP mit Page dargestellt, die einen Hyperlink besitzt.

Erwartungsgemäß verursacht das Klicken auf Hyperlink, dass eine XBAP zu Page navigiert, die durch das NavigateUri-Attribut identifiziert wird. Darüber hinaus fügt XBAP der Liste Zuletzt besuchte Seiten in Internet Explorer 7 einen Eintrag für die vorherige Page hinzu. Das wird in der folgenden Abbildung gezeigt.

Genauso wie das Unterstützen der Navigation von einer Page zur anderen, unterstützt Hyperlink auch Fragmentnavigation.

Fragmentnavigation

Fragmentnavigation beschreibt die Navigation zu einem Inhaltsfragment entweder in der aktuellen Page oder in einer anderen Page. In WPF entspricht ein Inhaltsfragment dem Inhalt, der im benannten Element enthalten ist. Ein benanntes Element ist ein Element, dessen Name-Attribut festgelegt wurde. Im folgenden Markup wird ein benanntes TextBlock-Element gezeigt, das ein Inhaltsfragment enthält.

<Page
    xmlns="https://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>

Damit ein Hyperlink zu einem Inhaltsfragment navigiert, muss das NavigateUri-Attribut Folgendes einschließen:

• Den URI von Page mit dem Inhaltsfragment, zu dem navigiert werden soll.

• Ein "#"-Zeichen

• Den Namen des Elements für die Page, die das Inhaltsfragment enthält.

Ein Fragment-URI hat das folgende Format.

PageURI#ElementName

Im Folgenden finden Sie ein Beispiel für einen Link, der für die Navigation zu einem Inhaltsfragment konfiguriert ist.

<Page
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page That Navigates To Fragment" >


...


<Hyperlink NavigateUri="PageWithFragments.xaml#Fragment1">
  Navigate To pack Fragment
</Hyperlink>


...


</Page>

Eine vollständiges Beispiel für die Fragmentnavigation finden Sie unter Beispiel für die Fragmentnavigation.

Wichtiger Hinweis:
Zu Fragmenten in Loose XAML-Seiten (Markup-XAML-Dateien mit Page als Stammelement) können Sie nur dann navigieren, wenn die Seiten über HTTP gesucht werden können. Das Navigieren zu den eigenen Fragmenten ist für eine Loose XAML-Seite jedoch möglich.

Navigationsdienst

Mit Hyperlink kann ein Benutzer die Navigation zu einer bestimmten Page initiieren. Das Suchen und Herunterladen der Seite wird durch die NavigationService-Klasse ausgeführt. Im Wesentlichen ermöglicht NavigationService die Verarbeitung einer Navigationsanforderung im Namen eine Clientcodes, z. B. Hyperlink. Darüber hinaus implementiert NavigationService Unterstützung auf höherer Ebene zum Nachverfolgen und Beeinflussen einer Navigationsanforderung.

Wenn Sie auf Hyperlink klicken, ruft WPF den NavigationService.Navigate auf, um Page unter dem angegebenen Paket-URI zu suchen und herunterzuladen. Die heruntergeladene Page wird in eine Struktur von Objekten konvertiert, deren Stammobjekt eine Instanz der heruntergeladenen Page ist. Ein Verweis auf das Page-Stammobjekt wird in der NavigationService.Content-Eigenschaft gespeichert. Der Paket-URI für den Inhalt, zu dem Sie navigiert sind, ist in der NavigationService.Source-Eigenschaft gespeichert. Dagegen speichert NavigationService.CurrentSource den Paket-URI für die letzte Seite, zu der navigiert wurde.

Programmgesteuerte Navigation mit dem Navigationsdienst

Sie müssen nichts über NavigationService wissen, wenn die Navigation durch Hyperlink deklarativ im Markup implementiert wird, da Hyperlink in Ihrem Namen NavigationService verwendet. Dies bedeutet, dass Hyperlink den Navigationsdienst des Navigationshosts finden und verwenden kann, um eine Navigationsanforderung zu verarbeiten, solange entweder das direkte oder das indirekte übergeordnete Element von Hyperlink ein Navigationshost ist (siehe Navigationshosts).

Es treten allerdings Situationen auf, in denen Sie NavigationService direkt verwenden müssen, darunter die folgenden:

• Wenn Sie Page unter Verwendung eines nicht standardmäßigen Konstruktors instanziieren müssen.

• Wenn Sie Eigenschaften auf Page festlegen müssen, bevor Sie dorthin navigieren.

• Wenn die Page, zu der navigiert werden muss, nur zur Laufzeit bestimmt werden kann.

In diesen Fällen müssen Sie Code schreiben, um die Navigation programmgesteuert zu initiieren, indem Sie die Navigate-Methode des NavigationService-Objekts aufrufen. Dies macht das Abrufen eines Verweises auf NavigationService erforderlich.

Abrufen eines Verweises auf NavigationService

Aus den im Abschnitt Navigationshosts genannten Gründen kann eine WPF-Anwendung mehrere NavigationService-Elemente haben. Daher benötigt Ihr Code eine Möglichkeit zum Suchen von NavigationService, wobei es sich in der Regel um den NavigationService handelt, der zur aktuellen Page navigiert ist. Sie können einen Verweis auf NavigationService abrufen, indem Sie die static NavigationService.GetNavigationService-Methode aufrufen. Zum Abrufen von NavigationService, der zu einer bestimmten Page navigiert ist, übergeben Sie einen Verweis auf Page als Argument der GetNavigationService-Methode. Im folgenden Code wird das Abrufen von NavigationService für die aktuelle Page dargestellt.

using System.Windows.Navigation; // NavigationServce


...


// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = NavigationService.GetNavigationService(this);

Als Arbeitserleichterung zum Suchen von NavigationService für Page implementiert Page die NavigationService-Eigenschaft. Dies wird im folgenden Beispiel gezeigt.

using System.Windows.Navigation; // NavigationServce


...


// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = this.NavigationService;

Programmgesteuerte Navigation zu einem Seitenobjekt

Im folgenden Beispiel wird die Verwendung von NavigationService zur programmgesteuerten Navigation zu Page veranschaulicht. Programmgesteuerte Navigation wird benötigt, da die Page, zu der navigiert wird, nur über einen einzelnen, nicht standardmäßigen Konstruktor instanziiert werden kann. Die Page mit dem nicht standardmäßigen Konstruktor wird im folgenden Markup und Code gezeigt.

<Page
    x:Class="SDKSample.PageWithNonDefaultConstructor"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    Title="PageWithNonDefaultConstructor">

  <!-- Content goes here -->

</Page>

using System.Windows.Controls; // Page

namespace SDKSample
{
    public partial class PageWithNonDefaultConstructor : Page
    {
        public PageWithNonDefaultConstructor(string message)
        {
            InitializeComponent();

            this.Content = message;
        }
    }
}

Die Page, die zu Page mit dem nicht standardmäßigen Konstruktor navigiert, wird im folgenden Markup und Code gezeigt.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

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);
        }
    }
}

Wenn auf dieser Page auf Hyperlink geklickt wird, wird die Navigation durch Instanziieren der Page eingeleitet, zu der navigiert wird, indem der nicht standardmäßige Konstruktor verwendet und die NavigationService.Navigate-Methode aufgerufen wird. Navigate akzeptiert einen Verweis auf das Objekt, zu dem NavigationService navigiert, jedoch keinen Paket-URI.

Programmgesteuerte Navigation mit einem Paket-URI

Wenn Sie einen Paket-URI programmgesteuert erstellen müssen (falls der Paket-URI beispielsweise nur zur Laufzeit bestimmt werden kann), können Sie die NavigationService.Navigate-Methode verwenden. Dies wird im folgenden Beispiel gezeigt.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSUriNavigationPage">
  <Hyperlink Click="hyperlink_Click">Navigate to Page by Pack URI</Hyperlink>
</Page>

using System; // Uri, UriKind
using System.Windows; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

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);
        }
    }
}

Aktualisieren der aktuellen Seite

Eine Page wird nicht heruntergeladen, wenn sie denselben Paket-URI besitzt wie der Paket-URI, der in der NavigationService.Source-Eigenschaft gespeichert wird. Wenn Sie erzwingen möchten, dass WPF die aktuelle Seite erneut herunterlädt, können Sie die NavigationService.Refresh-Methode aufrufen, wie im folgenden Beispiel dargestellt.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSRefreshNavigationPage">
 <Hyperlink Click="hyperlink_Click">Refresh this page</Hyperlink>
</Page>

using System.Windows; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

namespace SDKSample
{
    public partial class NSRefreshNavigationPage : Page
    {


...


        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Refresh();
        }
    }
}

Navigationslebensdauer

Wie Sie sehen, gibt es viele Möglichkeiten zum Einleiten der Navigation. Nachdem die Navigation initiiert wurde und während sie ausgeführt wird, können Sie die Navigation mit den folgenden Ereignissen, die von NavigationService implementiert werden, nachverfolgen und beeinflussen:

• Navigating. Tritt ein, wenn eine neue Navigation angefordert wird. Kann zum Abbrechen der Navigation verwendet werden.

• NavigationProgress. Tritt während eines Downloads regelmäßig ein, um Informationen zum Navigationsfortschritt bereitzustellen.

• Navigated. Tritt ein, nachdem die Seite gefunden und heruntergeladen wurde.

• NavigationStopped. Tritt ein, nachdem die Navigation (durch Aufrufen von StopLoading) angehalten wurde oder wenn eine neue Navigation angefordert wird, während die aktuelle Navigation noch ausgeführt wird.

• NavigationFailed. Tritt ein, wenn ein Fehler ausgelöst wird, während zum angeforderten Inhalt navigiert wird.

• LoadCompleted. Tritt ein, wenn der Inhalt, zu dem navigiert wurde, geladen und analysiert wird und mit dem Rendering begonnen wurde.

• FragmentNavigation. Tritt ein, wenn die Navigation zu einem Inhaltsfragment beginnt, was in folgenden Fällen geschieht:

  • Sofort, falls sich das gewünschte Fragment im aktuellen Inhalt befindet.

  • Nachdem der Inhalt der Quelldatei geladen wurde und sich das gewünschte Fragment in einem anderen Inhalt befindet.

Die Navigationsereignisse werden in der Reihenfolge ausgelöst, die in der folgenden Abbildung dargestellt wird.

Im Allgemeinen befasst sich Page nicht mit diesen Ereignissen. Es ist viel wahrscheinlicher, dass sich eine Anwendung mit ihnen befasst. Aus diesem Grund werden diese Ereignisse ebenfalls von der Application-Klasse ausgelöst:

• Application.Navigating

• Application.NavigationProgress

• Application.Navigated

• Application.NavigationFailed

• Application.NavigationStopped

• Application.LoadCompleted

• Application.FragmentNavigation

Jedes Mal, wenn NavigationService ein Ereignis auslöst, löst die Application-Klasse das entsprechende Ereignis aus. Frame und NavigationWindow bieten dieselben Ereignisse, mit denen Navigation in ihren jeweiligen Gültigkeitsbereichen erkannt wird.

In einigen Fällen könnten diese Ereignisse für Page von Interesse sein. Eine Page könnte beispielsweise das NavigationService.Navigating-Ereignis verarbeiten, um zu bestimmen, ob die Navigation von der Seite weg abgebrochen werden soll. Dies wird im folgenden Beispiel gezeigt.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CancelNavigationPage">
  <Button Click="button_Click">Navigate to Another Page</Button>
</Page>

using System; // Uri, UriKind
using System.Windows; // RoutedEventArgs, MessageBox, MessageBoxResult
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService, NavigatingCancelEventArgs

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;
        }
    }
}

Wenn Sie einen Handler für ein Navigationsereignis aus Page registrieren (siehe vorheriges Beispiel), dann müssen Sie auch die Registrierung des Ereignishandlers aufheben. Wenn Sie das versäumen, kann das Nebeneffekte im Hinblick darauf auslösen, wie die WPF-Navigation die Page-Navigation mithilfe des Journals speichert.

Aufzeichnung der Navigation mithilfe des Journals

WPF verwendet zwei Stapel, um die Seiten zu speichern, von denen Sie weg navigiert sind: jeweils einen Stapel für die Rückwärts- und einen Stapel für die Vorwärtsnavigation. Wenn Sie von der aktuellen Page zu einer neuen Page oder vorwärts zu einer vorhandenen Page navigieren, wird dem Rückwärtsstapel die aktuelle Page hinzugefügt. Wenn Sie von der aktuellen Page zurück zur vorherigen Page navigieren, wird dem Vorwärtsstapel die aktuelle Page hinzugefügt. Der Rückwärts- und der Vorwärtsstapel sowie die Funktion zum Verwalten der Stapel werden zusammen als das Journal bezeichnet. Jedes Element in den beiden Stapeln stellt eine Instanz der JournalEntry-Klasse dar und wird als Journaleintrag bezeichnet.

Navigieren im Journal in Internet Explorer 7

Prinzipiell funktioniert das Journal auf dieselbe Weise wie die Schaltflächen Zurück und Vorwärts in Internet Explorer 7. Diese sind in der folgenden Abbildung dargestellt.

Bei XBAPs, die von Internet Explorer 7 gehostet werden, integriert WPF das Journal in die Navigations-Benutzeroberfläche von Internet Explorer 7. Auf diese Weise können Benutzer zu Seiten in XBAP navigieren, indem sie die Schaltflächen Zurück, Vorwärts und Zuletzt besuchte Seiten in Internet Explorer 7 verwenden. Das Journal wird in Microsoft Internet Explorer 6 nicht auf dieselbe Weise integriert wie in Internet Explorer 7. Stattdessen rendert WPF eine Ersatznavigations-Benutzeroberfläche.

Wichtiger Hinweis:
Wenn ein Benutzer in Internet Explorer 7 von XBAP weg und wieder dorthin zurück navigiert, werden nur die Journaleinträge für Seiten, die nicht aktiv beibehalten wurden, im Journal beibehalten. Eine Erklärung, wie Sie Seiten beibehalten, finden Sie unter Seitenlebensdauer und das Journal weiter unten in diesem Thema.

Standardmäßig entspricht der Text für jede Page, die in der Liste Zuletzt besuchte Seiten von Internet Explorer 7 angezeigt wird, dem URI für Page. In vielen Fällen ist das für den Benutzer nicht besonders sinnvoll. Sie können den Text jedoch mithilfe einer der folgenden Optionen ändern:

1. Dem angefügten JournalEntry.Name-Attributwert

2. Dem Page.Title-Attributwert

3. Dem Page.WindowTitle-Attributwert und dem URI für die aktuelle Page

4. Dem URI für die aktuelle Page. (Standard)

Die Reihenfolge, in der die Optionen aufgeführt sind, entspricht der Rangfolge zum Suchen von Text. Wenn JournalEntry.Name festgelegt wurde, werden die anderen Werte beispielsweise ignoriert.

Im folgenden Beispiel wird das Page.Title-Attribut verwendet, um den Text zu ändern, der für einen Journaleintrag angezeigt wird.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // Page

namespace SDKSample
{
    public partial class PageWithTitle : Page
    {


...


    }
}

Navigieren im Journal mit WPF

Obwohl der Benutzer mithilfe der Schaltflächen Zurück, Vorwärts und Zuletzt besuchte Seiten in Internet Explorer 7 im Journal navigieren kann, können Sie auch sowohl mit dem deklarativen als auch mit dem programmgesteuerten Mechanismus von WPF im Journal navigieren. Ein Grund dafür besteht darin, benutzerdefinierte Navigations-UIs in den Seiten zur Verfügung zu stellen.

Sie können die Unterstützung der Journalnavigation deklarativ hinzufügen, indem Sie die Navigationsbefehle verwenden, die von NavigationCommands verfügbar gemacht werden. Im folgenden Beispiel wird die Verwendung des BrowseBack-Navigationsbefehls erläutert.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NavigationCommandsPage">


...


<Hyperlink Command="NavigationCommands.BrowseBack">Back</Hyperlink>


...


</Page>

Sie können programmgesteuert mit einem der folgenden Member der NavigationService-Klasse im Journal navigieren:

• GoBack

• GoForward

• CanGoBack

• CanGoForward

Das Journal kann auch programmgesteuert geändert werden, wie in Beibehalten des Inhaltszustands über den Navigationsverlauf weiter unten in diesem Thema erläutert wird.

Seitenlebensdauer und das Journal

Beispiel: Eine XBAP mit mehreren Seiten, die umfangreichem Inhalt, einschließlich Grafiken, Animationen und Medien, enthalten. Die Speicherbeanspruchung in Zeiten wie diesen könnte recht groß sein, insbesondere, wenn Video- und Audiomedien verwendet werden. Wenn das Journal Seiten "speichert", zu denen navigiert wurde, könnte XBAP schnell einen beträchtlichen Speicherplatz belegen.

Aus diesem Grund besteht das Standardverhalten des Journals im Speichern von Page-Metadaten in jedem Journaleintrag, anstatt auf ein Page-Objekt zu verweisen. Wird zu einem Journaleintrag navigiert, werden seine Page-Metadaten zum Erstellen einer neuen Instanz der angegebenen Page verwendet. Folglich hat jede Page, zu der navigiert wird, die in der folgenden Abbildung dargestellte Lebensdauer.

Obwohl das Standardverhalten des Journals zu einer geringeren Speicherauslastung führen kann, kann die Leistung beim Rendern pro Seite gemindert werden; das erneute Instanziieren von Page kann zeitaufwändig sein, insbesondere bei umfangreichem Inhalt. Wenn Sie eine Page-Instanz im Journal beibehalten müssen, können Sie hierzu die folgenden beiden Techniken verwenden. Navigieren Sie zuerst programmgesteuert zu einem Page-Objekt, indem Sie die NavigationService.Navigate-Methode aufrufen.

Als Nächstes können Sie angeben, dass WPF eine Instanz von Page im Journal beibehält, indem die KeepAlive-Eigenschaft auf true (der Standard ist false) festgelegt wird. Sie können KeepAlive deklarativ in Markup festlegen, wie im folgenden Beispiel veranschaulicht.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.KeepAlivePage"
    KeepAlive="True">

  An instance of this page is stored in the journal.

</Page>

Die Lebensdauer einer aktiv beibehaltenen Page unterscheidet sich nur wenig von einer nicht beibehaltenen Seite. Beim ersten Navigieren zu einer Page, die aktiv beibehalten wird, wird diese wie eine Page instanziiert, die nicht aktiv beibehalten wird. Da jedoch eine Instanz von Page im Journal beibehalten wird, wird sie für die Dauer ihrer Aufbewahrung im Journal nicht mehr instanziiert. Wenn eine Page also eine Initialisierungslogik hat, die bei jedem Navigieren zu Page aufgerufen werden muss, sollten Sie sie aus dem Konstruktor in einen Handler für das Loaded-Ereignis verschieben. Wie in der folgenden Abbildung dargestellt, werden das Loaded-Ereignis und das Unloaded-Ereignis nach wie vor jedes Mal ausgelöst, wenn zu Page hin und wieder zurücknavigiert wird.

Wenn Page nicht aktiv beibehalten wird, sollten Sie Folgendes unterlassen:

• Speichern eines Verweises auf die Seite oder einen Teil der Seite

• Registrieren von Ereignishandlern für Ereignisse, die nicht von ihr implementiert werden

Mit jedem dieser Schritte werden Verweise erstellt, die erzwingen, dass Page im Speicher beibehalten wird, nachdem sie aus dem Journal entfernt wurde.

Im Allgemeinen sollten Sie das Standardverhalten von Page vorziehen, d.h. Page nicht aktiv beibehalten. Dies zieht jedoch Auswirkungen auf den Zustand nach sich, die im nächsten Abschnitt erörtert werden.

Beibehalten des Inhaltszustands über den Navigationsverlauf

Angenommen, Page wird nicht aktiv beibehalten und verfügt über Steuerelemente, die Benutzerdaten erfassen. Wie wirkt es sich auf die Daten aus, wenn ein Benutzer von Page weg und dorthin zurück navigiert? Aus Gründen der Benutzererfahrung sollte der Benutzer erwarten, dass die zuvor eingegebenen Daten angezeigt werden. Da mit jeder Navigation eine neue Instanz von Page erstellt wird, werden die Steuerelemente, die die Daten erfasst haben, jedoch neu instanziiert, und die Daten gehen verloren.

Das Journal unterstützt jedoch das Speichern von Daten über Page-Navigationen hinweg, einschließlich Steuerelementdaten. Insbesondere der Journaleintrag für jede Page fungiert als temporärer Container für den zugeordneten Page-Zustand. In den folgenden Schritten wird beschrieben, wie diese Unterstützung verwendet wird, wenn von Page weg navigiert wird:

1. Dem Journal wird ein Eintrag für die aktuelle Page hinzugefügt.

2. Der Zustand von Page wird im Journaleintrag für diese Seite gespeichert, die dem Rückwärtsstapel hinzugefügt wird.

3. Es wird zur neuen Page navigiert.

Wenn zurück zur Seite Page navigiert wird, werden beim Verwenden des Journals die folgenden Schritte ausgeführt:

1. Die Page (der oberste Journaleintrag im Rückwärtsstapel) wird instanziiert.

2. Die Page wird mit dem Zustand aktualisiert, der mit dem Journaleintrag für Page gespeichert wurde.

3. Es wird zurück zur neuen Page navigiert.

WPF verwendet diese Unterstützung automatisch, wenn die folgenden Steuerelemente für Page verwendet werden:

• CheckBox

• ComboBox

• Expander

• Frame

• ListBox

• ListBoxItem

• MenuItem

• ProgressBar

• RadioButton

• Slider

• TabControl

• TabItem

• TextBox

Wenn Page diese Steuerelemente verwendet, werden die dort eingegebenen Daten über Page-Navigationen hinweg gespeichert, wie durch Bevorzugte Farbe ListBox in der folgenden Abbildung veranschaulicht wird.

Wenn eine Page andere Steuerelemente aufweist als die oben aufgeführten oder wenn ein Zustand in benutzerdefinierten Objekten gespeichert wird, müssen Sie Code schreiben, durch den das Journal den Zustand über Page-Navigationen hinweg speichert.

Wenn Sie kleinere Mengen der Zustandsinformationen über Page-Navigationen hinweg speichern müssen, können Sie Abhängigkeitseigenschaften verwenden (siehe DependencyProperty), die mit dem FrameworkPropertyMetadata.Journal-Metadatenflag konfiguriert werden. Ein Beispiel finden Sie unter Speichern eines Zustandselements über mehrere Seiteninstanzen.

Wenn der Zustand, den Page über mehrere Navigationen hinweg speichern muss, aus mehreren Datenmengen besteht, kann sich das Kapseln Ihres Zustands in einer einzelnen Klasse und Implementieren der IProvideCustomContentState-Schnittstelle als weniger codeintensiv erweisen. Siehe Speichern eines Zustandssatzes über mehrere Seiteninstanzen).

Wenn Sie durch verschiedene Zustände einer einzelnen Page navigieren müssen, können Sie IProvideCustomContentState und NavigationService.AddBackEntry verwenden, ohne von Page weg zu navigieren. Siehe Speichern mehrerer Zustandssätze pro Seiteninstanz).

Cookies

WPF-Anwendungen können Daten auch mit Cookies speichern, die unter Verwendung der SetCookie-Methode und der GetCookie-Methode erstellt, aktualisiert und gelöscht werden. Die Cookies, die Sie in WPF erstellen können, sind mit den Cookies identisch, die von anderen Webanwendungen verwendet werden. Cookies bestehen aus willkürlichen Daten, die von einer Anwendung entweder während oder über Anwendungssitzungen hinweg auf einem Clientcomputer gespeichert werden. Cookiedaten weisen meist das folgende Format eines Name-Wert-Paares auf.

Name=-Wert

Wenn die Daten an SetCookie übergeben werden, wird zusammen mit dem Uri des Standorts, für den das Cookie festgelegt werden soll, ein Cookie speicherintern erstellt. Für die Dauer der aktuellen Anwendungssitzung ist es das einzig verfügbare Cookie. Diese Art von Cookies wird als Sitzungscookie bezeichnet.

Wenn Sie ein Cookie über Anwendungssitzungen speichern möchten, muss dem Cookie unter Verwendung des folgenden Formats ein Ablaufdatum hinzugefügt werden.

NAME=WERT; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

Ein Cookie mit einem Ablaufdatum wird im Ordner Temporäre Internetdateien der aktuellen Windows-Installation gespeichert, bis das Cookie abläuft. Ein solches Cookie wird als dauerhaftes Cookie bezeichnet, da es über Anwendungssitzungen erhalten bleibt.

Sie rufen sowohl Sitzungscookies als auch dauerhafte Cookies auf, indem Sie die GetCookie-Methode aufrufen. Dabei übergeben Sie den Uri des Speicherorts, an dem das Cookie festgelegt wurde, mit der SetCookie-Methode.

Im Folgenden werden einige der Methoden zum Unterstützen von Cookies in WPF dargestellt:

• Eigenständige WPF-Anwendungen und XBAPs können Cookies erstellen und verwalten.

• Auf Cookies, die von XBAP erstellt werden, kann vom Browser zugegriffen werden.

• XBAPs aus derselben Domäne können Cookies erstellen und gemeinsam verwenden.

• XBAPs- und HTML-Seiten aus derselben Domäne können Cookies erstellen und gemeinsam verwenden.

• Cookies werden gesendet, wenn XBAPs und Loose XAML-Seiten Webanforderungen stellen.

• Die XBAPs der oberen Ebene und XBAPs, die in IFRAMES gehostet werden, können auf Cookies zugreifen.

• Cookieunterstützung in WPF ist für alle unterstützten Browser (Internet Explorer 7, Microsoft Internet Explorer 6 und Firefox 2.0+) gleich.

• In Microsoft Internet Explorer 6 und Internet Explorer 7 wird die P3P-Richtlinie, die Cookies betrifft, von WPF berücksichtigt, insbesondere in Bezug auf XBAPs von Erst- und Drittanbietern.

Strukturierte Navigation

Wenn Sie Daten von einer Page zur anderen übergeben müssen, können Sie die Daten als Argumente an einen nicht standardmäßigen Konstruktor von Page übergeben. Beachten Sie, dass Sie bei der Verwendung dieses Verfahrens Page aktiv beibehalten müssen. Andernfalls wird WPF Page beim nächsten Navigieren zu Page mithilfe des standardmäßigen Konstruktors erneut instanziiert.

Alternativ dazu kann Page Eigenschaften implementieren, die mit den zu übergebenden Daten festgelegt werden. Kompliziert wird dies, wenn Page Daten zurück an die Page übergeben muss, die dorthin navigiert ist. Das Problem besteht darin, dass die Navigation keine direkte Unterstützung für Mechanismen bietet, die garantieren können, dass zu einer Page zurückgekehrt wird, nachdem von ihr weg navigiert wurde. Im Grunde unterstützt die Navigation keine Semantik mit Aufruf/Rückgabe. Zur Behebung dieses Problems stellt WPF die PageFunction<T>-Klasse zur Verfügung, mit der Sie sicherstellen können, dass in einer vorhersehbaren und strukturierten Weise zu Page zurückgekehrt wird. Weitere Informationen finden Sie unter Übersicht über die strukturierte Navigation.

Die NavigationWindow-Klasse

Bis jetzt haben Sie das Spektrum der Navigationsdienste kennengelernt, die Sie zum Erstellen von Anwendungen mit navigierbarem Inhalt normalerweise verwenden werden. Diese Dienste wurden im Kontext von XBAPs behandelt, obwohl sie nicht auf XBAPs beschränkt sind. Moderne Betriebssysteme und Windows-Anwendungen nutzen die Browsererfahrung zeitgemäßer Benutzer, um die Navigation im Browserstil in eigenständige Anwendungen zu integrieren. Gängige Beispiele:

• Word-Thesaurus: Navigieren durch verschiedene Benennungen (Synonyme)

• Datei-Explorer: Navigieren in Dateien und Ordnern

• Assistenten: Untergliedern einer komplexen Aufgabe in mehrere Seiten, zwischen denen navigiert werden kann. Ein Beispiel ist der Assistent für Windows-Komponenten, der das Hinzufügen und Entfernen von Windows-Features verarbeitet.

Um die Navigation im Browserstil in Ihre eigenständigen Anwendungen zu integrieren, können Sie die NavigationWindow-Klasse verwenden. NavigationWindow wird von Window abgeleitet und bietet dieselbe Navigationsunterstützung, die von XBAPs zur Verfügung gestellt wird. Verwenden Sie NavigationWindow entweder als Hauptfenster Ihrer eigenständigen Anwendung oder als sekundäres Fenster, z. B. ein Dialogfeld.

Wenn Sie NavigationWindow implementieren möchten, verwenden Sie, wie bei den meisten Klassen der obersten Ebene in WPF (Window, Page usw.), eine Kombination aus Markup und Code-Behind. Dies wird im folgenden Beispiel gezeigt.

<NavigationWindow
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MainWindow" 
    Source="HomePage.xaml"/>

using System.Windows.Navigation; // NavigationWindow

namespace SDKSample
{
    public partial class MainWindow : NavigationWindow
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

Mit diesem Code wird ein NavigationWindow erstellt, das automatisch zu Page (HomePage.xaml) navigiert, wenn NavigationWindow geöffnet wird. Wenn NavigationWindow das Hauptanwendungsfenster ist, können Sie das StartupUri-Attribut verwenden, um es zu öffnen. Dies wird im folgenden Markup gezeigt.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="MainWindow.xaml" />

In der folgenden Abbildung wird NavigationWindow als Hauptanwendungsfenster einer eigenständigen Anwendung gezeigt.

Sie können in der Abbildung sehen, dass NavigationWindow einen Titel hat, obwohl dies nicht im NavigationWindow-Implementierungscode aus dem vorherigen Beispiel festgelegt wurde. Stattdessen wurde der Titel mithilfe der WindowTitle-Eigenschaft festgelegt, die im folgenden Code dargestellt wird.

<Page 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Home Page"
    WindowTitle="NavigationWindow">


...


</Page>

Das Festlegen der WindowWidth-Eigenschaft und der WindowHeight-Eigenschaft wirkt sich auch auf NavigationWindow aus.

Normalerweise implementieren Sie Ihr eigenes NavigationWindow, wenn Sie entweder das Verhalten oder die Anzeige anpassen müssen. Wenn keines von beiden angepasst werden muss, können Sie eine Verknüpfung verwenden. Wenn Sie den Paket-URI von Page als StartupUri in einer eigenständigen Anwendung angeben, erstellt Application automatisch NavigationWindow zum Hosten von Page. Im folgenden Markup wird gezeigt, wie Sie das aktivieren.

<Application
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="HomePage.xaml" />

Wenn Sie möchten, dass ein sekundäres Anwendungsfenster (z. B. ein Dialogfenster) ein NavigationWindow ist, können Sie den Code aus dem folgenden Beispiel verwenden, um es zu öffnen.

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

In der folgenden Abbildung wird das Ergebnis dargestellt.

Wie Sie sehen, zeigt NavigationWindow die Schaltflächen Zurück und Vorwärts, mit denen Benutzer im Journal navigieren können, im Stil von Internet Explorer 7 an. Wie in der folgenden Abbildung veranschaulicht, bieten diese Schaltflächen dieselbe Benutzererfahrung.

Wenn Ihre Seiten eine eigene Navigationsunterstützung für Journal und Benutzeroberfläche zur Verfügung stellen, können Sie die Schaltflächen Zurück und Vorwärts, die von NavigationWindow angezeigt werden, ausblenden, indem Sie den Wert der ShowsNavigationUI-Eigenschaft auf false festlegen. Wahlweise können Sie die Unterstützung der Anpassung in WPF verwenden, um die Benutzeroberfläche von NavigationWindow selbst zu ersetzen. Ein Beispiel dazu finden Sie unter Beispiel für eine benutzerdefinierte NavigationWindow-Benutzeroberfläche.

Die Frame-Klasse

Sowohl Browser und NavigationWindow sind Fenster, die navigierbaren Inhalt hosten. In einigen Fällen verfügen Anwendungen über Inhalt, der nicht von einem ganzen Fenster gehostet werden muss. Stattdessen kann solcher Inhalt in anderem Inhalt gehostet werden. Sie können navigierbaren Inhalt in anderen Inhalt einfügen, indem Sie die Frame-Klasse verwenden. Frame bietet dieselbe Unterstützung wie NavigationWindow und XBAPs.

Im folgenden Beispiel wird gezeigt, wie Sie Page das Element Frame deklarativ hinzufügen, indem Sie das Frame-Element verwenden.

<Page 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page that Hosts a Frame"
  WindowWidth="250"
  WindowHeight="250">


...


<Frame Source="FramePage1.xaml" />


...


</Page>

Mit diesem Markup wird das Source-Attribut des Frame-Elements mit einem Paket-URI für Page festgelegt, zu der Frame zunächst navigieren sollte. In der folgenden Abbildung wird eine XBAP mit Page angezeigt, die einen Frame aufweist, der zwischen mehreren Seiten navigiert ist.

Sie sind nicht auf die Verwendung von Frame innerhalb des Inhalts von Page beschränkt. Es ist auch üblich, Frame im Inhalt von Window zu hosten. Ein Beispiel finden Sie unter Beispiel für Frame-Navigation in einem Fenster.

Standardmäßig verwendet Frame nur sein eigenes Journal, wenn kein anderes angegeben ist. Wenn Frame Teil des Inhalts ist, der entweder in NavigationWindow oder in XBAP gehostet wird, verwendet Frame das Journal, das zu NavigationWindow oder XBAP gehört. Allerdings kommt es vor, dass Frame für das eigene Journal zuständig ist. Ein Grund dafür besteht darin, eine Navigation mithilfe des Journals innerhalb der Seiten zu ermöglichen, die durch Frame gehostet werden. Dies wird in der folgenden Abbildung verdeutlicht.

Sie können Frame in diesem Fall so konfigurieren, dass sein eigenes Journal verwendet wird. Dazu legen Sie die JournalOwnership-Eigenschaft von Frame auf OwnsJournal fest. Dies wird im folgenden Markup gezeigt.

<Page 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page that Hosts a Frame"
  WindowWidth="250"
  WindowHeight="250">


...


<Frame Source="FramePage1.xaml" JournalOwnership="OwnsJournal" />


...


</Page>

In der folgenden Abbildung wird die Auswirkung der Navigation in Frame dargestellt, der sein eigenes Journal verwendet.

Beachten Sie, dass die Journaleinträge durch den Navigations-Benutzeroberfläche in Frame gezeigt werden und nicht durch Internet Explorer 7.

Wenn Ihre Benutzererfahrung es erforderlich macht, dass Frame ein eigenes Journal zur Verfügung stellt, ohne dass die Navigations-Benutzeroberfläche angezeigt wird, können Sie die Navigations-Benutzeroberfläche ausblenden, indem Sie NavigationUIVisibility auf Hidden festlegen. Dies wird im folgenden Markup gezeigt.

<Page 
  xmlns="https://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>

Navigationshosts

Frame und NavigationWindow sind Klassen, die als Navigationshosts bezeichnet werden. Ein Navigationshost ist eine Klasse, die zu Inhalt navigieren und diesen anzeigen kann. Hierzu verwendet jeder Navigationshost den eigenen NavigationService und das eigene Journal. Die grundlegende Konstruktion eines Navigationshosts wird in der folgenden Abbildung gezeigt.

Im Wesentlichen erlaubt dies NavigationWindow und Frame, dieselbe Navigationsunterstützung zur Verfügung zu stellen, die eine XBAP verfügbar macht, wenn sie im Browser gehostet wird.

Neben dem Verwenden von NavigationService und einem Journal, implementieren Navigationshosts dieselben Member, die NavigationService implementiert. Dies wird in der folgenden Abbildung verdeutlicht.

Dies ermöglicht es Ihnen, Navigationsunterstützung direkt für sie zu programmieren. Ziehen Sie dies in Erwägung, wenn Sie eine benutzerdefinierte Navigations-Benutzeroberfläche für Frame bereitstellen müssen, der in Window gehostet wird. Darüber hinaus implementieren beide Typen zusätzliche Member, die für die Navigation erforderlich sind, einschließlich BackStack (NavigationWindow.BackStack, Frame.BackStack) und ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), mit denen Sie die Journaleinträge im Rückwärts- bzw. Vorwärtsstapel auflisten können.

Wie bereits erwähnt, können in einer Anwendung mehrere Journale vorhanden sein. Die folgende Abbildung enthält ein Beispiel für die Fälle, in denen das auftreten kann.

Navigieren zu anderem Inhalt als XAML-Seiten

In diesem Thema wurden Page und Paket-XBAPs dazu verwendet, die verschiedenen Navigationsfunktionen von WPF zu veranschaulichen. Eine Page, die in eine Anwendung kompiliert wird, ist nicht die einzige Art von Inhalt, zu der navigiert werden kann. Paket-XBAPs sind nicht die einzige Möglichkeit zum Identifizieren von Inhalt.

Wie in diesem Abschnitt veranschaulicht wird, können Sie auch zu Loose XAML-Dateien, HTML-Dateien und Objekten navigieren.

Navigieren zu Loose XAML-Dateien

Unter einer Loose XAML-Datei versteht man eine Datei mit den folgenden Eigenschaften:

• Enthält nur XAML (d. h., keinen Code).

• Verfügt über eine entsprechende Namespacedeklaration.

• Hat die Dateinamenerweiterung .xaml.

Stellen Sie sich z. B. den folgenden, zu speichernden Inhalt als Loose XAML-Datei Person.xaml vor.

<!-- Person.xaml -->
<TextBlock xmlns="https://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>

Wenn Sie auf die Datei doppelklicken, wird der Browser geöffnet und navigiert zur Datei und zeigt den Inhalt an. Das wird in der folgenden Abbildung gezeigt.

Sie können eine Loose XAML-Datei von folgenden Orten aus anzeigen:

• Einer Website auf dem lokalen Computer, dem Intranet oder dem Internet

• Einer Universal Naming Convention (UNC)-Dateifreigabe

• Dem lokalen Datenträger

Eine Loose XAML-Datei kann den Favoriten des Browsers hinzugefügt werden oder die Homepage des Browsers darstellen.

Loose XAML sind dahingehend eingeschränkt, dass nur Inhalt gehostet werden kann, der zum Ausführen mit teilweiser Vertrauenswürdigkeit sicher ist. Beispielsweise kann Window nicht das Stammelement einer Loose XAML-Datei sein. Weitere Informationen finden Sie unter Windows Presentation Foundation - Sicherheit bei teilweiser Vertrauenswürdigkeit.

Navigieren zu HTML-Dateien mit Frame

Wie erwartet, können Sie auch zu HTML navigieren. Sie müssen lediglich einen URI zur Verfügung stellen, der das http-Schema verwendet. In der folgenden XAML wird beispielsweise Frame angezeigt, der zu einer HTML-Seite navigiert.

<Frame Source="https://www.microsoft.com/default.aspx" />

Zum Navigieren zu HTML sind besondere Berechtigungen erforderlich. Sie können beispielsweise nicht von einer XBAP navigieren, die im teilweise vertrauenswürdigen Sicherheitsbereich (Sandbox) der Internetzone ausgeführt wird. Weitere Informationen finden Sie unter Windows Presentation Foundation - Sicherheit bei teilweiser Vertrauenswürdigkeit.

Navigieren mit dem WebBrowser-Steuerelement zu HTML-Dateien

Während Frame eine gemischte XAML/HTML-Navigationserfahrung bietet, unterstützt Frame die Interoperation zwischen gehostetenHTML-Seiten und WPF-Hostanwendungen. Es gibt keinen Mechanismus, mit dem Skriptfunktionen aktiviert werden, die von der HTML-Seite implementiert werden, um Methoden mit verwaltetem Code aufzurufen, die von der WPF-Hostanwendung implementiert werden. Ebenso haben WPF-Anwendungen keine Möglichkeit, Skriptfunktionen in gehosteten HTML-Seiten aufzurufen. Falls Sie diese Funktion benötigen, können Sie stattdessen das WebBrowser-Steuerelement verwenden, das das HTML-Dokumenthosting, die Navigation und die Interoperabilität Skript/verwalteter Code unterstützt. Ausführliche Informationen zum WebBrowser-Steuerelement finden Sie im WebBrowser. Ein Beispiel, das den von WebBrowser unterstützten Funktionsbereich darstellt, finden Sie unter Beispiel für das WebBrowser-Steuerelement.

Wie im Falle von Frame, sind für die Navigation zu HTML unter Verwendung von WebBrowser spezielle Berechtigungen erforderlich. Von einer teilweise vertrauenswürdigen Anwendung können Sie nur zu HTML navigieren, das auf der Ursprungssite gespeichert ist. Weitere Informationen finden Sie unter Windows Presentation Foundation - Sicherheit bei teilweiser Vertrauenswürdigkeit.

Navigieren zu benutzerdefinierten Objekten

Wenn Sie Daten als benutzerdefinierte Objekte gespeichert haben, können die Daten u. a. durch Erstellen von Page mit Inhalt angezeigt werden, der an diese Objekte gebunden wird (siehe Übersicht über Datenbindung). Wenn Sie eine ganze Seite nicht nur zu dem Zweck erstellen möchten, die Objekte anzuzeigen, können Sie stattdessen direkt zu ihnen navigieren.

Betrachten Sie die im folgenden Code implementierte Person-Klasse.

Rufen Sie die NavigationWindow.Navigate-Methode auf, um zu ihr zu navigieren, wie mit dem folgenden Code veranschaulicht.

In der folgenden Abbildung wird das Ergebnis dargestellt.

Aus dieser Abbildung können Sie ersehen, dass nichts Nützliches angezeigt wird. Tatsächlich handelt es sich beim angezeigten Wert um den Rückgabewert der ToString-Methode für das Person-Objekt. Standardmäßig ist das der einzige Wert, den WPF zum Darstellen des Objekts verwenden kann. Sie könnten die ToString-Methode überschreiben, um aussagekräftigere Informationen zu erhalten. Allerdings wird auch dann nur ein Zeichenfolgenwert zurückgegeben. Mit einer Datenvorlage lassen sich die Darstellungsfunktionen von WPF nutzen. Sie können eine Datenvorlage implementieren, die WPF dem Objekt eines bestimmten Typs zuordnen kann. Im folgenden Code wird eine Datenvorlage für das Person-Objekt gezeigt.

In diesem Fall wird die Datenvorlage dem Person-Typ unter Verwendung der x:Type-Markuperweiterung im DataType-Attribut zugeordnet. Die Datenvorlage bindet dann TextBlock-Elemente (siehe TextBlock) an die Eigenschaften der Person-Klasse. In der folgenden Abbildung wird die aktualisierte Darstellung des Person-Objekts angezeigt.

Ein Vorteil dieser Technik liegt in der Konsistenz, die Ihnen die Wiederverwendung der Datenvorlage zur konsistenten Anzeige Ihrer Objekte in der gesamten Anwendung erlaubt.

Das vollständige Beispiel finden Sie unter Beispiel für das Navigieren zu einem benutzerdefinierten Objekt.

Weitere Informationen zu Datenvorlagen finden Sie unter Übersicht über Datenvorlagen.

Sicherheit

Die WPF-Navigationsunterstützung ermöglicht es, dass über das Internet zu XBAPs navigiert werden kann. Außerdem können Anwendungen Inhalt von Drittanbietern hosten. Um Benutzer und Anwendungen vor bedrohlichem Verhalten zu schützen, stellt WPF eine Palette an Sicherheitsfeatures bereit, die unter Windows Presentation Foundation-Sicherheit und Windows Presentation Foundation - Sicherheit bei teilweiser Vertrauenswürdigkeit behandelt werden.

Siehe auch

Aufgaben

Speichern eines Zustandssatzes über mehrere Seiteninstanzen

Speichern mehrerer Zustandssätze pro Seiteninstanz

Speichern eines Zustandselements über mehrere Seiteninstanzen

Beispiel für einen Assistenten

Beispiel für eine benutzerdefinierte NavigationWindow-Benutzeroberfläche

Beispiel für Frame-Navigation in einem Fenster

Beispiel für Anwendungscookies

Konzepte

Übersicht über die Anwendungsverwaltung

Paket-URIs in Windows Presentation Foundation

Übersicht über Windows Media Center-gehostete Anwendungen in Windows Presentation Foundation

Übersicht über die strukturierte Navigation

Bereitstellen von WPF-Anwendungen (WPF)

Referenz

SetCookie

GetCookie

Änderungsprotokoll

Date	Versionsgeschichte	Grund
Juli 2008	Navigieren zu HTML-Dateien mit dem WebBrowser-Steuerelement wurde hinzugefügt.	SP1-Featureänderung.