Übersicht über die NavigationNavigation Overview

Windows Presentation Foundation (WPF) unterstützt die Navigation im Browser Stil, die in zwei Anwendungs Typen verwendet werden kann: eigenständige Anwendungen und XAML-Browser Anwendungen (XBAPs).Windows Presentation Foundation (WPF) supports browser-style navigation that can be used in two types of applications: standalone applications and XAML browser applications (XBAPs). Zum Verpacken von Inhalten für die Navigation stellt WPF die Page-Klasse bereit.To package content for navigation, WPF provides the Page class. Sie können von einem Page zu einem anderen deklarativ navigieren, indem Sie eine Hyperlinkoder Programm gesteuert verwenden, indem Sie die-NavigationServiceverwenden.You can navigate from one Page to another declaratively, by using a Hyperlink, or programmatically, by using the NavigationService. WPF verwendet das Journal, um Seiten zu speichern, von denen aus navigiert wurde, und um zurück zu diesen zu navigieren.WPF uses the journal to remember pages that have been navigated from and to navigate back to them.

Page, Hyperlink, NavigationServiceund das Journal bilden den Kern der von WPF angebotenen Navigationsunterstützung.Page, Hyperlink, NavigationService, and the journal form the core of the navigation support offered by WPF. In dieser Übersicht werden diese Features ausführlich erläutert, bevor die erweiterte Navigationsunterstützung behandelt wird, die die Navigation zu losen Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) Dateien, HTML-Dateien und Objekten umfasst.This overview explores these features in detail before covering advanced navigation support that includes navigation to loose Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) files, HTML files, and objects.

Hinweis

In diesem Thema bezieht sich der Begriff "Browser" nur auf Browser, die WPF-Anwendungen hosten können, die derzeit Microsoft Internet Explorer und Firefox enthalten.In this topic, the term "browser" refers only to browsers that can host WPF applications, which currently includes Microsoft Internet Explorer and Firefox. Wenn bestimmte WPF-Funktionen nur von einem bestimmten Browser unterstützt werden, wird auf die Browserversion verwiesen.Where specific WPF features are supported only by a particular browser, the browser version is referred to.

Dieses Thema enthält eine Übersicht über die wichtigsten Navigationsfunktionen in WPF.This topic provides an overview of the key navigation capabilities 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 einer XBAP dargestellt werden.These capabilities are available to both standalone applications and XBAPs, although this topic presents them within the context of an XBAP.

Hinweis

In diesem Thema wird nicht erläutert, wie XBAPs erstellt und bereitgestellt werden.This topic doesn't discuss how to build and deploy XBAPs. Weitere Informationen zu XBAPs finden Sie unter Übersicht über WPF-XAML-Browser Anwendungen.For more information on XBAPs, see WPF XAML Browser Applications Overview.

In diesem Abschnitt werden die folgenden Aspekte der Navigation erklärt und veranschaulicht:This section explains and demonstrates the following aspects of navigation:

Implementieren einer SeiteImplementing a Page

In WPF können Sie zu verschiedenen Inhaltstypen navigieren, die .NET Framework-Objekte, benutzerdefinierte Objekte, Enumerationswerte, Benutzer Steuerelemente, XAMLXAML Dateien und HTML-Dateien enthalten.In WPF, you can navigate to several content types that include .NET Framework objects, custom objects, enumeration values, user controls, XAMLXAML files, and HTML files. Sie werden jedoch feststellen, dass die gängigste und bequeme Methode zum Verpacken von Inhalten das Verwenden von Pageist.However, you'll find that the most common and convenient way to package content is by using Page. Außerdem werden Page Navigations spezifische Features implementiert, um ihre Darstellung zu verbessern und die Entwicklung zu vereinfachen.Furthermore, Page implements navigation-specific features to enhance their appearance and simplify development.

Mithilfe von Pagekönnen Sie eine Navigier Bare Seite XAMLXAML Inhalts deklarativ implementieren, indem Sie wie folgt Markup verwenden.Using Page, you can declaratively implement a navigable page of XAMLXAML content by using markup like the following.

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

Eine Page, die in XAMLXAML Markup implementiert ist, hat Page als Stamm Element und erfordert die WPF-XML-Namespace Deklaration.A Page that is implemented in XAMLXAML markup has Page as its root element and requires the WPF XML namespace declaration. Das Page-Element enthält den Inhalt, zu dem Sie navigieren und den Sie anzeigen möchten.The Page element contains the content that you want to navigate to and display. Sie fügen Inhalt hinzu, indem Sie das Page.Content-Eigenschafts Element festlegen, wie im folgenden Markup gezeigt.You add content by setting the Page.Content property element, as shown in the following markup.

<Page xmlns="http://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!“.Page.Content can only contain one child element; in the preceding example, the content is a single string, "Hello, Page!" In der Praxis verwenden Sie in der Regel ein Layoutsteuerelement als untergeordnetes Element (siehe Layout), um Ihre Inhalte zu speichern und zu verfassen.In practice, you will usually use a layout control as the child element (see Layout) to contain and compose your content.

Die untergeordneten Elemente eines Page-Elements werden als Inhalt eines Page betrachtet. Folglich müssen Sie die explizite Page.Content Deklaration nicht verwenden.The child elements of a Page element are considered to be the content of a Page and, consequently, you don't need to use the explicit Page.Content declaration. Das folgende Markup stellt die deklarative Entsprechung zum vorherigen Beispiel dar.The following markup is the declarative equivalent to the preceding sample.

<Page xmlns="http://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.In this case, Page.Content is automatically set with the child elements of the Page element. Weitere Informationen finden Sie unter WPF-Inhaltsmodell.For more information, see WPF Content Model.

Ein nur-Markup-Page ist zum Anzeigen von Inhalten nützlich.A markup-only Page is useful for displaying content. Eine Page kann jedoch auch Steuerelemente anzeigen, die es Benutzern ermöglichen, mit der Seite zu interagieren, und Sie kann auf die Interaktion von Benutzern reagieren, indem Ereignisse behandelt und Anwendungslogik aufgerufen wird.However, a Page can also display controls that allow users to interact with the page, and it can respond to user interaction by handling events and calling application logic. Eine interaktive Page wird mithilfe einer Kombination aus Markup und Code Behind implementiert, wie im folgenden Beispiel gezeigt.An interactive Page is implemented by using a combination of markup and code-behind, as shown in the following example.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.HomePage">
  Hello, from the XBAP HomePage!
</Page>
using System.Windows.Controls;

namespace SDKSample
{
    public partial class HomePage : Page
    {
        public HomePage()
        {
            InitializeComponent();
        }
    }
}

Imports System.Windows.Controls

Namespace SDKSample
    Partial Public Class HomePage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Damit eine Markup- und eine Code-Behind-Datei zusammenarbeiten können, ist die folgende Konfiguration erforderlich:To allow a markup file and code-behind file to work together, the following configuration is required:

  • Im Markup muss das Page-Element das x:Class-Attribut enthalten.In markup, the Page element must include the x:Class attribute. Wenn die Anwendung erstellt wird, bewirkt das vorhanden sein von x:Class in der Markup Datei, dass Microsoft Build Engine (MSBuild) eine partial Klasse erstellt, die von Page abgeleitet ist und über den Namen verfügt, der durch das x:Class-Attribut angegeben wird.When the application is built, the existence of x:Class in the markup file causes Microsoft build engine (MSBuild) to create a partial class that derives from Page and has the name that is specified by the x:Class attribute. Dies erfordert das Hinzufügen einer XML-Namespace Deklaration für das XAMLXAML Schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").This requires the addition of an XML namespace declaration for the XAMLXAML schema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Die generierte partial Klasse implementiert InitializeComponent, das aufgerufen wird, um die Ereignisse zu registrieren und die Eigenschaften festzulegen, die im Markup implementiert werden.The generated partial class implements InitializeComponent, which is called to register the events and set the properties that are implemented in markup.

  • 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 Pageabgeleitet werden.In code-behind, the class must be a partial class with the same name that is specified by the x:Class attribute in markup, and it must derive from Page. Dadurch kann die Code-Behind-Datei mit der partial-Klasse verknüpft werden, die beim Erstellen der Anwendung für die Markup Datei generiert wird (siehe Erstellen einer WPF-Anwendung).This allows the code-behind file to be associated with the partial class that is generated for the markup file when the application is built (see Building a WPF Application).

  • Im Code-Behind muss die Page Klasse einen Konstruktor implementieren, der die InitializeComponent-Methode aufruft.In code-behind, the Page class must implement a constructor that calls the InitializeComponent method. InitializeComponent wird von der generierten partial Klasse der Markup Datei implementiert, um Ereignisse zu registrieren und im Markup definierte Eigenschaften festzulegen.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Hinweis

Wenn Sie Ihrem Projekt mithilfe von Visual Studio eine neue Page hinzufügen, wird der Page mithilfe von Markup und Code Behind implementiert. er enthält die erforderliche Konfiguration zum Erstellen der Zuordnung zwischen dem Markup und den Code-Behind-Dateien, wie hier beschrieben.When you add a new Page to your project using Visual Studio, the Page is implemented using both markup and code-behind, and it includes the necessary configuration to create the association between the markup and code-behind files as described here.

Wenn Sie ein Pagehaben, können Sie dorthin navigieren.Once you have a Page, you can navigate to it. Um den ersten Page anzugeben, zu dem eine Anwendung navigiert, müssen Sie die Start Pagekonfigurieren.To specify the first Page that an application navigates to, you need to configure the start Page.

Konfigurieren einer StartseiteConfiguring a Start Page

XBAPs erfordert, dass eine bestimmte Menge an Anwendungs Infrastruktur in einem Browser gehostet wird.XBAPs require a certain amount of application infrastructure to be hosted in a browser. In WPF ist die Application Klasse Teil einer Anwendungs Definition, die die erforderliche Anwendungs Infrastruktur festlegt (siehe Übersicht über die Anwendungs Verwaltung).In WPF, the Application class is part of an application definition that establishes the required application infrastructure (see Application Management Overview).

Eine Anwendungs Definition wird in der Regel unter Verwendung von Markup und Code Behind implementiert, wobei die Markup Datei als MSBuild-ApplicationDefinition Element konfiguriert ist.An application definition is usually implemented using both markup and code-behind, with the markup file configured as an MSBuildApplicationDefinition item. Im folgenden finden Sie eine Anwendungs Definition für eine XBAP.The following is an application definition for an XBAP.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App" />
using System.Windows;

