Dela via

Navigeringsöversikt

  • Artikel

Windows Presentation Foundation (WPF) stöder navigering i webbläsarformat som kan användas i två typer av program: fristående program och XAML-webbläsarprogram (XBAPs). För att paketera innehåll för navigering tillhandahåller WPF klassen Page. Du kan navigera från en Page till en annan deklarativt med hjälp av en Hyperlink, eller programmatiskt, med hjälp av NavigationService. WPF använder journalen för att komma ihåg sidor som har navigerats från och för att gå tillbaka till dem.

Page, Hyperlink, NavigationServiceoch journalen utgör kärnan i navigeringsstödet som erbjuds av WPF. Den här översikten utforskar dessa funktioner i detalj innan du tar upp avancerat navigeringsstöd som inkluderar navigering till lösa XAML-filer (Extensible Application Markup Language), HTML-filer och objekt.

Not

I det här avsnittet refererar termen "webbläsare" bara till webbläsare som kan vara värdar för WPF-program, som för närvarande innehåller Microsoft Internet Explorer och Firefox. Om specifika WPF-funktioner endast stöds av en viss webbläsare hänvisas webbläsarversionen till.

Det här avsnittet innehåller en översikt över de viktigaste navigeringsfunktionerna i WPF. De här funktionerna är tillgängliga för både fristående program och XBAP:er, även om det här avsnittet presenterar dem inom ramen för en XBAP.

Not

Det här avsnittet beskriver inte hur du skapar och distribuerar XBAP:er. Mer information om XBAPs finns i WPF XAML Browser Applications Overview.

Det här avsnittet förklarar och visar följande aspekter av navigeringen:

Implementera en sida

I WPF kan du navigera till flera innehållstyper som innehåller .NET Framework-objekt, anpassade objekt, uppräkningsvärden, användarkontroller, XAML-filer och HTML-filer. Det vanligaste och enklaste sättet att paketera innehåll är dock att använda Page. Dessutom implementerar Page navigeringsspecifika funktioner för att förbättra deras utseende och förenkla utvecklingen.

Med hjälp av Pagekan du deklarativt implementera en navigeringsbar sida med XAML-innehåll med hjälp av markering som följande.

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

En Page som implementeras i XAML-markering har Page som rotelement och kräver WPF XML-namnområdesdeklarationen. Elementet Page innehåller det innehåll som du vill navigera till och visa. Du lägger till innehåll genom att ange egenskapselementet Page.Content enligt följande markering.

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

Page.Content får bara innehålla ett underordnat element. I föregående exempel är innehållet en enda sträng, "Hello, Page!" I praktiken använder du vanligtvis en layoutkontroll som det underordnade elementet (se Layout) för att innehålla och skriva ditt innehåll.

Underordnade element som hör till ett Page-element anses vara innehållet i ett Page, och därför behöver du inte använda den explicita Page.Content-deklarationen. Följande markering är den deklarativa motsvarigheten till föregående exempel.

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

I det här fallet anges Page.Content automatiskt med de underordnade elementen i Page-elementet. Mer information finns i WPF-innehållsmodell.

En Page med endast markup är användbar för att visa innehåll. Men en Page kan också visa kontroller som gör det möjligt för användare att interagera med sidan, och den kan svara på användarinteraktion genom att hantera händelser och anropa programlogik. En interaktiv Page implementeras med hjälp av en kombination av markup-språket och bakomliggande kod, som visas i följande exempel.

<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

För att en markeringsfil och kod bakom fil ska fungera tillsammans krävs följande konfiguration:

  • I markering måste elementet Page innehålla attributet x:Class. När programmet skapas gör förekomsten av x:Class i markupfilen att Microsoft Build Engine (MSBuild) skapar en partial-klass som härleds från Page och har det namn som specificeras av attributet x:Class. Detta kräver tillägg av en XML-namnområdesdeklaration för XAML-schemat ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Den genererade partial-klassen implementerar InitializeComponent, som anropas för att registrera händelserna och ange de egenskaper som implementeras i markering.

  • I code-behind måste klassen vara en partial-klass med samma namn som anges av attributet x:Class i markering, och den måste härledas från Page. Detta gör att filen bakom koden kan associeras med den partial-klass som genereras för markeringsfilen när programmet skapas (se Skapa ett WPF-program).

  • I code-behind måste klassen Page implementera en konstruktor som anropar metoden InitializeComponent. InitializeComponent implementeras av markeringsfilens genererade partial-klass för att registrera händelser och ange egenskaper som definieras i markering.

Notera

När du lägger till en ny Page i projektet med Visual Studio implementeras Page med både markering och kod bakom, och den innehåller den konfiguration som krävs för att skapa associationen mellan markeringsfilerna och kod bakom filerna enligt beskrivningen här.