namespace SDKSample
{
    public partial class App : Application { }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
    End Class
End Namespace

Eine XBAP kann die Anwendungs Definition verwenden, um einen Start Pageanzugeben. Dies ist der Page, der beim Starten der XBAP automatisch geladen wird.An XBAP can use its application definition to specify a start Page, which is the Page that is automatically loaded when the XBAP is launched. Hierzu legen Sie die StartupUri-Eigenschaft mit dem URI (Uniform Resource Identifier) für die gewünschte Pagefest.You do this by setting the StartupUri property with the uniform resource identifier (URI) for the desired Page.

Hinweis

In den meisten Fällen wird der Page entweder in kompiliert oder mit einer Anwendung bereitgestellt.In most cases, the Page is either compiled into or deployed with an application. In diesen Fällen ist der URI, der einen Page identifiziert, ein Paket-URI, bei dem es sich um einen URI handelt, der dem Paket Schema entspricht.In these cases, the URI that identifies a Page is a pack URI, which is a URI that conforms to the pack scheme. Paket-URIs werden in Paket-URIs in WPFausführlicher erläutert.Pack URIs are discussed further in Pack URIs in WPF. Sie können auch mit dem HTTP-Schema zum Inhalt navigieren. Das Schema wird nachfolgend erklärt.You can also navigate to content using the http scheme, which is discussed below.

Sie können StartupUri deklarativ in Markup festlegen, wie im folgenden Beispiel gezeigt.You can set StartupUri declaratively in markup, as shown in the following example.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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.In this example, the StartupUri attribute is set with a relative pack URI that identifies HomePage.xaml. Wenn die XBAP gestartet wird, wird Homepage. XAML automatisch zu navigieren und angezeigt.When the XBAP is launched, HomePage.xaml is automatically navigated to and displayed. Dies wird in der folgenden Abbildung veranschaulicht, die eine XBAP anzeigt, die von einem Webserver gestartet wurde.This is demonstrated by the following figure, which shows an XBAP that was launched from a Web server.

XBAP-SeiteXBAP page

Hinweis

Weitere Informationen zur Entwicklung und Bereitstellung von XBAPs finden Sie unter Übersicht über WPF-XAML-Browser Anwendungen und bereitstellen einer WPF-Anwendung.For more information regarding the development and deployment of XBAPs, see WPF XAML Browser Applications Overview and Deploying a WPF Application.

Konfigurieren von Titel, Breite und Höhe des HostfenstersConfiguring the Host Window's Title, Width, and Height

Möglicherweise haben Sie in der vorherigen Abbildung bemerkt, dass der Titel sowohl des Browsers als auch des Registerkarten Bereichs der URI für die XBAP ist.One thing you may have noticed from the previous figure is that the title of both the browser and the tab panel is the URI for the XBAP. Der Titel ist zum einen lang und zum anderen weder ansprechend noch informativ.Besides being long, the title is neither attractive nor informative. Aus diesem Grund bietet Page eine Möglichkeit, den Titel durch Festlegen der WindowTitle-Eigenschaft zu ändern.For this reason, Page offers a way for you to change the title by setting the WindowTitle property. Darüber hinaus können Sie die Breite und Höhe des Browserfensters konfigurieren, indem Sie WindowWidth bzw. WindowHeightfestlegen.Furthermore, you can configure the width and height of the browser window by setting WindowWidth and WindowHeight, respectively.

WindowTitle, WindowWidthund WindowHeight können im Markup deklarativ festgelegt werden, wie im folgenden Beispiel gezeigt.WindowTitle, WindowWidth, and WindowHeight can be set declaratively in markup, as shown in the following example.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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 ist in der folgenden Abbildung dargestellt.The result is shown in the following figure.

Fenstertitel, Höhe, BreiteWindow title, height, width

Eine typische XBAP besteht aus mehreren Seiten.A typical XBAP comprises several pages. Die einfachste Möglichkeit, von einer Seite zu einer anderen zu navigieren, ist die Verwendung einer Hyperlink.The simplest way to navigate from one page to another is to use a Hyperlink. Sie können einem Page deklarativ eine Hyperlink hinzufügen, indem Sie das Hyperlink-Element verwenden, das im folgenden Markup gezeigt wird.You can declaratively add a Hyperlink to a Page by using the Hyperlink element, which is shown in the following markup.

<Page
  xmlns="http://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 Hyperlink Element ist Folgendes erforderlich:A Hyperlink element requires the following:

  • Der Paket-URI der Page, zu der navigiert werden soll, wie vom NavigateUri-Attribut angegeben.The pack URI of the Page to navigate to, as specified by the NavigateUri attribute.

  • Inhalt, auf den ein Benutzer klicken kann, um die Navigation zu initiieren, z. b. Text und Bilder (für den Inhalt, den das Hyperlink Element enthalten kann, finden Sie unter Hyperlink).Content that a user can click to initiate the navigation, such as text and images (for the content that the Hyperlink element can contain, see Hyperlink).

In der folgenden Abbildung wird eine XBAP mit einem Page gezeigt, der über eine Hyperlinkverfügt.The following figure shows an XBAP with a Page that has a Hyperlink.

Seite mit HyperlinkPage with Hyperlink

Das Klicken auf den Hyperlink bewirkt, dass die XBAP zu der Page navigiert, die durch das NavigateUri-Attribut identifiziert wird.As you would expect, clicking the Hyperlink causes the XBAP to navigate to the Page that is identified by the NavigateUri attribute. Außerdem fügt die XBAP der Liste zuletzt verwendete Seiten in Internet Explorer einen Eintrag für den vorherigen Page hinzu.Additionally, the XBAP adds an entry for the previous Page to the Recent Pages list in Internet Explorer. Das wird in der folgenden Abbildung gezeigt.This is shown in the following figure.

Zurück-und vorwärts-SchaltflächenBack and Forward buttons

Ebenso wie die Navigation von einem Page zu einem anderen unterstützt Hyperlink auch die Fragmentnavigation.As well as supporting navigation from one Page to another, Hyperlink also supports fragment navigation.

FragmentnavigationFragment Navigation

Bei der FragmentNavigation wird die Navigation zu einem Inhalts Fragment entweder im aktuellen Page oder in einem anderen Page.Fragment navigation is the navigation to a content fragment in either the current Page or another Page. In WPF ist ein Inhalts Fragment der Inhalt, der in einem benannten Element enthalten ist.In WPF, a content fragment is the content that is contained by a named element. Ein benanntes Element ist ein Element, dessen Name Attribut festgelegt ist.A named element is an element that has its Name attribute set. Das folgende Markup zeigt ein benanntes TextBlock Element, das ein Inhalts Fragment enthält.The following markup shows a named TextBlock element that contains a content fragment.

<Page
    xmlns="http://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 eine Hyperlink zu einem Inhalts Fragment navigiert, muss das NavigateUri Attribut Folgendes enthalten:For a Hyperlink to navigate to a content fragment, the NavigateUri attribute must include the following:

  • Der URI des Page mit dem Inhalts Fragment, zu dem navigiert werden soll.The URI of the Page with the content fragment to navigate to.

  • Ein „#“-Zeichen.A "#" character.

  • Der Name des Elements auf dem Page, das das Inhalts Fragment enthält.The name of the element on the Page that contains the content fragment.

Ein Fragment-URI weist das folgende Format auf.A fragment URI has the following format.

PageUri -# ElementNamePageURI # ElementName

Im folgenden finden Sie ein Beispiel für eine Hyperlink, die für die Navigation zu einem Inhalts Fragment konfiguriert ist.The following shows an example of a Hyperlink that is configured to navigate to a content fragment.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page That Navigates To Fragment" >
<Hyperlink NavigateUri="PageWithFragments.xaml#Fragment1">
  Navigate To pack Fragment
</Hyperlink>
</Page>

Hinweis

In diesem Abschnitt wird die Standard Implementierung der FragmentNavigation in WPF beschrieben.This section describes the default fragment navigation implementation in WPF. Mithilfe von WPF können Sie auch Ihr eigenes fragmentnavigationschema implementieren, das teilweise die Behandlung des NavigationService.FragmentNavigation Ereignisses erfordert.WPF also allows you to implement your own fragment navigation scheme which, in part, requires handling the NavigationService.FragmentNavigation event.

Wichtig

Sie können zu Fragmenten in losen XAMLXAML Seiten (nur Markup XAMLXAML Dateien mit Page als Stamm Element) navigieren, wenn die Seiten über HTTP durchsucht werden können.You can navigate to fragments in loose XAMLXAML pages (markup-only XAMLXAML files with Page as the root element) only if the pages can be browsed via HTTP.

Eine lose XAMLXAML Seite kann jedoch zu ihren eigenen Fragmenten navigieren.However, a loose XAMLXAML page can navigate to its own fragments.

Hyperlink ermöglicht es einem Benutzer, die Navigation zu einer bestimmten Pagezu initiieren, wird das Auffinden und Herunterladen der Seite von der NavigationService-Klasse durchgeführt.While Hyperlink allows a user to initiate navigation to a particular Page, the work of locating and downloading the page is performed by the NavigationService class. Im Wesentlichen bietet NavigationService die Möglichkeit, eine Navigations Anforderung im Namen des Client Codes, z. b. der Hyperlink, zu verarbeiten.Essentially, NavigationService provides the ability to process a navigation request on behalf of client code, such as the Hyperlink. Darüber hinaus implementiert NavigationService eine höhere Unterstützung für das Nachverfolgen und beeinflussen einer Navigations Anforderung.Additionally, NavigationService implements higher-level support for tracking and influencing a navigation request.

Beim Klicken auf einen Hyperlink ruft WPF NavigationService.Navigate auf, um die Page am angegebenen Paket-URI zu suchen und herunterzuladen.When a Hyperlink is clicked, WPF calls NavigationService.Navigate to locate and download the Page at the specified pack URI. Der heruntergeladene Page wird in eine Struktur von Objekten konvertiert, deren Stamm Objekt eine Instanz des heruntergeladenen Pageist.The downloaded Page is converted to a tree of objects whose root object is an instance of the downloaded Page. Ein Verweis auf das Stamm Page Objekt wird in der NavigationService.Content-Eigenschaft gespeichert.A reference to the root Page object is stored in the NavigationService.Content property. Der Paket-URI für den Inhalt, zu dem navigiert wurde, wird in der NavigationService.Source-Eigenschaft gespeichert, während der NavigationService.CurrentSource den Paket-URI für die letzte Seite speichert, zu der navigiert wurde.The pack URI for the content that was navigated to is stored in the NavigationService.Source property, while the NavigationService.CurrentSource stores the pack URI for the last page that was navigated to.

Hinweis

Es ist möglich, dass eine WPF-Anwendung mehr als eine derzeit aktive NavigationServicehat.It is possible for a WPF application to have more than one currently active NavigationService. Weitere Informationen finden Sie unter Navigations Hosts weiter unten in diesem Thema.For more information, see Navigation Hosts later in this topic.

Programmgesteuerte Navigation mit dem NavigationsdienstProgrammatic Navigation with the Navigation Service

Sie müssen sich nicht über NavigationService informieren, wenn die Navigation mit Hyperlinkdeklarativ in Markup implementiert wird, da Hyperlink die NavigationService in Ihrem Namen verwendet.You don't need to know about NavigationService if navigation is implemented declaratively in markup using Hyperlink, because Hyperlink uses the NavigationService on your behalf. Dies bedeutet, dass, solange das direkte oder indirekte übergeordnete Element einer Hyperlink ein Navigations Host ist (siehe Navigations Hosts), Hyperlink den Navigationsdienst des Navigations Hosts suchen und verwenden können, um eine Navigations Anforderung zu verarbeiten.This means that, as long as either the direct or indirect parent of a Hyperlink is a navigation host (see Navigation Hosts), Hyperlink will be able to find and use the navigation host's navigation service to process a navigation request.

Es gibt jedoch Situationen, in denen Sie NavigationService direkt verwenden müssen, einschließlich der folgenden:However, there are situations when you need to use NavigationService directly, including the following:

  • Wenn Sie ein Page mit einem nicht Parameter losen Konstruktor instanziieren müssen.When you need to instantiate a Page using a non-parameterless constructor.

  • Wenn Sie Eigenschaften für den Page festlegen müssen, bevor Sie dorthin navigieren.When you need to set properties on the Page before you navigate to it.

  • Wenn die Page, zu der navigiert werden muss, nur zur Laufzeit bestimmt werden kann.When the Page that needs to be navigated to can only be determined at run time.

In diesen Fällen müssen Sie Code schreiben, um die Navigation Programm gesteuert zu initiieren, indem Sie die Navigate-Methode des NavigationService-Objekts aufrufen.In these situations, you need to write code to programmatically initiate navigation by calling the Navigate method of the NavigationService object. Hierfür müssen Sie einen Verweis auf eine NavigationServiceerhalten.That requires getting a reference to a NavigationService.

Abrufen eines Verweises auf NavigationServiceGetting a Reference to the NavigationService

Aus Gründen, die im Abschnitt Navigations Hosts behandelt werden, kann eine WPF-Anwendung mehr als eine NavigationServiceaufweisen.For reasons that are covered in the Navigation Hosts section, a WPF application can have more than one NavigationService. Dies bedeutet, dass Ihr Code eine Möglichkeit zum Suchen eines NavigationServicebenötigt, bei dem es sich in der Regel um die NavigationService handelt, die zur aktuellen Pagenavigiert sind.This means that your code needs a way to find a NavigationService, which is usually the NavigationService that navigated to the current Page. Sie können einen Verweis auf eine NavigationService abrufen, indem Sie die staticNavigationService.GetNavigationService-Methode aufrufen.You can get a reference to a NavigationService by calling the staticNavigationService.GetNavigationService method. Um die NavigationService zu einem bestimmten Pagezu erhalten, übergeben Sie als Argument der GetNavigationService-Methode einen Verweis auf die Page.To get the NavigationService that navigated to a particular Page, you pass a reference to the Page as the argument of the GetNavigationService method. Der folgende Code zeigt, wie Sie die NavigationService für die aktuelle Pageerhalten.The following code shows how to get the NavigationService for the current Page.

using System.Windows.Navigation;
// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = NavigationService.GetNavigationService(this);
' Get a reference to the NavigationService that navigated to this Page
Dim ns As NavigationService = NavigationService.GetNavigationService(Me)

Als Verknüpfung zum Suchen der NavigationService für eine Pageimplementiert Page die NavigationService-Eigenschaft.As a shortcut for finding the NavigationService for a Page, Page implements the NavigationService property. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

using System.Windows.Navigation;
// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = this.NavigationService;
' Get a reference to the NavigationService that navigated to this Page
Dim ns As NavigationService = Me.NavigationService

Hinweis

Ein Page kann nur dann einen Verweis auf seine NavigationService erhalten, wenn Page das Loaded Ereignis auslöst.A Page can only get a reference to its NavigationService when Page raises the Loaded event.

Programmgesteuerte Navigation zu einem SeitenobjektProgrammatic Navigation to a Page Object

Im folgenden Beispiel wird gezeigt, wie die NavigationService verwendet werden kann, um Programm gesteuert zu einem Pagezu navigieren.The following example shows how to use the NavigationService to programmatically navigate to a Page. Die programmgesteuerte Navigation ist erforderlich, da die Page, zu der navigiert wird, nur mit einem einzigen, nicht parameterlosen Konstruktor instanziiert werden kann.Programmatic navigation is required because the Page that is being navigated to can only be instantiated using a single, non-parameterless constructor. Die Page mit dem nicht Parameter losen Konstruktor wird im folgenden Markup und Code gezeigt.The Page with the non-parameterless constructor is shown in the following markup and code.

<Page
    x:Class="SDKSample.PageWithNonDefaultConstructor"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="PageWithNonDefaultConstructor">
  
  <!-- Content goes here -->
  
</Page>
using System.Windows.Controls;

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

            this.Content = message;
        }
    }
}

Namespace SDKSample
    Partial Public Class PageWithNonDefaultConstructor
        Inherits Page
        Public Sub New(ByVal message As String)
            InitializeComponent()

            Me.Content = message
        End Sub
    End Class
End Namespace

Der Page, der zum Page mit dem nicht Parameter losen Konstruktor navigiert, wird im folgenden Markup und Code gezeigt.The Page that navigates to the Page with the non-parameterless constructor is shown in the following markup and code.

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

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

Namespace SDKSample
    Partial Public Class NSNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Instantiate the page to navigate to
            Dim page As New PageWithNonDefaultConstructor("Hello!")

            ' Navigate to the page, using the NavigationService
            Me.NavigationService.Navigate(page)
        End Sub
    End Class
End Namespace

Wenn auf den Hyperlink auf diesen Page geklickt wird, wird die Navigation durch Instanziieren des Page initiiert, um zu zu navigieren, indem der nicht parameterlose Konstruktor verwendet und die NavigationService.Navigate-Methode aufgerufen wird.When the Hyperlink on this Page is clicked, navigation is initiated by instantiating the Page to navigate to using the non-parameterless constructor and calling the NavigationService.Navigate method. Navigate akzeptiert einen Verweis auf das Objekt, zu dem der NavigationService navigiert, anstelle eines Paket-URIs.Navigate accepts a reference to the object that the NavigationService will navigate to, rather than a pack URI.

Programmgesteuerte Navigation mit einem Paket-URIProgrammatic Navigation with a Pack URI

Wenn Sie einen Paket-URI Programm gesteuert erstellen müssen (wenn Sie z. b. nur den Paket-URI zur Laufzeit bestimmen können), können Sie die NavigationService.Navigate-Methode verwenden.If you need to construct a pack URI programmatically (when you can only determine the pack URI at run time, for example), you can use the NavigationService.Navigate method. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSUriNavigationPage">
  <Hyperlink Click="hyperlink_Click">Navigate to Page by Pack URI</Hyperlink>
</Page>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

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

Namespace SDKSample
    Partial Public Class NSUriNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Create a pack URI
            Dim uri As New Uri("AnotherPage.xaml", UriKind.Relative)

            ' Get the navigation service that was used to 
            ' navigate to this page, and navigate to 
            ' AnotherPage.xaml
            Me.NavigationService.Navigate(uri)
        End Sub
    End Class
End Namespace

Aktualisieren der aktuellen SeiteRefreshing the Current Page

Eine Page wird nicht heruntergeladen, wenn Sie denselben Paket-URI wie der Paket-URI aufweist, der in der NavigationService.Source-Eigenschaft gespeichert ist.A Page is not downloaded if it has the same pack URI as the pack URI that is stored in the NavigationService.Source property. Wenn Sie erzwingen möchten, dass WPF die aktuelle Seite erneut herunterlädt, können Sie die NavigationService.Refresh-Methode wie im folgenden Beispiel gezeigt aufzurufen.To force WPF to download the current page again, you can call the NavigationService.Refresh method, as shown in the following example.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSRefreshNavigationPage">
 <Hyperlink Click="hyperlink_Click">Refresh this page</Hyperlink>
</Page>
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class NSRefreshNavigationPage : Page
    {

Namespace SDKSample
    Partial Public Class NSRefreshNavigationPage
        Inherits Page
        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Refresh();
        }
    }
}
        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Force WPF to download this page again
            Me.NavigationService.Refresh()
        End Sub
    End Class
End Namespace

Wie Sie sehen, gibt es viele Möglichkeiten zum Einleiten der Navigation.There are many ways to initiate navigation, as you've seen. Wenn die Navigation initiiert wird und während der Navigation ausgeführt wird, können Sie die Navigation mithilfe der folgenden Ereignisse, die von NavigationServiceimplementiert werden, nachverfolgen und beeinflussen:When navigation is initiated, and while navigation is in progress, you can track and influence the navigation using the following events that are implemented by NavigationService:

  • Navigating.Navigating. Tritt ein, wenn eine neue Navigation angefordert wird.Occurs when a new navigation is requested. Kann zum Abbrechen der Navigation verwendet werden.Can be used to cancel the navigation.

  • NavigationProgress.NavigationProgress. Tritt regelmäßig während eines Downloadvorgangs auf, um Informationen zum Navigationsstatus bereitzustellen.Occurs periodically during a download to provide navigation progress information.

  • Navigated.Navigated. Tritt ein, nachdem die Seite gefunden und heruntergeladen wurde.Occurs when the page has been located and downloaded.

  • NavigationStopped.NavigationStopped. Tritt auf, wenn die Navigation beendet wird (durch Aufrufen von StopLoading) oder wenn eine neue Navigation angefordert wird, während eine aktuelle Navigation ausgeführt wird.Occurs when the navigation is stopped (by calling StopLoading), or when a new navigation is requested while a current navigation is in progress.

  • NavigationFailed.NavigationFailed. Tritt ein, wenn ein Fehler ausgelöst wird, während zum angeforderten Inhalt navigiert wird.Occurs when an error is raised while navigating to the requested content.

  • LoadCompleted.LoadCompleted. Tritt ein, wenn der Inhalt, zu dem navigiert wurde, geladen und analysiert wird und mit dem Rendering begonnen wurde.Occurs when content that was navigated to is loaded and parsed, and has begun rendering.

  • FragmentNavigation.FragmentNavigation. Tritt ein, wenn die Navigation zu einem Inhaltsfragment beginnt, was in folgenden Fällen geschieht:Occurs when navigation to a content fragment begins, which happens:

    • Sofort, falls sich das gewünschte Fragment im aktuellen Inhalt befindet.Immediately, if the desired fragment is in the current content.

    • Nachdem der Inhalt der Quelldatei geladen wurde und sich das gewünschte Fragment in einem anderen Inhalt befindet.After the source content has been loaded, if the desired fragment is in different content.