När du väl har en Pagekan du navigera till den. Om du vill ange den första Page som ett program navigerar till måste du konfigurera start Page.

Konfigurera en startsida

XBAP:er kräver att en viss mängd programinfrastruktur finns i en webbläsare. I WPF är klassen Application en del av en programdefinition som upprättar den nödvändiga programinfrastrukturen (se Översikt över programhantering).

En programdefinition implementeras vanligtvis med både markup och bakomliggande kod, med markeringsfilen konfigurerad som ett MSBuild-ApplicationDefinition-objekt. Följande är en programdefinition för en 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

En XBAP kan använda sin programdefinition för att ange en start Page, vilket är den Page som läses in automatiskt när XBAP startas. Det gör du genom att ange egenskapen StartupUri med URI (Uniform Resource Identifier) för önskad Page.

Not

I de flesta fall kompileras Page antingen till eller distribueras med ett program. I dessa fall är URI:n som identifierar en Page en pack-URI, vilket är en URI som överensstämmer med schemat pack. Paket-URI:er beskrivs ytterligare i Pack-URI:er i WPF. Du kan också navigera till innehåll med hjälp av http-schemat, som beskrivs nedan.

Du kan ange StartupUri deklarativt i markering, som du ser i följande exempel.

<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" />

I det här exemplet anges attributet StartupUri med en relativ pack-URI som identifierar HomePage.xaml. När XBAP startas navigeras HomePage.xaml automatiskt till och visas. Detta visas med följande bild, som visar en XBAP som startades från en webbserver.

XBAP-sida

Not

Mer information om utveckling och distribution av XBAPs finns i WPF XAML Browser Applications Overview and Deploying a WPF Application.

Konfigurera värdfönstrets rubrik, bredd och höjd

En sak som du kanske har märkt från föregående bild är att rubriken för både webbläsaren och flikpanelen är URI:n för XBAP. Förutom att vara lång är titeln varken attraktiv eller informativ. Därför erbjuder Page ett sätt för dig att ändra rubriken genom att ange egenskapen WindowTitle. Dessutom kan du konfigurera bredd och höjd för webbläsarfönstret genom att ange WindowWidth respektive WindowHeight.

WindowTitle, WindowWidthoch WindowHeight kan anges deklarativt i markering, enligt följande exempel.

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

Resultatet visas i följande bild.

Fönsterrubrik, höjd, bredd

En typisk XBAP består av flera sidor. Det enklaste sättet att navigera från en sida till en annan är att använda en Hyperlink. Du kan deklarativt lägga till en Hyperlink till en Page med hjälp av elementet Hyperlink, som visas i följande markering.

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

Ett Hyperlink-element kräver följande:

  • Pack-URI:n för Page att navigera till, som anges av attributet NavigateUri.

  • Innehåll som en användare kan klicka på för att initiera navigeringen, till exempel text och bilder (för det innehåll som Hyperlink-elementet kan innehålla, se Hyperlink).

Följande bild visar en XBAP med en Page som har en Hyperlink.

sida med hyperlänk

Om du klickar på Hyperlink kan XBAP navigera till Page som identifieras av attributet NavigateUri. Dessutom lägger XBAP till en post för föregående Page till listan Senaste sidor i Internet Explorer. Detta visas i följande bild.

bakåt- och framåtknappar

Förutom stöd för navigering från en Page till en annan stöder Hyperlink även fragmentnavigering.

Fragmentnavigering

Fragmentnavigering är navigeringen till ett innehållsfragment i antingen den aktuella Page eller någon annan Page. I WPF är ett innehållsfragment det innehåll som finns i ett namngivet element. Ett namngivet element är ett element som har sin Name attributuppsättning. Följande markering visar ett namngivet TextBlock-element som innehåller ett innehållsfragment.

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

För att en Hyperlink ska kunna navigera till ett innehållsfragment måste attributet NavigateUri innehålla följande:

  • URI:n till Page med innehållsfragmentet som ska navigeras till.

  • Ett "#"-tecken.

  • Namnet på elementet på Page som innehåller innehållsfragmentet.

En fragment-URI har följande format.

PageURI#ElementName

Följande visar ett exempel på en Hyperlink som är konfigurerad för att navigera till ett innehållsfragment.

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

Not

I det här avsnittet beskrivs standardimplementering av fragmentnavigering i WPF. MED WPF kan du också implementera ett eget fragmentnavigeringsschema som delvis kräver hantering av NavigationService.FragmentNavigation händelsen.

Viktig

Du kan navigera till fragment i lösa XAML-sidor (endast XAML-filer med Page som rotelement) endast om sidorna kan bläddras via HTTP.