Die Navigationsereignisse werden in der Reihenfolge ausgelöst, die in der folgenden Abbildung dargestellt wird.The navigation events are raised in the order that is illustrated by the following figure.

Flussdiagramm für die SeitennavigationPage navigation flow chart

Im Allgemeinen ist eine Page für diese Ereignisse nicht relevant.In general, a Page isn't concerned about these events. Es ist wahrscheinlicher, dass sich eine Anwendung mit Ihnen beschäftigt, und aus diesem Grund werden diese Ereignisse auch von der Application-Klasse ausgelöst:It is more likely that an application is concerned with them and, for that reason, these events are also raised by the Application class:

Jedes Mal, wenn NavigationService ein Ereignis auslöst, löst die Application-Klasse das entsprechende-Ereignis aus.Every time NavigationService raises an event, the Application class raises the corresponding event. Frame und NavigationWindow bieten dieselben Ereignisse, um die Navigation innerhalb ihrer jeweiligen Bereiche zu erkennen.Frame and NavigationWindow offer the same events to detect navigation within their respective scopes.

In manchen Fällen könnte eine Page an diesen Ereignissen interessiert sein.In some cases, a Page might be interested in these events. Beispielsweise kann ein Page das NavigationService.Navigating-Ereignis behandeln, um zu bestimmen, ob die Navigation von sich selbst abgebrochen werden soll.For example, a Page might handle the NavigationService.Navigating event to determine whether or not to cancel navigation away from itself. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CancelNavigationPage">
  <Button Click="button_Click">Navigate to Another Page</Button>
</Page>
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

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

Namespace SDKSample
    Partial Public Class CancelNavigationPage
        Inherits Page
        Public Sub New()
            InitializeComponent()

            ' Can only access the NavigationService when the page has been loaded
            AddHandler Loaded, AddressOf CancelNavigationPage_Loaded
            AddHandler Unloaded, AddressOf CancelNavigationPage_Unloaded
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Force WPF to download this page again
            Me.NavigationService.Navigate(New Uri("AnotherPage.xaml", UriKind.Relative))
        End Sub

        Private Sub CancelNavigationPage_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
            AddHandler NavigationService.Navigating, AddressOf NavigationService_Navigating
        End Sub

        Private Sub CancelNavigationPage_Unloaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
            RemoveHandler NavigationService.Navigating, AddressOf NavigationService_Navigating
        End Sub

        Private Sub NavigationService_Navigating(ByVal sender As Object, ByVal e As NavigatingCancelEventArgs)
            ' Does the user really want to navigate to another page?
            Dim result As MessageBoxResult
            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 Then
                e.Cancel = True
            End If
        End Sub
    End Class
End Namespace

Wenn Sie einen Handler bei einem Navigations Ereignis von einem Pageregistrieren, müssen Sie wie im vorherigen Beispiel auch die Registrierung des Ereignis Handlers aufheben.If you register a handler with a navigation event from a Page, as the preceding example does, you must also unregister the event handler. Wenn Sie dies nicht tun, können Nebeneffekte in Bezug auf die Art und Weise, wie die WPF-Navigation Page Navigation mit dem Journal speichert, auftreten.If you don't, there may be side effects with respect to how WPF navigation remembers Page navigation using the journal.

Aufzeichnung der Navigation mithilfe des JournalsRemembering Navigation with the Journal

WPF verwendet zwei Stapel, um die Seiten zu merken, von denen Sie navigiert sind: einen BackStack und einen vorwärts Stapel.WPF uses two stacks to remember the pages that you have navigated from: a back stack and a forward stack. Wenn Sie von der aktuellen Page zu einer neuen Page oder vorwärts zu einer vorhandenen Pagenavigieren, wird die aktuelle Page zum BackStackhinzugefügt.When you navigate from the current Page to a new Page or forward to an existing Page, the current Page is added to the back stack. Wenn Sie von der aktuellen Page zurück zum vorherigen Pagenavigieren, wird die aktuelle Page dem Vorwärts Stapelhinzugefügt.When you navigate from the current Page back to the previous Page, the current Page is added to the forward stack. Der Rückwärts- und der Vorwärtsstapel sowie die Funktion zum Verwalten der Stapel werden zusammen als das Journal bezeichnet.The back stack, the forward stack, and the functionality to manage them, are collectively referred to as the journal. Jedes Element im Hintergrund Stapel und der vorwärts Stapel ist eine Instanz der JournalEntry-Klasse und wird als Journal Eintragbezeichnet.Each item in the back stack and the forward stack is an instance of the JournalEntry class, and is referred to as a journal entry.

Konzeptionell funktioniert das Journal genauso wie die Schaltflächen " zurück " und " Vorwärts " in Internet Explorer.Conceptually, the journal operates the same way that the Back and Forward buttons in Internet Explorer do. Diese sind in der folgenden Abbildung dargestellt.These are shown in the following figure.

Zurück-und vorwärts-SchaltflächenBack and Forward buttons

Bei XBAPs, die von Internet Explorer gehostet werden, wird das Journal von WPF in die Navigations UIUI von Internet Explorer integriert.For XBAPs that are hosted by Internet Explorer, WPF integrates the journal into the navigation UIUI of Internet Explorer. Dadurch können Benutzer mithilfe der Schaltflächen " zurück", " Vorwärts" und " Letzte Seiten " in Internet Explorer auf Seiten in einer XBAP navigieren.This allows users to navigate pages in an XBAP by using the Back, Forward, and Recent Pages buttons in Internet Explorer.

Wichtig

Wenn ein Benutzer in Internet Explorer von und zurück zu einer XBAP navigiert, werden nur die Journal Einträge für Seiten, die nicht aktiv gehalten wurden, im Journal beibehalten.In Internet Explorer, when a user navigates away from and back to an XBAP, only the journal entries for pages that were not kept alive are retained in the journal. Weitere Informationen zur Aufrechterhaltung von Seiten finden Sie unter Seiten Lebensdauer und das Journal weiter unten in diesem Thema.For discussion on keeping pages alive, see Page Lifetime and the Journal later in this topic.

Standardmäßig ist der Text für jede Page, der in der Liste zuletzt verwendete Seiten von Internet Explorer angezeigt wird, der URI für die Page.By default, the text for each Page that appears in the Recent Pages list of Internet Explorer is the URI for the Page. In vielen Fällen ist das für den Benutzer nicht besonders sinnvoll.In many cases, this is not particularly meaningful to the user. Sie können den Text jedoch mithilfe einer der folgenden Optionen ändern:Fortunately, you can change the text using one the following options:

  1. Der Wert des angefügten JournalEntry.Name Attributs.The attached JournalEntry.Name attribute value.

  2. Der Wert des Page.Title Attributs.The Page.Title attribute value.

  3. Der Page.WindowTitle-Attribut Wert und der URI für die aktuelle Page.The Page.WindowTitle attribute value and the URI for the current Page.

  4. Der URI für die aktuelle Page.The URI for the current Page. (Standardeinstellung)(Default)

Die Reihenfolge, in der die Optionen aufgeführt sind, entspricht der Rangfolge zum Suchen von Text.The order in which the options are listed matches the order of precedence for finding the text. Wenn JournalEntry.Name z. b. festgelegt ist, werden die anderen Werte ignoriert.For example, if JournalEntry.Name is set, the other values are ignored.

Im folgenden Beispiel wird das Page.Title-Attribut verwendet, um den Text zu ändern, der für einen Journal Eintrag angezeigt wird.The following example uses the Page.Title attribute to change the text that appears for a journal entry.

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

namespace SDKSample
{
    public partial class PageWithTitle : Page
    {

Namespace SDKSample
    Partial Public Class PageWithTitle
        Inherits Page
    }
}
    End Class
End Namespace

Obwohl ein Benutzer im Journal mithilfe der Seiten " zurück", " Vorwärts" und " zuletzt verwendet" im Internet Explorer navigieren kann, können Sie auch mit den von WPF bereitgestellten deklarativen und programmatischen Mechanismen durch das Journal navigieren.Although a user can navigate the journal by using the Back, Forward, and Recent Pages in Internet Explorer, you can also navigate the journal using both declarative and programmatic mechanisms provided by WPF. Ein Grund hierfür ist die Bereitstellung benutzerdefinierter Navigations-UIs auf Ihren Seiten.One reason to do this is to provide custom navigation UIs in your pages.

Sie können die Unterstützung für Journal Navigation deklarativ hinzufügen, indem Sie die von NavigationCommandsverfügbar gemachten Navigations Befehle verwenden.You can declaratively add journal navigation support by using the navigation commands exposed by NavigationCommands. Im folgenden Beispiel wird veranschaulicht, wie der BrowseBack Navigations Befehl verwendet wird.The following example demonstrates how to use the BrowseBack navigation command.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NavigationCommandsPage">
<Hyperlink Command="NavigationCommands.BrowseBack">Back</Hyperlink>
<Hyperlink Command="NavigationCommands.BrowseForward">Forward</Hyperlink>
</Page>

Sie können das Journal Programm gesteuert mithilfe eines der folgenden Member der NavigationService-Klasse navigieren:You can programmatically navigate the journal by using one of the following members of the NavigationService class:

Das Journal kann auch Programm gesteuert bearbeitet werden, wie unter beibehalten des Inhalts Zustands mit dem Navigationsverlauf weiter unten in diesem Thema erläutert.The journal can also be manipulated programmatically, as discussed in Retaining Content State with Navigation History later in this topic.

Seitenlebensdauer und das JournalPage Lifetime and the Journal

Stellen Sie sich eine XBAP mit mehreren Seiten vor, die umfangreiche Inhalte enthalten, einschließlich Grafiken, Animationen und Medien.Consider an XBAP with several pages that contain rich content, including graphics, animations, and media. Die Speicherbeanspruchung für Seiten wie diese könnte recht groß sein, insbesondere, wenn Video- und Audiomedien verwendet werden.The memory footprint for pages like these could be quite large, particularly if video and audio media are used. Da das Journal die Seiten "speichert", zu denen navigiert wurde, könnte eine solche XBAP schnell eine große und spürbare Menge an Arbeitsspeicher beanspruchen.Given that the journal "remembers" pages that have been navigated to, such an XBAP could quickly consume a large and noticeable amount of memory.

Aus diesem Grund besteht das Standardverhalten des Journal darin, Page Metadaten in jedem Journal Eintrag zu speichern, anstatt einen Verweis auf ein Page Objekt zu erhalten.For this reason, the default behavior of the journal is to store Page metadata in each journal entry rather than a reference to a Page object. Wenn ein Journal Eintrag zu navigiert wird, werden seine Page Metadaten verwendet, um eine neue Instanz des angegebenen Pagezu erstellen.When a journal entry is navigated to, its Page metadata is used to create a new instance of the specified Page. Folglich hat jede Page, die navigiert wird, die Gültigkeitsdauer, die in der folgenden Abbildung veranschaulicht wird.As a consequence, each Page that is navigated has the lifetime that is illustrated by the following figure.

Seiten LebensdauerPage lifetime

Obwohl die Verwendung des standardmäßigen journalingverhaltens die Arbeitsspeicher Nutzung einsparen kann, kann die Renderingleistung pro Seite reduziert werden. die Neuerstellung einer Page kann zeitaufwändig sein, insbesondere, wenn Sie über umfangreiche Inhalte verfügt.Although using the default journaling behavior can save on memory consumption, per-page rendering performance might be reduced; reinstantiating a Page can be time-intensive, particularly if it has a lot of content. Wenn Sie eine Page Instanz im Journal beibehalten müssen, können Sie hierfür zwei Verfahren erstellen.If you need to retain a Page instance in the journal, you can draw on two techniques for doing so. Zuerst können Sie Programm gesteuert zu einem Page Objekt navigieren, indem Sie die NavigationService.Navigate-Methode aufrufen.First, you can programmatically navigate to a Page object by calling the NavigationService.Navigate method.

Zweitens können Sie angeben, dass WPF eine Instanz eines Page im Journal beibehalten soll, indem Sie die Eigenschaft KeepAlive auf true (Standardwert false) festlegen.Second, you can specify that WPF retain an instance of a Page in the journal by setting the KeepAlive property to true (the default is false). Wie im folgenden Beispiel gezeigt, können Sie KeepAlive deklarativ in Markup festlegen.As shown in the following example, you can set KeepAlive declaratively in markup.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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 Page, die aufrechterhalten wird, unterscheidet sich ganz leicht von einer, die nicht ist.The lifetime of a Page that is kept alive is subtly different from one that is not. Wenn ein Page, das aktiv bleibt, zu der navigiert wird, wird es wie ein Page instanziiert, das nicht aktiv bleibt.The first time a Page that is kept alive is navigated to, it is instantiated just like a Page that is not kept alive. Da eine Instanz der Page im Journal beibehalten wird, wird Sie jedoch nie so lange instanziiert, wie Sie im Journal verbleibt.However, because an instance of the Page is retained in the journal, it is never instantiated again for as long as it remains in the journal. Wenn eine Page eine Initialisierungs Logik aufweist, die jedes Mal aufgerufen werden muss, wenn die Page navigiert wird, sollten Sie Sie aus dem Konstruktor in einen Handler für das Loaded-Ereignis verschieben.Consequently, if a Page has initialization logic that needs to be called every time the Page is navigated to, you should move it from the constructor into a handler for the Loaded event. Wie in der folgenden Abbildung gezeigt, werden die Loaded-und Unloaded Ereignisse immer noch ausgelöst, wenn eine Page zu bzw. zu der navigiert wird.As shown in the following figure, the Loaded and Unloaded events are still raised each time a Page is navigated to and from, respectively.

Wenn die geladenen und entladenen Ereignisse ausgelöst werdenWhen the Loaded and Unloaded events are raised

Wenn ein Page nicht aktiv bleibt, sollten Sie keines der folgenden Aktionen ausführen:When a Page is not kept alive, you should not do either of the following:

  • Speichern eines Verweises auf die Seite oder einen Teil der SeiteStore a reference to it, or any part of it.

  • Registrieren von Ereignishandlern für Ereignisse, die nicht von ihr implementiert werdenRegister event handlers with events that are not implemented by it.

Durch diese beiden Schritte werden Verweise erstellt, die erzwingen, dass die Page im Arbeitsspeicher beibehalten werden, auch nachdem Sie aus dem Journal entfernt wurde.Doing either of these will create references that force the Page to be retained in memory, even after it has been removed from the journal.

Im Allgemeinen sollten Sie das standardmäßige Page Verhalten bevorzugen, bei dem ein Page nicht aktiv bleibt.In general, you should prefer the default Page behavior of not keeping a Page alive. Dies zieht jedoch Auswirkungen auf den Zustand nach sich, die im nächsten Abschnitt erörtert werden.However, this has state implications that are discussed in the next section.

Beibehalten des Inhaltszustands über den NavigationsverlaufRetaining Content State with Navigation History

Wenn ein Page nicht aktiv bleibt und über Steuerelemente verfügt, die Daten vom Benutzer sammeln, was geschieht mit den Daten, wenn ein Benutzer von und zurück zum Pagenavigiert?If a Page is not kept alive, and it has controls that collect data from the user, what happens to the data if a user navigates away from and back to the Page? Aus Gründen der Benutzererfahrung sollte der Benutzer erwarten, dass die zuvor eingegebenen Daten angezeigt werden.From a user experience perspective, the user should expect to see the data they entered previously. Da bei jeder Navigation eine neue Instanz der Page erstellt wird, werden die Steuerelemente, die die Daten gesammelt haben, neu erstellt, und die Daten gehen verloren.Unfortunately, because a new instance of the Page is created with each navigation, the controls that collected the data are reinstantiated and the data is lost.

Glücklicherweise bietet das Journal Unterstützung für das Speichern von Daten über Page Navigationen hinweg, einschließlich der Steuerungsdaten.Fortunately, the journal provides support for remembering data across Page navigations, including control data. Insbesondere fungiert der Journal Eintrag für jede Page als temporärer Container für den zugeordneten Page Zustand.Specifically, the journal entry for each Page acts as a temporary container for the associated Page state. Die folgenden Schritte beschreiben, wie diese Unterstützung verwendet wird, wenn ein Page von der navigiert wird:The following steps outline how this support is used when a Page is navigated from:

  1. Ein Eintrag für die aktuelle Page wird dem Journal hinzugefügt.An entry for the current Page is added to the journal.

  2. Der Status des Page wird mit dem Journal Eintrag für diese Seite gespeichert, der dem BackStack hinzugefügt wird.The state of the Page is stored with the journal entry for that page, which is added to the back stack.

  3. Die neue Page wird zu navigiert.The new Page is navigated to.

Wenn die Seite Page über das Journal zurück navigiert wird, werden die folgenden Schritte ausgeführt:When the page Page is navigated back to, using the journal, the following steps take place:

  1. Die Page (der obere Journal Eintrag im BackStack) wird instanziiert.The Page (the top journal entry on the back stack) is instantiated.

  2. Die Page wird mit dem Status aktualisiert, der mit dem Journal Eintrag für den Pagegespeichert wurde.The Page is refreshed with the state that was stored with the journal entry for the Page.

  3. Der Page wird zurück zu zurück navigiert.The Page is navigated back to.

WPF verwendet diese Unterstützung automatisch, wenn die folgenden Steuerelemente für eine Pageverwendet werden:WPF automatically uses this support when the following controls are used on a Page:

Wenn eine Page diese Steuerelemente verwendet, werden die in Sie eingegebenen Daten über Page Navigationen hinweg gespeichert, wie in der folgenden Abbildung in der Favoriten FarbeListBox dargestellt.If a Page uses these controls, data entered into them is remembered across Page navigations, as demonstrated by the Favorite ColorListBox in the following figure.

Seite mit Steuerelementen, die den Zustand speichernPage with controls that remember state

Wenn eine Page andere Steuerelemente als die in der vorangehenden Liste aufweist oder wenn State in benutzerdefinierten Objekten gespeichert wird, müssen Sie Code schreiben, damit das Journal den Status über Page Navigationen hinweg speichert.When a Page has controls other than those in the preceding list, or when state is stored in custom objects, you need to write code to cause the journal to remember state across Page navigations.

Wenn Sie in Page Navigationen kleinere Teile des Zustands speichern müssen, können Sie Abhängigkeits Eigenschaften (siehe DependencyProperty) verwenden, die mit dem FrameworkPropertyMetadata.Journal Metadata-Flag konfiguriert sind.If you need to remember small pieces of state across Page navigations, you can use dependency properties (see DependencyProperty) that are configured with the FrameworkPropertyMetadata.Journal metadata flag.

Wenn sich der Status, den Ihr Page über die gesamte Navigation hinweg berücksichtigen muss, aus mehreren Daten Teilen besteht, ist es möglicherweise weniger Code intensiv, den Zustand in einer einzigen Klasse zu kapseln und die IProvideCustomContentState Schnittstelle zu implementieren.If the state that your Page needs to remember across navigations comprises multiple pieces of data, you may find it less code intensive to encapsulate your state in a single class and implement the IProvideCustomContentState interface.

Wenn Sie durch verschiedene Zustände eines einzelnen Pagenavigieren müssen, ohne von der Page selbst zu navigieren, können Sie IProvideCustomContentState und NavigationService.AddBackEntryverwenden.If you need to navigate through various states of a single Page, without navigating from the Page itself, you can use IProvideCustomContentState and NavigationService.AddBackEntry.

CookiesCookies

Eine andere Möglichkeit, wie WPF-Anwendungen Daten speichern können, ist die Verwendung von Cookies, die mit den Methoden SetCookie und GetCookie erstellt, aktualisiert und gelöscht werden.Another way that WPF applications can store data is with cookies, which are created, updated, and deleted by using the SetCookie and GetCookie methods. Die Cookies, die Sie in WPF erstellen können, sind dieselben Cookies, die von anderen Webanwendungs Typen verwendet werden. Cookies sind beliebige Daten, die von einer Anwendung entweder während oder über Anwendungs Sitzungen hinweg auf einem Client Computer gespeichert werden.The cookies that you can create in WPF are the same cookies that other types of Web applications use; cookies are arbitrary pieces of data that are stored by an application on a client machine either during or across application sessions. Cookiedaten weisen meist das folgende Format eines Name-Wert-Paares auf.Cookie data typically takes the form of a name/value pair in the following format.