En lös XAML-sida kan dock navigera till sina egna fragment.

Även om Hyperlink tillåter att en användare initierar navigering till en viss Pageutförs arbetet med att hitta och ladda ned sidan av klassen NavigationService. I grund och botten ger NavigationService möjlighet att bearbeta en navigeringsbegäran för klientkodens räkning, till exempel Hyperlink. Dessutom implementerar NavigationService stöd på högre nivå för att spåra och påverka en navigeringsbegäran.

När en Hyperlink klickas anropar WPF NavigationService.Navigate för att hitta och ladda ned Page på den angivna paket-URI:n. Den nedladdade Page konverteras till ett träd med objekt vars rotobjekt är en instans av den nedladdade Page. En referens till rotobjektet Page lagras i egenskapen NavigationService.Content. Paket-URI:n för innehållet som navigerades till lagras i egenskapen NavigationService.Source, medan NavigationService.CurrentSource lagrar paket-URI:n för den sista sidan som navigerades till.

Notera

Det är möjligt att ett WPF-program har fler än en aktiv NavigationService. Mer information finns i navigeringsvärdar senare i det här avsnittet.

Programmeringsnavigering med navigeringstjänsten

Du behöver inte känna till NavigationService om navigeringen implementeras deklarativt i markering med Hyperlinkeftersom Hyperlink använder NavigationService åt dig. Det innebär att Hyperlink kan hitta och använda navigeringsvärdens navigeringstjänst, så länge någon av de direkta eller indirekta överordnade till en Hyperlink är en navigeringsvärd (se Navigeringsvärdar).

Det finns dock situationer när du behöver använda NavigationService direkt, inklusive följande:

  • När du behöver instansiera en Page med en icke-parameterlös konstruktor.

  • När du behöver ange egenskaper för Page innan du navigerar till den.

  • När Page som behöver navigeras till kan endast fastställas vid körning.

I dessa situationer måste du skriva kod för att programmatiskt initiera navigeringen genom att anropa Navigate-metoden för NavigationService-objektet. Det kräver att du hämtar en referens till en NavigationService.

Hämta en referens till NavigationService

Av skäl som beskrivs i avsnittet Navigeringsvärdar kan ett WPF-program ha mer än en NavigationService. Det innebär att din kod behöver en metod för att hitta en NavigationService, som vanligtvis är den NavigationService som navigerade till den nuvarande Page. Du kan hämta en referens till en NavigationService genom att anropa metoden staticNavigationService.GetNavigationService. Om du vill hämta NavigationService som navigerade till en viss Pageskickar du en referens till Page som argument för metoden GetNavigationService. Följande kod visar hur man hämtar NavigationService för den aktuella 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)

Som en genväg för att hitta NavigationService för en Pageimplementerar Page egenskapen NavigationService. Detta visas i följande exempel.

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

Not

En Page kan bara få en referens till sin NavigationService när Page genererar händelsen Loaded.

Programmeringsnavigering till ett sidobjekt

I följande exempel visas hur du använder NavigationService för att programmatiskt navigera till en Page. Programmeringsnavigering krävs eftersom den Page som navigeras till bara kan instansieras med hjälp av en enda konstruktor som inte är parameterlös. Den Page med den icke-parameterlösa konstruktorn visas i följande markering och kod.

<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

Den Page som navigerar till Page med den icke-parameterlösa konstruktorn visas i följande kod.

<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

När Hyperlink på den här Page klickas initieras navigeringen genom att instansiera Page för att navigera till med den icke-parameterlösa konstruktorn och anropa metoden NavigationService.Navigate. Navigate accepterar en referens till det objekt som NavigationService navigerar till i stället för en paket-URI.

Programmatisk navigering med en pack-URI

Om du behöver konstruera en paket-URI programmatiskt (när du bara kan fastställa paket-URI vid körning) kan du använda metoden NavigationService.Navigate. Detta visas i följande exempel.

<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

Uppdaterar den aktuella sidan

En Page laddas inte ned om den har samma pack-URI som pack-URI:n som lagras i egenskapen NavigationService.Source. Om du vill tvinga WPF att ladda ned den aktuella sidan igen kan du anropa metoden NavigationService.Refresh, som du ser i följande exempel.

<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