Name = WertName = Value

Wenn die Daten zusammen mit dem Uri des Speicher Orts, für den das Cookie festgelegt werden soll, an SetCookieweitergegeben werden, wird ein Cookie im Arbeitsspeicher erstellt und ist nur für die Dauer der aktuellen Anwendungs Sitzung verfügbar.When the data is passed to SetCookie, along with the Uri of the location for which the cookie should be set, a cookie is created in-memory, and it is only available for the duration of the current application session. Diese Art von Cookie wird als Sitzungs Cookiebezeichnet.This type of cookie is referred to as a session cookie.

Wenn Sie ein Cookie über Anwendungssitzungen speichern möchten, muss dem Cookie unter Verwendung des folgenden Formats ein Ablaufdatum hinzugefügt werden.To store a cookie across application sessions, an expiration date must be added to the cookie, using the following format.

Name = Wert ; expires=DAY, DD-MMM-YYYY HH:MM:SS GMTNAME = VALUE ; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

Ein Cookie mit einem Ablaufdatum wird im Ordner "temporäre Internet Dateien" der aktuellen Windows-Installation gespeichert, bis das Cookie abläuft.A cookie with an expiration date is stored in the current Windows installation's Temporary Internet Files folder until the cookie expires. Ein solches Cookie wird als dauerhaftes Cookie bezeichnet, da es über Anwendungs Sitzungen hinweg beibehalten wird.Such a cookie is known as a persistent cookie because it persists across application sessions.

Sie rufen sowohl Sitzungs-als auch persistente Cookies ab, indem Sie die GetCookie-Methode aufrufen und die Uri des Speicher Orts übergeben, an dem das Cookie mit der SetCookie-Methode festgelegt wurdeYou retrieve both session and persistent cookies by calling the GetCookie method, passing the Uri of the location where the cookie was set with the SetCookie method.

Im folgenden finden Sie einige Möglichkeiten, wie Cookies in WPF unterstützt werden:The following are some of the ways that cookies are supported in WPF:

  • Eigenständige WPF-Anwendungen und XBAPs können Cookies erstellen und verwalten.WPF standalone applications and XBAPs can both create and manage cookies.

  • Auf Cookies, die von einer XBAP erstellt werden, kann über den Browser zugegriffen werden.Cookies that are created by an XBAP can be accessed from the browser.

  • XBAPs aus derselben Domäne können Cookies erstellen und freigeben.XBAPs from the same domain can create and share cookies.

  • XBAPs und HTML-Seiten aus derselben Domäne können Cookies erstellen und freigeben.XBAPs and HTML pages from the same domain can create and share cookies.

  • Cookies werden gesendet, wenn XBAPs und lose XAMLXAML Seiten Webanforderungen stellen.Cookies are dispatched when XBAPs and loose XAMLXAML pages make Web requests.

  • Sowohl XBAPs als auch XBAPs, die in iframes gehostet werden, können auf Cookies zugreifen.Both top-level XBAPs and XBAPs hosted in IFRAMES can access cookies.

  • Cookie-Unterstützung in WPF ist für alle unterstützten Browser identisch.Cookie support in WPF is the same for all supported browsers.

  • In Internet Explorer wird die P3P-Richtlinie, die sich auf Cookies bezieht, von WPF berücksichtigt, insbesondere in Bezug auf die erst Anbieter-und Drittanbieter-XBAPs.In Internet Explorer, P3P policy that pertains to cookies is honored by WPF, particularly with respect to first-party and third-party XBAPs.

Strukturierte NavigationStructured Navigation

Wenn Sie Daten von einem Page an einen anderen übergeben müssen, können Sie die Daten als Argumente an einen nicht parameterlosen Konstruktor der Pageübergeben.If you need to pass data from one Page to another, you can pass the data as arguments to a non-parameterless constructor of the Page. Beachten Sie, dass Sie bei Verwendung dieses Verfahrens die Page aktiv halten müssen. Wenn dies nicht der Fall ist, wird das Page von WPF mit dem Parameter losen Konstruktor neu installiert, wenn Sie das nächste Mal zum Pagenavigieren.Note that if you use this technique, you must keep the Page alive; if not, the next time you navigate to the Page, WPF reinstantiates the Page by using the parameterless constructor.

Alternativ können Ihre Page Eigenschaften implementieren, die mit den Daten, die übermittelt werden müssen, festgelegt werden.Alternatively, your Page can implement properties that are set with the data that needs to be passed. Es ist jedoch knifflig, wenn ein Page Daten an die Page zurückgeben muss, die zu ihm navigiert sind.Things become tricky, however, when a Page needs to pass data back to the Page that navigated to it. Das Problem besteht darin, dass die Navigation keine Mechanismen unterstützt, mit denen sichergestellt wird, dass eine Page an zurückgegeben wird, nachdem Sie von der navigiert wurde.The problem is that navigation doesn't natively support mechanisms for guaranteeing that a Page will be returned to after it is navigated from. Im Grunde unterstützt die Navigation keine Semantik mit Aufruf/Rückgabe.Essentially, navigation doesn't support call/return semantics. Um dieses Problem zu beheben, bietet WPF die PageFunction<T>-Klasse, mit der Sie sicherstellen können, dass eine Page auf vorhersagbare und strukturierte Weise zurückgegeben wird.To solve this problem, WPF provides the PageFunction<T> class that you can use to ensure that a Page is returned to in a predictable and structured fashion. Weitere Informationen finden Sie unter Übersicht über die strukturierte Navigation.For more information, see Structured Navigation Overview.

Die NavigationWindow-KlasseThe NavigationWindow Class

Bis jetzt haben Sie das Spektrum der Navigationsdienste kennengelernt, die Sie zum Erstellen von Anwendungen mit navigierbarem Inhalt normalerweise verwenden werden.To this point, you've seen the gamut of navigation services that you are most likely to use to build applications with navigable content. Diese Dienste wurden im Kontext von XBAPs erläutert, auch wenn Sie nicht auf XBAPs beschränkt sind.These services were discussed in the context of XBAPs, although they are not limited to XBAPs. Moderne Betriebssysteme und Windows-Anwendungen nutzen die Browser Darstellung moderner Benutzer, um die Navigation im Browser Stil in eigenständige Anwendungen zu integrieren.Modern operating systems and Windows applications take advantage of the browser experience of modern users to incorporate browser-style navigation into standalone applications. Gängige Beispiele:Common examples include:

  • Word-Thesaurus: Navigieren durch verschiedene Benennungen (Synonyme)Word Thesaurus: Navigate word choices.

  • Datei-Explorer: Navigieren in Dateien und OrdnernFile Explorer: Navigate files and folders.

  • Assistenten: Untergliedern einer komplexen Aufgabe in mehrere Seiten, zwischen denen navigiert werden kann.Wizards: Breaking down a complex task into multiple pages that can be navigated between. Ein Beispiel ist der Assistent für Windows-Komponenten, der das Hinzufügen und Entfernen von Windows-Features behandelt.An example is the Windows Components Wizard that handles adding and removing Windows features.

Um die Navigation im Browser Stil in ihre eigenständigen Anwendungen zu integrieren, können Sie die NavigationWindow-Klasse verwenden.To incorporate browser-style navigation into your standalone applications, you can use the NavigationWindow class. NavigationWindow von Window abgeleitet und mit derselben Unterstützung für die Navigation erweitert, die von XBAPs bereitgestellt wird.NavigationWindow derives from Window and extends it with the same support for navigation that XBAPs provide. Sie können NavigationWindow entweder als Hauptfenster der eigenständigen Anwendung oder als sekundäres Fenster (z. b. ein Dialogfeld) verwenden.You can use NavigationWindow as either the main window of your standalone application or as a secondary window such as a dialog box.

Zum Implementieren einer NavigationWindow, wie bei den meisten Klassen der obersten Ebene in WPF (Window, Pageusw.), verwenden Sie eine Kombination aus Markup und Code Behind.To implement a NavigationWindow, as with most top-level classes in WPF (Window, Page, and so on), you use a combination of markup and code-behind. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

<NavigationWindow
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MainWindow" 
    Source="HomePage.xaml"/>
using System.Windows.Navigation;

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

Namespace SDKSample
    Partial Public Class MainWindow
        Inherits NavigationWindow
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Mit diesem Code wird eine NavigationWindow erstellt, die beim Öffnen des NavigationWindow automatisch zu einer Page (Homepage. XAML) navigiert.This code creates a NavigationWindow that automatically navigates to a Page (HomePage.xaml) when the NavigationWindow is opened. Wenn die NavigationWindow das Hauptanwendungsfenster ist, können Sie das StartupUri-Attribut verwenden, um es zu starten.If the NavigationWindow is the main application window, you can use the StartupUri attribute to launch it. Dies wird im folgenden Markup gezeigt.This is shown in the following markup.

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

In der folgenden Abbildung wird die NavigationWindow als Hauptfenster einer eigenständigen Anwendung gezeigt.The following figure shows the NavigationWindow as the main window of a standalone application.

Ein HauptfensterA main window

In der Abbildung sehen Sie, dass die NavigationWindow über einen Titel verfügt, obwohl Sie nicht im NavigationWindow Implementierungs Code aus dem vorherigen Beispiel festgelegt wurde.From the figure, you can see that the NavigationWindow has a title, even though it wasn't set in the NavigationWindow implementation code from the preceding example. Stattdessen wird der Titel mit der WindowTitle-Eigenschaft festgelegt, die im folgenden Code gezeigt wird.Instead, the title is set using the WindowTitle property, which is shown in the following code.

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

Das Festlegen der Eigenschaften WindowWidth und WindowHeight wirkt sich auch auf die NavigationWindowaus.Setting the WindowWidth and WindowHeight properties also affects the NavigationWindow.

Normalerweise implementieren Sie Ihre eigenen NavigationWindow, wenn Sie entweder das Verhalten oder seine Darstellung anpassen müssen.Usually, you implement your own NavigationWindow when you need to customize either its behavior or its appearance. Wenn keines von beiden angepasst werden muss, können Sie eine Verknüpfung verwenden.If you do neither, you can use a shortcut. Wenn Sie den Paket-URI eines Page als StartupUri in einer eigenständigen Anwendung angeben, erstellt Application automatisch eine NavigationWindow, um die Pagezu hosten.If you specify the pack URI of a Page as the StartupUri in a standalone application, Application automatically creates a NavigationWindow to host the Page. Im folgenden Markup wird gezeigt, wie Sie das aktivieren.The following markup shows how to enable this.

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

Wenn Sie möchten, dass ein sekundäres Anwendungsfenster, z. b. ein Dialogfeld, ein NavigationWindowist, können Sie den Code im folgenden Beispiel verwenden, um ihn zu öffnen.If you want a secondary application window such as a dialog box to be a NavigationWindow, you can use the code in the following example to open it.

// 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();
' Open a navigation window as a dialog box
Dim dlg As New NavigationWindowDialogBox()
dlg.Source = New Uri("HomePage.xaml", UriKind.Relative)
dlg.Owner = Me
dlg.ShowDialog()

Die folgende Abbildung zeigt das Ergebnis.The following figure shows the result.

Ein DialogfeldA dialog box

Wie Sie sehen, zeigt NavigationWindow die Schaltflächen " zurück " und " Vorwärts " im Internet Explorer an, mit denen Benutzer im Journal navigieren können.As you can see, NavigationWindow displays Internet Explorer-style Back and Forward buttons that allow users to navigate the journal. Wie in der folgenden Abbildung veranschaulicht, bieten diese Schaltflächen dieselbe Benutzererfahrung.These buttons provide the same user experience, as shown in the following figure.

Zurück-und vorwärts-Schaltflächen in einem NavigationWindowBack and Forward buttons in a NavigationWindow

Wenn Ihre Seiten ihre eigene Unterstützung für Journal Navigation und Benutzeroberfläche bereitstellen, können Sie die zurück -und Vorwärts -Schaltflächen ausblenden, die durch NavigationWindow angezeigt werden, indem Sie den Wert der Eigenschaft ShowsNavigationUI auf falsefestlegen.If your pages provide their own journal navigation support and UI, you can hide the Back and Forward buttons displayed by NavigationWindow by setting the value of the ShowsNavigationUI property to false.

Alternativ können Sie die Anpassungs Unterstützung in WPF verwenden, um die UIUI der NavigationWindow selbst zu ersetzen.Alternatively, you can use customization support in WPF to replace the UIUI of the NavigationWindow itself.

Die Frame-KlasseThe Frame Class

Sowohl Browser als auch NavigationWindow sind Fenster, die navigierbaren Inhalt hosten.Both the browser and NavigationWindow are windows that host navigable content. In einigen Fällen verfügen Anwendungen über Inhalt, der nicht von einem ganzen Fenster gehostet werden muss.In some cases, applications have content that does not need to be hosted by an entire window. Stattdessen kann solcher Inhalt in anderem Inhalt gehostet werden.Instead, such content be hosted inside other content. Sie können navigierbaren Inhalt in andere Inhalte einfügen, indem Sie die Frame-Klasse verwenden.You can insert navigable content into other content by using the Frame class. Frame bietet dieselbe Unterstützung wie NavigationWindow und XBAPs.Frame provides the same support as NavigationWindow and XBAPs.

Im folgenden Beispiel wird gezeigt, wie einer Page deklarativ mit dem Frame-Element ein Frame hinzugefügt wird.The following example shows how to add a Frame to a Page declaratively by using the Frame element.

<Page 
  xmlns="http://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 die Page festgelegt, zu der der Frame anfänglich navigieren soll.This markup sets the Source attribute of the Frame element with a pack URI for the Page that the Frame should initially navigate to. Die folgende Abbildung zeigt eine XBAP mit einer Page, die über eine Frame verfügt, die zwischen mehreren Seiten navigiert ist.The following figure shows an XBAP with a Page that has a Frame that has navigated between several pages.

Ein Frame, der zwischen mehreren Seiten navigiert ist.A frame that has navigated between multiple pages

Sie müssen nicht nur im Inhalt einer PageFrame verwenden.You don't only have to use Frame inside the content of a Page. Es ist auch üblich, eine Frame innerhalb des Inhalts einer Windowzu hosten.It is also common to host a Frame inside the content of a Window.

Standardmäßig verwendet Frame nur ein eigenes Journal, wenn kein anderes Journal vorhanden ist.By default, Frame only uses its own journal in the absence of another journal. Wenn eine Frame Teil des Inhalts ist, der in einem NavigationWindow oder einer XBAP gehostet wird, verwendet Frame das Journal, das zum NavigationWindow oder XBAP gehört.If a Frame is part of content that is hosted inside either a NavigationWindow or an XBAP, Frame uses the journal that belongs to the NavigationWindow or XBAP. Manchmal ist es jedoch möglich, dass ein Frame für sein eigenes Journal verantwortlich ist.Sometimes, though, a Frame might need to be responsible for its own journal. Ein Grund hierfür ist das Zulassen der Journal Navigation innerhalb der Seiten, die von einem Framegehostet werden.One reason to do so is to allow journal navigation within the pages that are hosted by a Frame. Dies wird in der folgenden Abbildung verdeutlicht.This is illustrated by the following figure.

Frame-und Seiten DiagrammFrame and Page diagram

In diesem Fall können Sie die Frame so konfigurieren, dass Sie ein eigenes Journal verwendet, indem Sie die JournalOwnership-Eigenschaft des Frame auf OwnsJournalfestlegen.In this case, you can configure the Frame to use its own journal by setting the JournalOwnership property of the Frame to OwnsJournal. Dies wird im folgenden Markup gezeigt.This is shown in the following markup.

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

Die folgende Abbildung veranschaulicht die Auswirkung der Navigation in einer Frame, die ein eigenes Journal verwendet.The following figure illustrates the effect of navigating within a Frame that uses its own journal.

Ein Frame, der sein eigenes Journal verwendetA frame that uses its own journal

Beachten Sie, dass die Journal Einträge von der Navigations UIUI in der Frameanstelle von Internet Explorer angezeigt werden.Notice that the journal entries are shown by the navigation UIUI in the Frame, rather than by Internet Explorer.

Hinweis

Wenn eine Frame Teil von Inhalten ist, die in einem Windowgehostet wird, verwendet Frame ein eigenes Journal und zeigt folglich eine eigene Navigations UIUIan.If a Frame is part of content that is hosted in a Window, Frame uses its own journal and, consequently, displays its own navigation UIUI.

Wenn die Benutzerumgebung eine Frame zum Bereitstellen eines eigenen Journal erfordert, ohne die Navigations UIUIanzuzeigen, können Sie die Navigations UIUI ausblenden, indem Sie die NavigationUIVisibility auf Hiddenfestlegen.If your user experience requires a Frame to provide its own journal without showing the navigation UIUI, you can hide the navigation UIUI by setting the NavigationUIVisibility to Hidden. Dies wird im folgenden Markup gezeigt.This is shown in the following markup.

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

Frame und NavigationWindow sind Klassen, die als Navigations Hosts bezeichnet werden.Frame and NavigationWindow are classes that are known as navigation hosts. Ein Navigations Host ist eine Klasse, die zum Inhalt navigieren und Inhalte anzeigen kann.A navigation host is a class that can navigate to and display content. Um dies zu erreichen, verwendet jeder Navigations Host seine eigenen NavigationService und Ihr Journal.To accomplish this, each navigation host uses its own NavigationService and journal. Die grundlegende Konstruktion eines Navigationshosts wird in der folgenden Abbildung gezeigt.The basic construction of a navigation host is shown in the following figure.

NavigationdiagrammeNavigator diagrams

Dadurch können NavigationWindow und Frame die gleiche Navigationsunterstützung bereitstellen, die eine XBAP bietet, wenn Sie im Browser gehostet wird.Essentially, this allows NavigationWindow and Frame to provide the same navigation support that an XBAP provides when hosted in the browser.

Neben der Verwendung von NavigationService und einem Journal implementieren Navigations Hosts dieselben Member, die von NavigationService implementiert werden.Besides using NavigationService and a journal, navigation hosts implement the same members that NavigationService implements. Dies wird in der folgenden Abbildung verdeutlicht.This is illustrated by the following figure.

Ein Journal in einem Frame und in einem NavigationWindowA journal in a Frame and in a NavigationWindow

Dies ermöglicht es Ihnen, Navigationsunterstützung direkt für sie zu programmieren.This allows you to program navigation support directly against them. Dies kann in Erwägung gezogen werden, wenn Sie eine benutzerdefinierte Navigations UIUI für eine Frame bereitstellen müssen, die in einem Windowgehostet wird.You may consider this if you need to provide a custom navigation UIUI for a Frame that is hosted in a Window. Außerdem implementieren beide Typen zusätzliche Navigations bezogene Member, einschließlich BackStack (NavigationWindow.BackStack, Frame.BackStack) und ForwardStack (NavigationWindow.ForwardStackFrame.ForwardStack), mit denen Sie die Journal Einträge im BackStack bzw. vorwärts Stapel aufzählen können.Furthermore, both types implement additional, navigation-related members, including BackStack (NavigationWindow.BackStack, Frame.BackStack) and ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), which allow you to enumerate the journal entries in the back stack and forward stack, respectively.

Wie bereits erwähnt, können in einer Anwendung mehrere Journale vorhanden sein.As mentioned earlier, more than one journal can exist within an application. Die folgende Abbildung enthält ein Beispiel für die Fälle, in denen das auftreten kann.The following figure provides an example of when this can happen.

Mehrere Journale in einer AnwendungMultiple journals within one application

In diesem Thema werden die verschiedenen Navigationsfunktionen von WPF mithilfe von Page-und Paket-XBAPs veranschaulicht.Throughout this topic, Page and pack XBAPs have been used to demonstrate the various navigation capabilities of WPF. Eine in eine Anwendung kompilierte Page ist jedoch nicht die einzige Art von Inhalt, zu der navigiert werden kann, und Pack XBAPs sind nicht die einzige Möglichkeit, Inhalte zu identifizieren.However, a Page that is compiled into an application is not the only type of content that can be navigated to, and pack XBAPs aren't the only way to identify content.

Wie in diesem Abschnitt gezeigt, können Sie auch zu lose XAMLXAML Dateien, HTML-Dateien und Objekten navigieren.As this section demonstrates, you can also navigate to loose XAMLXAML files, HTML files, and objects.

Eine lose XAMLXAML Datei ist eine Datei mit den folgenden Merkmalen:A loose XAMLXAML file is a file with the following characteristics:

  • Enthält nur XAMLXAML (d. h. keinen Code).Contains only XAMLXAML (that is, no code).

  • Verfügt über eine entsprechende Namespacedeklaration.Has an appropriate namespace declaration.

  • Hat die Dateierweiterung .xaml.Has the .xaml file name extension.

Sehen Sie sich beispielsweise den folgenden Inhalt an, der als lose XAMLXAML Datei "Person. XAML" gespeichert wird.For example, consider the following content that is stored as a loose XAMLXAML file, Person.xaml.