Det finns många sätt att initiera navigering, som du har sett. När navigeringen initieras och navigering pågår kan du spåra och påverka navigeringen med hjälp av följande händelser som implementeras av NavigationService:

  • Navigating. Inträffar när en ny navigering begärs. Kan användas för att avbryta navigeringen.

  • NavigationProgress. Inträffar regelbundet under en nedladdning för att tillhandahålla information om navigeringsförloppet.

  • Navigated. Inträffar när sidan har hittats och laddats ned.

  • NavigationStopped. Inträffar när navigeringen stoppas (genom att anropa StopLoading), eller när en ny navigering begärs medan en aktuell navigering pågår.

  • NavigationFailed. Inträffar när ett fel uppstår när du navigerar till det begärda innehållet.

  • LoadCompleted. Inträffar när innehåll som har navigerats till läses in, parsas och har börjat återges.

  • FragmentNavigation. Inträffar när navigeringen till ett innehållsfragment börjar, vilket händer:

    • Omedelbart om det önskade fragmentet finns i det aktuella innehållet.

    • När källinnehållet har lästs in, om det önskade fragmentet finns i annat innehåll.

Navigeringshändelserna genereras i den ordning som illustreras av följande bild.

Sidnavigeringsflödesdiagram

I allmänhet bryr sig inte en Page om dessa händelser. Det är mer troligt att ett program berörs av dem, och av den anledningen genereras även dessa händelser av klassen Application:

Varje gång NavigationService genererar en händelse genererar klassen Application motsvarande händelse. Frame och NavigationWindow erbjuder samma händelser för att identifiera navigering inom respektive omfång.

I vissa fall kan en Page vara intresserad av dessa händelser. En Page kan till exempel hantera händelsen NavigationService.Navigating för att avgöra om navigeringen ska avbrytas från sig själv eller inte. Detta visas i följande exempel.

<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

Om du registrerar en hanterare med en navigeringshändelse från en Page, som i föregående exempel, måste du också avregistrera händelsehanteraren. Om du inte gör det kan det finnas konsekvenser angående hur WPF-navigeringen kommer ihåg Page-navigeringen med hjälp av journalen.

Komma ihåg navigering med journalen

WPF använder två staplar för att komma ihåg de sidor som du har navigerat från: en bakåtstack och en framåtstack. När du navigerar från den aktuella Page till en ny Page eller vidare till en befintlig Pageläggs den aktuella Page till i back stack. När du navigerar från den aktuella Page tillbaka till föregående Pageläggs den aktuella Page till i framåtstacken. Både tillbaka-stacken, framåt-stacken och funktionaliteten för att hantera dem kallas tillsammans journalen. Varje objekt i den bakre stacken och den vidarebefordrade stacken är en instans av klassen JournalEntry och kallas för en journalpost.

Konceptuellt fungerar journalen på samma sätt som knapparna Back och Forward i Internet Explorer. Dessa visas i följande bild.

bakåt- och framåtknappar

För XBAP:er som hanteras av Internet Explorer integrerar WPF journalen i navigeringsgränssnittet i Internet Explorer. På så sätt kan användarna navigera på sidor i en XBAP med knapparna Back, Forwardoch Recent Pages i Internet Explorer.

Viktig

När en användare navigerar bort från och sedan återvänder till en XBAP i Internet Explorer, behålls endast journalposterna för sidor som inte hölls aktiva i journalen. En diskussion om hur du håller sidorna vid liv finns i Page Lifetime och Journal senare i det här avsnittet.

Som standard är texten för varje Page som visas i listan Senaste sidor i Internet Explorer URI:n för Page. I många fall är detta inte särskilt meningsfullt för användaren. Som tur är kan du ändra texten med något av följande alternativ:

  1. Det kopplade attributvärdet JournalEntry.Name.

  2. Värdet av attributet Page.Title.

  3. Attributvärdet för Page.WindowTitle och URI:n för den aktuella Page.

  4. URI:n för den aktuella Page. (Standard)

Ordningen i vilken alternativen visas matchar prioritetsordningen för att hitta texten. Om JournalEntry.Name till exempel anges ignoreras de andra värdena.

I följande exempel används attributet Page.Title för att ändra texten som visas för en journalpost.

<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

Även om en användare kan navigera i journalen med hjälp av Back, Forwardoch Senaste sidor i Internet Explorer, kan du också navigera i journalen med hjälp av både deklarativa och programmatiska mekanismer som tillhandahålls av WPF. En anledning att göra detta är att tillhandahålla anpassade navigerings-UIs på dina sidor.

Du kan deklarativt lägga till stöd för journalnavigering med hjälp av navigeringskommandona som exponeras av NavigationCommands. I följande exempel visas hur du använder navigeringskommandot BrowseBack.

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

Du kan navigera i journalen programmatiskt med någon av följande medlemmar i klassen NavigationService:

Journalen kan också manipuleras programmatiskt, enligt beskrivningen i Behåll innehållstillstånd med navigeringshistorik senare i det här avsnittet.

Sidans livslängd och journalen

Överväg en XBAP med flera sidor som innehåller omfattande innehåll, inklusive grafik, animeringar och media. Minnesfotavtrycket för sidor som dessa kan vara ganska stort, särskilt om video- och ljudmedier används. Med tanke på att journalen "kommer ihåg" sidor som har navigerats till kan en sådan XBAP snabbt förbruka en stor och märkbar mängd minne.

Därför är standardbeteendet för journalen att lagra Page metadata i varje journalpost i stället för en referens till ett Page objekt. När en journalpost navigeras till används dess Page metadata för att skapa en ny instans av den angivna Page. Därför har varje Page som navigeras den livslängd som illustreras av följande bild.

Sidlivslängd

Även om användningen av standardbeteendet för journalföring kan spara på minnesförbrukningen, kan prestandan för per-side-återgivning minskas; Att återskapa en Page kan vara tidskrävande, särskilt om den har mycket innehåll. Om du behöver behålla en Page instans i journalen kan du använda två metoder för att göra det. Först kan du programmatiskt navigera till ett Page objekt genom att anropa metoden NavigationService.Navigate.

För det andra kan du ange att WPF ska behålla en instans av en Page i journalen genom att ange egenskapen KeepAlive till true (standardvärdet är false). Som du ser i följande exempel kan du ange KeepAlive deklarativt i markering.

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

Livslängden för en Page som hålls vid liv skiljer sig subtilt från en som inte är det. Första gången en Page som hålls vid liv navigeras till instansieras den precis som en Page som inte hålls vid liv. Men eftersom en instans av Page behålls i journalen, instansieras den aldrig på nytt så länge den förblir i journalen. Om en Page har initieringslogik som måste anropas varje gång Page navigeras till bör du flytta den från konstruktorn till en hanterare för händelsen Loaded. Som du ser i följande bild aktiveras fortfarande Loaded- och Unloaded-händelserna när en Page navigeras till och från.

När inlästa och oladdade händelser aktiveras

När en Page inte hålls vid liv bör du inte göra något av följande:

  • Lagra en referens till den eller någon del av den.

  • Registrera händelsehanterare med händelser som inte implementeras av den.

Om du gör något av detta skapas referenser som tvingar Page att behållas i minnet, även efter att det tagits bort från journalen.

I allmänhet bör du föredra standardbeteendet Page att inte hålla en Page vid liv. Detta har dock tillståndskonsekvenser som beskrivs i nästa avsnitt.

Behålla innehållstillstånd med navigeringshistorik

Om en Page inte hålls vid liv och den har kontroller som samlar in data från användaren, vad händer med data om en användare navigerar bort från och tillbaka till Page? Från ett användarupplevelseperspektiv bör användaren förvänta sig att se de data som de angav tidigare. Tyvärr, eftersom en ny instans av Page skapas vid varje navigering, blir kontrollerna som samlade in data återuppbyggda och data går förlorad.

Som tur är ger journalen stöd för att komma ihåg data över flera Page-navigeringar, inklusive kontrolldata. Mer specifikt fungerar journalposten för varje Page som en tillfällig behållare för den associerade Page-statusen. Följande steg beskriver hur det här stödet används när en Page navigeras från:

  1. En post för den aktuella Page läggs till i journalen.

  2. Tillståndet för Page lagras med journalposten för den sidan, som läggs till i den bakre stacken.

  3. Till den nya Page navigerar man.

När sidan Page navigeras tillbaka till sker följande steg med hjälp av journalen:

  1. Page (den översta journalposten i den bakre stacken) instansieras.

  2. Page uppdateras med tillståndet som har lagrats med journalposten för Page.

  3. Man navigerar tillbaka till Page.

WPF använder automatiskt det här stödet när följande kontroller används på en Page:

Om en Page använder dessa kontroller kommer data som anges i dem att sparas i Page navigering, vilket visas av favoritfärgListBox i följande bild.

sida med kontroller som kommer ihåg tillstånd

När en Page har andra kontroller än de i föregående lista, eller när tillståndet lagras i anpassade objekt, måste du skriva kod för att journalen ska komma ihåg tillståndet i Page navigering.

Om du behöver komma ihåg små delar av tillståndet under Page navigeringar kan du använda beroendeegenskaper (se DependencyProperty) som har konfigurerats med FrameworkPropertyMetadata.Journal metadataflaggan.

Om det tillstånd som din Page behöver komma ihåg i navigeringen består av flera datadelar kan det vara mindre kodintensivt att kapsla in ditt tillstånd i en enda klass och implementera IProvideCustomContentState-gränssnittet.

Om du behöver navigera genom olika tillstånd i en enda Page, utan att navigera från själva Page, kan du använda IProvideCustomContentState och NavigationService.AddBackEntry.