<!-- Person.xaml -->
<TextBlock xmlns="http://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.When you double-click the file, the browser opens and navigates to and displays the content. Das wird in der folgenden Abbildung gezeigt.This is shown in the following figure.

![Anzeige des Inhalts in der Person. XAML-Datei](./media/navigation-overview/contents-of-person-xaml-file.png "Zeigt den Inhalt der Datei "Person. XAML" an.")Display of the content in the Person.XAML file

Sie können eine lose XAMLXAML Datei aus folgendem anzeigen:You can display a loose XAMLXAML file from the following:

  • Einer Website auf dem lokalen Computer, dem Intranet oder dem InternetA Web site on the local machine, the intranet, or the Internet.

  • Eine Universal Naming Convention Dateifreigabe (UNC).A Universal Naming Convention (UNC) file share.

  • Dem lokalen DatenträgerThe local disk.

Eine lose XAMLXAML Datei kann den Favoriten des Browsers hinzugefügt werden, oder Sie ist die Startseite des Browsers.A loose XAMLXAML file can be added to the browser's favorites, or be the browser's home page.

Hinweis

Weitere Informationen zum Veröffentlichen und starten von losen XAMLXAML Seiten finden Sie unter Bereitstellen einer WPF-Anwendung.For more information about publishing and launching loose XAMLXAML pages, see Deploying a WPF Application.

Eine Einschränkung in Bezug auf die lose XAMLXAML besteht darin, dass Sie nur Inhalte hosten können, die sicher mit teilweiser Vertrauenswürdigkeit ausgeführt werden können.One limitation with respect to loose XAMLXAML is that you can only host content that is safe to run in partial trust. Beispielsweise kann Window nicht das Stamm Element einer losen XAMLXAML Datei sein.For example, Window cannot be the root element of a loose XAMLXAML file. Weitere Informationen finden Sie unter WPF-Sicherheit mit teilweiser Vertrauenswürdigkeit.For more information, see WPF Partial Trust Security.

Wie Sie vielleicht erwarten, können Sie auch zu HTML navigieren.As you might expect, you can also navigate to HTML. Sie müssen lediglich einen URI angeben, der das http-Schema verwendet.You simply need to provide a URI that uses the http scheme. Im folgenden XAMLXAML wird z. b. ein Frame angezeigt, der zu einer HTML-Seite navigiert.For example, the following XAMLXAML shows a Frame that navigates to an HTML page.

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

Zum Navigieren zu HTML sind spezielle Berechtigungen erforderlich.Navigating to HTML requires special permissions. Beispielsweise können Sie nicht von einer XBAP aus navigieren, die in der Sicherheits Sandbox für die teilweise vertrauenswürdige Zone der Internet Zone ausgeführt wird.For example, you can't navigate from an XBAP that is running in the Internet zone partial trust security sandbox. Weitere Informationen finden Sie unter WPF-Sicherheit mit teilweiser Vertrauenswürdigkeit.For more information, see WPF Partial Trust Security.

Das WebBrowser-Steuerelement unterstützt die Interoperabilität von HTML-Dokumenten, Navigation und Skript/verwaltetem Code.The WebBrowser control supports HTML document hosting, navigation and script/managed code interoperability. Ausführliche Informationen zum WebBrowser Steuerelement finden Sie unter WebBrowser.For detailed information regarding the WebBrowser control, see WebBrowser.

Wie Frameerfordert die Navigation zu HTML mithilfe WebBrowser besondere Berechtigungen.Like Frame, navigating to HTML using WebBrowser requires special permissions. Beispielsweise können Sie in einer teilweise vertrauenswürdigen Anwendung nur zu HTML navigieren, das sich auf der Ursprungs Site befindet.For example, from a partial-trust application, you can navigate only to HTML located at the site of origin. Weitere Informationen finden Sie unter WPF-Sicherheit mit teilweiser Vertrauenswürdigkeit.For more information, see WPF Partial Trust Security.

Wenn Sie über Daten verfügen, die als benutzerdefinierte Objekte gespeichert sind, besteht eine Möglichkeit zum Anzeigen dieser Daten darin, eine Page mit Inhalt zu erstellen, der an diese Objekte gebunden ist (siehe Übersicht über die Datenbindung).If you have data that is stored as custom objects, one way to display that data is to create a Page with content that is bound to those objects (see Data Binding Overview). Wenn Sie eine ganze Seite nicht nur zu dem Zweck erstellen möchten, die Objekte anzuzeigen, können Sie stattdessen direkt zu ihnen navigieren.If you don't need the overhead of creating an entire page just to display the objects, you can navigate directly to them instead.

Beachten Sie die Person-Klasse, die im folgenden Code implementiert ist.Consider the Person class that is implemented in the following code.

using System.Windows.Media;

namespace SDKSample
{
    public class Person
    {
        string name;
        Color favoriteColor;

        public Person() { }
        public Person(string name, Color favoriteColor)
        {
            this.name = name;
            this.favoriteColor = favoriteColor;
        }

        public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }

        public Color FavoriteColor
        {
            get { return this.favoriteColor; }
            set { this.favoriteColor = value; }
        }
    }
}

Namespace SDKSample
    Public Class Person
        Private _name As String
        Private _favoriteColor As Color

        Public Sub New()
        End Sub
        Public Sub New(ByVal name As String, ByVal favoriteColor As Color)
            Me._name = name
            Me._favoriteColor = favoriteColor
        End Sub

        Public Property Name() As String
            Get
                Return Me._name
            End Get
            Set(ByVal value As String)
                Me._name = value
            End Set
        End Property

        Public Property FavoriteColor() As Color
            Get
                Return Me._favoriteColor
            End Get
            Set(ByVal value As Color)
                Me._favoriteColor = value
            End Set
        End Property
    End Class
End Namespace

Um dorthin zu navigieren, rufen Sie die NavigationWindow.Navigate-Methode auf, wie im folgenden Code veranschaulicht.To navigate to it, you call the NavigationWindow.Navigate method, as demonstrated by the following code.

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.HomePage"
  WindowTitle="Page that Navigates to an Object">
<Hyperlink Name="hyperlink" Click="hyperlink_Click">
  Navigate to Nancy Davolio
</Hyperlink>
</Page>
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace SDKSample
{
    public partial class HomePage : Page
    {
        public HomePage()
        {
            InitializeComponent();
        }

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            Person person = new Person("Nancy Davolio", Colors.Yellow);
            this.NavigationService.Navigate(person);
        }
    }
}

Namespace SDKSample
    Partial Public Class HomePage
        Inherits Page
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub hyperlink_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            Dim person As New Person("Nancy Davolio", Colors.Yellow)
            Me.NavigationService.Navigate(person)
        End Sub
    End Class
End Namespace

Die folgende Abbildung zeigt das Ergebnis.The following figure shows the result.

Eine Seite, die zu einer Klasse navigiert.A page that navigates to a class

Aus dieser Abbildung können Sie ersehen, dass nichts Nützliches angezeigt wird.From this figure, you can see that nothing useful is displayed. Tatsächlich ist der angezeigte Wert der Rückgabewert der ToString-Methode für das Person -Objekt. Standardmäßig ist dies der einzige Wert, den WPF zum Darstellen des Objekts verwenden kann.In fact, the value that is displayed is the return value of the ToString method for the Person object; by default, this is the only value that WPF can use to represent your object. Sie können die ToString-Methode außer Kraft setzen, um aussagekräftigere Informationen zurückzugeben, obwohl es sich immer noch um einen Zeichen folgen Wert handelt.You could override the ToString method to return more meaningful information, although it will still only be a string value. Eine Methode, die Sie verwenden können, die Präsentations Funktionen von WPF nutzt, ist die Verwendung einer Daten Vorlage.One technique you can use that takes advantage of the presentation capabilities of WPF is to use a data template. Sie können eine Daten Vorlage implementieren, die WPF einem Objekt eines bestimmten Typs zuordnen kann.You can implement a data template that WPF can associate with an object of a particular type. Der folgende Code zeigt eine Daten Vorlage für das Person-Objekt.The following code shows a data template for the Person object.

<Application
    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.App"
    StartupUri="HomePage.xaml">

  <Application.Resources>

    <!-- Data Template for the Person Class -->
    <DataTemplate DataType="{x:Type local:Person}">
      <TextBlock xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
        <TextBlock FontWeight="Bold">Name:</TextBlock>
        <TextBlock Text="{Binding Path=Name}" />
        <LineBreak />
        <TextBlock FontWeight="Bold">Favorite Color:</TextBlock>
        <TextBlock Text="{Binding Path=FavoriteColor}" />
      </TextBlock>
    </DataTemplate>
    
  </Application.Resources>

</Application>

Hier ist die Daten Vorlage dem Person-Typ zugeordnet, indem die x:Type Markup Erweiterung im DataType-Attribut verwendet wird.Here, the data template is associated with the Person type by using the x:Type markup extension in the DataType attribute. Anschließend bindet die Daten Vorlage TextBlock Elemente (siehe TextBlock) an die Eigenschaften der Person-Klasse.The data template then binds TextBlock elements (see TextBlock) to the properties of the Person class. Die folgende Abbildung zeigt die aktualisierte Darstellung des Person Objekts.The following figure shows the updated appearance of the Person object.

Navigieren zu einer Klasse mit einer Daten VorlageNavigating to a class that has a data template

Ein Vorteil dieser Technik liegt in der Konsistenz, die Ihnen die Wiederverwendung der Datenvorlage zur konsistenten Anzeige Ihrer Objekte in der gesamten Anwendung erlaubt.An advantage of this technique is the consistency you gain by being able to reuse the data template to display your objects consistently anywhere in your application.

Weitere Informationen zu Datenvorlagen finden Sie unter Übersicht über DatenVorlagen.For more information on data templates, see Data Templating Overview.

SicherheitSecurity

Die Unterstützung der WPF-Navigation ermöglicht, dass XBAPs über das Internet navigiert werden kann, und ermöglicht Anwendungen, Inhalte von Drittanbietern zu hosten.WPF navigation support allows XBAPs to be navigated to across the Internet, and it allows applications to host third-party content. Um sowohl Anwendungen als auch Benutzer vor schädlichem Verhalten zu schützen, bietet WPF eine Reihe von Sicherheitsfunktionen, die unter Sicherheit und WPF-Sicherheit mit teilweiser VertrauensWürdigkeit erläutert werden.To protect both applications and users from harmful behavior, WPF provides a variety of security features that are discussed in Security and WPF Partial Trust Security.

Siehe auchSee also