Cookies

Ett annat sätt att WPF-program kan lagra data är med cookies som skapas, uppdateras och tas bort med hjälp av metoderna SetCookie och GetCookie. De cookies som du kan skapa i WPF är samma cookies som andra typer av webbprogram använder. cookies är godtyckliga data som lagras av ett program på en klientdator under eller mellan programsessioner. Cookiedata har vanligtvis formen av ett namn/värde-par i följande format.

namn=värde

När data skickas till SetCookie, tillsammans med Uri för den plats där cookien ska anges, skapas en cookie i minnet och den är endast tillgänglig under den aktuella programsessionen. Den här typen av cookie kallas för en sessionscookie.

Om du vill lagra en cookie mellan programsessioner måste ett förfallodatum läggas till i cookien med hjälp av följande format.

NAMN=VÄRDE; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

En cookie med ett förfallodatum lagras i den aktuella Windows-installationens temporära Internet Files-mapp tills cookien upphör att gälla. En sådan cookie kallas för en beständig cookie eftersom den bevaras mellan programsessioner.

Du hämtar både sessions- och beständiga cookies genom att anropa metoden GetCookie och skicka Uri för platsen där cookien angavs med metoden SetCookie.

Följande är några av de sätt som cookies stöds på i WPF:

  • WPF-fristående program och XBAP:er kan både skapa och hantera cookies.

  • Cookies som skapas av en XBAP kan nås från webbläsaren.

  • XBAPs från samma domän kan skapa och dela cookies.

  • XBAP:er och HTML-sidor från samma domän kan skapa och dela cookies.

  • Cookies skickas när XBAP:er och lösa XAML-sidor gör webbförfrågningar.

  • Både XBAP:er på toppnivå och XBAP:er som finns i IFRAMES kan komma åt cookies.

  • Cookiestöd i WPF är detsamma för alla webbläsare som stöds.

  • I Internet Explorer respekteras P3P-policyn som gäller cookies av WPF, särskilt när det gäller förstaparts- och tredjeparts-XBAP:er.

Strukturerad navigering

Om du behöver skicka data från en Page till en annan kan du skicka data som argument till en icke-parameterlös konstruktor för Page. Observera att om du använder den här tekniken måste du hålla Page vid liv. om inte, kommer WPF nästa gång du navigerar till Pageatt återstantera Page med hjälp av den parameterlösa konstruktorn.

Alternativt kan din Page implementera egenskaper som anges med de data som måste skickas. Det blir dock svårt när en Page behöver skicka data tillbaka till Page som navigerade till den. Problemet är att navigeringen inte har inbyggt stöd för mekanismer för att garantera att en Page returneras till när den har navigerats från. I princip stöder navigering inte samtals-/retursemantik. För att lösa det här problemet tillhandahåller WPF den PageFunction<T>-klass som du kan använda för att säkerställa att en Page returneras till på ett förutsägbart och strukturerat sätt. Mer information finns i Strukturerad navigeringsöversikt.

NavigationWindow-klassen

I det här läget har du sett den mängd navigeringstjänster som du troligtvis använder för att skapa program med navigeringsbart innehåll. Dessa tjänster diskuterades i samband med XBAP:er, även om de inte är begränsade till XBAP:er. Moderna operativsystem och Windows-program drar nytta av webbläsarens upplevelse av moderna användare för att införliva webbläsarliknande navigering i fristående program. Vanliga exempel är:

  • Word Thesaurus: Navigera i ordval.

  • Utforskaren: Navigera i filer och mappar.

  • Guider: Dela upp en komplex uppgift i flera sidor som kan navigeras mellan. Ett exempel är guiden Windows-komponenter som hanterar tillägg och borttagning av Windows-funktioner.

Om du vill införliva navigering i webbläsarformat i dina fristående program kan du använda klassen NavigationWindow. NavigationWindow härleds från Window och utökar den med samma stöd för navigering som XBAP:er tillhandahåller. Du kan använda NavigationWindow som antingen huvudfönstret i ditt fristående program eller som ett sekundärt fönster, till exempel en dialogruta.

Om du vill implementera en NavigationWindow, som med de flesta toppklasser i WPF (Window, Pageoch så vidare), använder du en kombination av markering och kod bakom. Detta visas i följande exempel.

<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

Den här koden skapar en NavigationWindow som automatiskt navigerar till en Page (HomePage.xaml) när NavigationWindow öppnas. Om NavigationWindow är huvudprogrammets fönster kan du använda attributet StartupUri för att starta det. Detta visas i följande markering.

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

Följande bild visar NavigationWindow som huvudfönster för ett fristående program.

Ett huvudfönster

Från bilden kan du se att NavigationWindow har en rubrik, även om den inte angavs i NavigationWindow-implementeringskoden från föregående exempel. I stället anges rubriken med egenskapen WindowTitle, som visas i följande kod.

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

</Page>

Att ange egenskaperna WindowWidth och WindowHeight påverkar också NavigationWindow.

Vanligtvis implementerar du egna NavigationWindow när du behöver anpassa dess beteende eller dess utseende. Om du inte gör det kan du använda en genväg. Om du anger paket-URI för en Page som StartupUri i ett fristående program skapar Application automatiskt en NavigationWindow som värd för Page. Följande markering visar hur du aktiverar detta.

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

Om du vill att ett sekundärt programfönster, till exempel en dialogruta, ska vara en NavigationWindowkan du använda koden i följande exempel för att öppna den.

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

Följande bild visar resultatet.

En dialogruta

Som du ser visar NavigationWindow knappar i stil med Internet Explorer: Bakåt och Framåt, vilket gör det möjligt för användare att navigera i journalen. De här knapparna ger samma användarupplevelse, som du ser i följande bild.

bakåt- och framåtknappar i ett navigeringsfönster

Om dina sidor har sitt eget stöd för journalnavigering och användargränssnitt kan du dölja knapparna Back och Forward som visas av NavigationWindow genom att ange värdet för egenskapen ShowsNavigationUI till false.

Du kan också använda anpassningsstöd i WPF för att ersätta användargränssnittet för själva NavigationWindow.

Ramklassen

Både webbläsaren och NavigationWindow är fönster som är värdar för navigeringsbart innehåll. I vissa fall har program innehåll som inte behöver hanteras av ett helt fönster. I stället lagras sådant innehåll i annat innehåll. Du kan infoga navigeringsbart innehåll i annat innehåll med hjälp av klassen Frame. Frame har samma stöd som NavigationWindow och XBAP:er.

I följande exempel visas hur du lägger till en Frame till en Page deklarativt med hjälp av elementet Frame.

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

Den här markering anger Source-attributet för Frame-elementet med en pack-URI för den Page som Frame först ska navigera till. Följande bild visar en XBAP med en Page där en Frame har navigerat mellan flera sidor.

En ram som har navigerat mellan flera sidor

Du behöver inte bara använda Frame inuti innehållet i en Page. Det är också vanligt att hysa en Frame inuti innehållet i en Window.

Som standard använder Frame bara en egen journal i avsaknad av en annan journal. Om en Frame är en del av innehåll som finns i antingen en NavigationWindow eller en XBAP använder Frame journalen som tillhör NavigationWindow eller XBAP. Ibland kan dock en Frame behöva ansvara för sin egen journal. En anledning till detta är att tillåta journalnavigering på de sidor som hanteras av en Frame. Detta illustreras av följande bild.

bildruta och siddiagram

I det här fallet kan du konfigurera Frame att använda en egen journal genom att ange egenskapen JournalOwnership för Frame till OwnsJournal. Detta visas i följande markering.

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

Följande bild illustrerar effekten av att navigera inom en Frame som använder sin egen journal.

En ram som använder sin egen journal

Observera att journalposterna visas i navigeringsgränssnittet i Frame, i stället för av Internet Explorer.

Not

Om en Frame är en del av innehåll som finns i en Windowanvänder Frame en egen journal och visar därmed ett eget navigeringsgränssnitt.

Om användarupplevelsen kräver en Frame för att tillhandahålla en egen journal utan att visa navigeringsgränssnittet kan du dölja navigeringsgränssnittet genom att ange NavigationUIVisibility till Hidden. Detta visas i följande markering.

<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 och NavigationWindow är klasser som kallas för navigeringsvärdar. En navigeringsvärd är en klass som kan navigera till och visa innehåll. För att åstadkomma detta använder varje navigeringsvärd sin egen NavigationService och journal. Den grundläggande konstruktionen av en navigeringsvärd visas i följande bild.

Navigatordiagram

Detta gör att NavigationWindow och Frame ger samma navigeringsstöd som en XBAP tillhandahåller när den finns i webbläsaren.

Förutom att använda NavigationService och en journal implementerar navigeringsvärdar samma medlemmar som NavigationService implementerar. Detta illustreras av följande bild.

En journal i en ram och i ett navigeringsfönster

På så sätt kan du programmera navigeringsstöd direkt mot dem. Du kan överväga detta om du behöver ange ett anpassat navigeringsgränssnitt för en Frame som finns i en Window. Dessutom implementerar båda typerna ytterligare, navigeringsrelaterade medlemmar, inklusive BackStack (NavigationWindow.BackStack, Frame.BackStack) och ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), som gör att du kan räkna upp journalposterna i backstacken respektive vidarebefordra stacken.

Som tidigare nämnts kan mer än en journal finnas i ett program. Följande bild visar ett exempel på när detta kan inträffa.

Flera journaler i ett program

Navigera till annat innehåll än XAML-sidor

Under hela det här avsnittet har Page och pack XBAPs använts för att demonstrera de olika navigeringsfunktionerna i WPF. En Page som kompileras till ett program är dock inte den enda typen av innehåll som kan navigeras till, och paket-XBAP:er är inte det enda sättet att identifiera innehåll.

Som det här avsnittet visar kan du också navigera till lösa XAML-filer, HTML-filer och objekt.

En lös XAML-fil är en fil med följande egenskaper:

  • Innehåller endast XAML (alltså ingen kod).

  • Har en lämplig namnområdesdeklaration.

  • Har filnamnstillägget .xaml.

Tänk till exempel på följande innehåll som lagras som en lös XAML-fil, 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>

När du dubbelklickar på filen öppnas webbläsaren och navigerar till och visar innehållet. Detta visas i följande bild.

Visning av innehållet i Filen Person.XAML

Du kan visa en lös XAML-fil från följande:

  • En webbplats på den lokala datorn, intranätet eller Internet.

  • En UNC-nätverksresurs (Universal Naming Convention).

  • Den lokala disken.

En lös XAML-fil kan läggas till i webbläsarens favoriter eller vara webbläsarens startsida.

Not

Mer information om hur du publicerar och startar lösa XAML-sidor finns i Distribuera ett WPF-program.

En begränsning när det gäller lös XAML är att du bara kan vara värd för innehåll som är säkert att köra i partiellt förtroende. Window kan till exempel inte vara rotelementet i en lös XAML-fil. Mer information finns i WPF Partial Trust Security.

Som du kan förvänta dig kan du också navigera till HTML. Du behöver bara ange en URI som använder http-schemat. Följande XAML visar till exempel en Frame som navigerar till en HTML-sida.

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

Att navigera till HTML kräver särskilda behörigheter. Du kan till exempel inte navigera från en XBAP som körs i sandbox-miljön för partiell förtroendesäkerhet i zonen Internet. Mer information finns i WPF Partial Trust Security.

Kontrollen WebBrowser stöder HTML-dokumentvärd, navigering och skript/hanterad kodkompatibilitet. Detaljerad information om WebBrowser-kontrollen finns i WebBrowser.

Precis som Framekräver navigering till HTML med WebBrowser särskilda behörigheter. Från ett program med partiellt förtroende kan du till exempel bara navigera till HTML som finns på ursprungsplatsen. Mer information finns i WPF Partial Trust Security.

Om du har data som lagras som anpassade objekt är ett sätt att visa dessa data att skapa en Page med innehåll som är bundet till dessa objekt (se Översikt över databindning). Om du inte behöver omkostnaderna för att skapa en hel sida bara för att visa objekten kan du navigera direkt till dem i stället.

Överväg den Person-klass som implementeras i följande kod.

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

Om du vill navigera till den anropar du metoden NavigationWindow.Navigate, vilket visas i följande kod.

<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

Följande bild visar resultatet.

En sida som navigerar till en klass

Från den här bilden kan du se att inget användbart visas. I själva verket är det värde som visas returvärdet för ToString-metoden för objektet Person. Som standard är detta det enda värde som WPF kan använda för att representera ditt objekt. Du kan åsidosätta metoden ToString för att returnera mer meningsfull information, även om det fortfarande bara är ett strängvärde. En teknik som du kan använda som utnyttjar presentationsfunktionerna i WPF är att använda en datamall. Du kan implementera en datamall som WPF kan associera med ett objekt av en viss typ. Följande kod visar en datamall för Person-objektet.

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

Här associeras datamallen med den Person typen med hjälp av tillägget x:Type i attributet DataType. Datamallen binder sedan TextBlock element (se TextBlock) till egenskaperna för klassen Person. Följande bild visar det uppdaterade utseendet på det Person objektet.

Navigera till en klass som har en datamall

En fördel med den här tekniken är den konsekvens du uppnår genom att kunna återanvända datamallen för att konsekvent visa dina objekt överallt i programmet.

Mer information om datamallar finns i Översikt över datamallar.

Säkerhet

WPF-navigeringsstöd gör att XBAP:er kan navigeras till via Internet, och det gör att program kan vara värdar för innehåll från tredje part. För att skydda både program och användare från skadligt beteende tillhandahåller WPF en mängd olika säkerhetsfunktioner som beskrivs i Security och WPF Partial Trust Security.

Se även