Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Windows Presentation Foundation (WPF) ondersteunt browsernavigatie die kan worden gebruikt in twee typen toepassingen: zelfstandige toepassingen en XAML-browsertoepassingen (XBAPs). Als u inhoud voor navigatie wilt verpakken, biedt WPF de Page klasse. U kunt declaratief van Page het ene naar het andere navigeren met behulp van een Hyperlink, of programmatisch, met behulp van de NavigationService. WPF gebruikt het logboek om pagina's te onthouden van waaruit is genavigeerd en om terug te gaan naar de pagina's.
Page, , Hyperlinken NavigationServicehet logboek vormen de kern van de navigatieondersteuning die door WPF wordt aangeboden. In dit overzicht worden deze functies uitgebreid besproken voordat u geavanceerde navigatieondersteuning bestrijkt, waaronder navigatie naar losse XAML-bestanden (Extensible Application Markup Language), HTML-bestanden en -objecten.
Opmerking
In dit onderwerp verwijst de term 'browser' alleen naar browsers die WPF-toepassingen kunnen hosten, die momenteel Microsoft Internet Explorer en Firefox bevatten. Wanneer specifieke WPF-functies alleen worden ondersteund door een bepaalde browser, wordt de browserversie verwezen.
Navigatie in WPF-toepassingen
In dit onderwerp vindt u een overzicht van de belangrijkste navigatiemogelijkheden in WPF. Deze mogelijkheden zijn beschikbaar voor zowel zelfstandige toepassingen als XBAPs, hoewel dit onderwerp ze presenteert binnen de context van een XBAP.
Opmerking
In dit onderwerp wordt niet besproken hoe u XBAPs bouwt en implementeert. Zie het overzicht van WPF XAML-browsertoepassingen voor meer informatie over XBAPs.
In deze sectie worden de volgende aspecten van navigatie uitgelegd en gedemonstreert:
Een pagina implementeren
In WPF kunt u navigeren naar verschillende inhoudstypen met .NET Framework-objecten, aangepaste objecten, opsommingswaarden, gebruikersbesturingselementen, XAML-bestanden en HTML-bestanden. U zult echter merken dat de meest voorkomende en handige manier om inhoud te verpakken is met behulp van Page. Page Daarnaast worden navigatiespecifieke functies geïmplementeerd om hun uiterlijk te verbeteren en de ontwikkeling te vereenvoudigen.
Met behulp Pagevan kunt u declaratief een bevaarbare pagina van XAML-inhoud implementeren met behulp van markeringen zoals hieronder.
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />
Een Page die is geïmplementeerd in XAML-markeringen heeft Page als hoofdelement en vereist de declaratie van de WPF XML-naamruimte. Het Page element bevat de inhoud waarnaar u wilt navigeren en weergeven. U voegt inhoud toe door het Page.Content eigenschapselement in te stellen, zoals wordt weergegeven in de volgende markeringen.
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<Page.Content>
<!-- Page Content -->
Hello, Page!
</Page.Content>
</Page>
Page.Content mag slechts één onderliggend element bevatten; in het voorgaande voorbeeld is de inhoud één tekenreeks, 'Hallo, pagina!' In de praktijk gebruikt u meestal een indelingsbesturingselement als het onderliggende element (zie Indeling) om uw inhoud op te slaan en op te stellen.
De onderliggende elementen van een Page element worden beschouwd als de inhoud van een Page en daarom hoeft u de expliciete Page.Content declaratie niet te gebruiken. De volgende opmaak is het declaratieve equivalent van de voorgaande steekproef.
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<!-- Page Content -->
Hello, Page!
</Page>
In dit geval Page.Content wordt automatisch ingesteld met de onderliggende elementen van het Page element. Zie WPF-inhoudsmodel voor meer informatie.
Een uitsluitend markering Page is handig voor het weergeven van inhoud. Een Page kan echter ook besturingselementen weergeven waarmee gebruikers kunnen communiceren met de pagina en het kan reageren op gebruikersinteractie door gebeurtenissen te verwerken en toepassingslogica aan te roepen. Een interactieve Page wordt geïmplementeerd met behulp van een combinatie van markup en code-behind, zoals te zien in het volgende voorbeeld.
<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
Als u wilt toestaan dat een markeringsbestand en code-behind-bestand samenwerken, is de volgende configuratie vereist:
In markeringen moet het
Page-element het kenmerkx:Classbevatten. Wanneer de toepassing is gebouwd, zorgt het bestaan vanx:Classin het markupbestand ervoor dat Microsoft build engine (MSBuild) eenpartial-klasse maakt die is afgeleid van Page en de naam heeft die is opgegeven door hetx:Class-kenmerk. Hiervoor moet een XML-naamruimtedeclaratie worden toegevoegd voor het XAML-schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). De gegenereerdepartialklasse implementeertInitializeComponent, die wordt aangeroepen om de gebeurtenissen te registreren en de eigenschappen in te stellen die zijn geïmplementeerd in markeringen.In code-behind moet de klasse een
partial-klasse zijn met dezelfde naam die is opgegeven door het kenmerkx:Classin markeringen en moet deze zijn afgeleid van Page. Hierdoor kan het code-behind-bestand worden gekoppeld aan departialklasse die wordt gegenereerd voor het markeringsbestand wanneer de toepassing wordt gebouwd (zie Een WPF-toepassing bouwen).In code-behind moet de Page-klasse een constructor implementeren die de
InitializeComponentmethode aanroept.InitializeComponentwordt geïmplementeerd door de gegenereerdepartial-klasse van het opmaakbestand om gebeurtenissen te registreren en eigenschappen in te stellen die zijn gedefinieerd in de opmaak.
Opmerking
Wanneer u een nieuw Page aan uw project toevoegt met Visual Studio, wordt het Page geïmplementeerd met zowel mark-up als code-behind, en bevat het de benodigde configuratie om de koppeling tussen de mark-up- en code-behind-bestanden te maken, zoals hier wordt beschreven.
Zodra u een Pagehebt, kunt u ernaartoe navigeren. Als u de eerste Page wilt opgeven waarnaar een toepassing navigeert, moet u het begin Pageconfigureren.
Een startpagina configureren
Voor XBAPs moet een bepaalde hoeveelheid toepassingsinfrastructuur worden gehost in een browser. In WPF maakt de Application klasse deel uit van een toepassingsdefinitie waarmee de vereiste toepassingsinfrastructuur wordt vastgesteld (zie Application Management Overview).
Een toepassingsdefinitie wordt meestal geïmplementeerd met behulp van zowel markup als code-behind, waarbij het opmaakbestand is geconfigureerd als een MSBuild-itemApplicationDefinition. Hier volgt een toepassingsdefinitie voor een 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
Een XBAP kan de toepassingsdefinitie gebruiken om een begin Pageop te geven. Dit is de Page waarde die automatisch wordt geladen wanneer de XBAP wordt gestart. U doet dit door de StartupUri eigenschap in te stellen met de URI (Uniform Resource Identifier) voor de gewenste Pagewaarde.
Opmerking
In de meeste gevallen wordt de Page ofwel gecompileerd in of samen met een toepassing ingezet. In deze gevallen is de URI die een Page identificeert een pakket-URI, die voldoet aan het packschema. Pack-URI's worden verder besproken in Pack-URI's in WPF. U kunt ook naar inhoud navigeren met behulp van het HTTP-schema, dat hieronder wordt besproken.
U kunt StartupUri declaratief instellen in opmaak, zoals wordt weergegeven in het volgende voorbeeld.
<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 dit voorbeeld wordt het StartupUri kenmerk ingesteld met een relatieve pack-URI die HomePage.xaml identificeert. Wanneer de XBAP wordt gestart, wordt er automatisch naar HomePage.xaml genavigeerd en weergegeven. Dit wordt gedemonstreerd in de volgende afbeelding, waarin een XBAP wordt weergegeven die is gestart vanaf een webserver.
Opmerking
Zie het overzicht van WPF XAML-browsertoepassingen en het implementeren van een WPF-toepassing voor meer informatie over de ontwikkeling en implementatie van XBAPs.
De titel, breedte en hoogte van het hostvenster configureren
Een ding dat u misschien hebt opgemerkt uit de vorige afbeelding, is dat de titel van zowel de browser als het tabbladvenster de URI voor de XBAP is. Naast lang zijn, is de titel niet aantrekkelijk of informatief. Page Daarom kunt u de titel wijzigen door de WindowTitle eigenschap in te stellen. Bovendien kunt u de breedte en hoogte van het browservenster configureren door respectievelijk in te stellen WindowWidth en WindowHeight, respectievelijk.
WindowTitle, WindowWidthen WindowHeight kan declaratief worden ingesteld in markeringen, zoals wordt weergegeven in het volgende voorbeeld.
<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>
Het resultaat wordt weergegeven in de volgende afbeelding.
Hyperlink Navigatie
Een typische XBAP bestaat uit verschillende pagina's. De eenvoudigste manier om van de ene pagina naar de andere te navigeren, is door een Hyperlink. U kunt op declaratieve wijze een Hyperlink aan een Page toevoegen met behulp van het Hyperlink-element, dat wordt weergegeven in de volgende opmaak.
<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>
Voor een Hyperlink element is het volgende vereist:
De pack-URI van de Page om naar te navigeren, zoals opgegeven door het
NavigateUrikenmerk.Inhoud waarop een gebruiker kan klikken om de navigatie te initiëren, zoals tekst en afbeeldingen (voor de inhoud die het
Hyperlinkelement kan bevatten, zie Hyperlink).
In de volgende afbeelding ziet u een XBAP met een Page dat een Hyperlink heeft.
Zoals u zou verwachten, zorgt klikken op Hyperlink ervoor dat de XBAP naar Page navigeert dat is geïdentificeerd door het NavigateUri kenmerk. Bovendien voegt de XBAP een vermelding voor de vorige Page toe aan de lijst Recente pagina's in Internet Explorer. Dit wordt weergegeven in de volgende afbeelding.
Naast de ondersteuning van navigatie van het ene Page naar het andere, biedt Hyperlink ook ondersteuning voor fragmentnavigatie.
Fragmentnavigatie
Fragmentnavigatie is de navigatie naar een inhoudsfragment in de huidige Page of een anderePage. In WPF is een inhoudsfragment de inhoud die is opgenomen door een benoemd element. Een benoemd element is een element waaraan het Name kenmerk is ingesteld. In de volgende markeringen ziet u een benoemd TextBlock element dat een inhoudsfragment bevat.
<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>
Als u Hyperlink naar een inhoudsfragment wilt navigeren, moet het NavigateUri kenmerk het volgende bevatten:
De URI van de Page met het inhoudsfragment waarnaar genavigeerd moet worden.
Een #-teken.
De naam van het element op het Page element dat het inhoudsfragment bevat.
Een fragment-URI heeft de volgende indeling.
PageURI#ElementName
Hieronder ziet u een voorbeeld van een Hyperlink fragment dat is geconfigureerd om naar een inhoudsfragment te navigeren.
<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>
Opmerking
In deze sectie wordt de standaard implementatie van fragmentnavigatie in WPF beschreven. MET WPF kunt u ook uw eigen fragmentnavigatieschema implementeren dat gedeeltelijk vereist dat de NavigationService.FragmentNavigation gebeurtenis wordt verwerkt.
Belangrijk
U kunt alleen navigeren naar fragmenten in losse XAML-pagina's (alleen XAML-bestanden met markeringen met Page als hoofdelement) als de pagina's kunnen worden bekeken via HTTP.
Een losse XAML-pagina kan echter naar zijn eigen fragmenten navigeren.
Navigatieservice
Hoewel Hyperlink een gebruiker in staat stelt om de navigatie naar een bepaalde Page te initiëren, wordt het werk van het zoeken en downloaden van de pagina uitgevoerd door de NavigationService klasse. In wezen NavigationService maakt het mogelijk om een navigatieaanvraag namens de client-code te verwerken, zoals de Hyperlink. NavigationService Daarnaast wordt ondersteuning op een hoger niveau geïmplementeerd voor het bijhouden en beïnvloeden van een navigatieaanvraag.
Wanneer op een Hyperlink wordt geklikt, roept WPF NavigationService.Navigate aan om de Page-URI op te zoeken en te downloaden die is opgegeven in het pack-URI. Het gedownloade Page object wordt geconverteerd naar een boomstructuur van objecten waarvan het hoofdobject een exemplaar is van het gedownloade Pageobject. Een verwijzing naar het hoofdobject Page wordt opgeslagen in de NavigationService.Content eigenschap. De pack-URI voor de inhoud waarnaar is genavigeerd, wordt opgeslagen in de NavigationService.Source eigenschap, terwijl de NavigationService.CurrentSource pack-URI wordt opgeslagen voor de laatste pagina waarnaar is genavigeerd.
Opmerking
Het is mogelijk dat een WPF-toepassing momenteel meer dan één actief NavigationService heeft. Zie Navigatiehosts verderop in dit onderwerp voor meer informatie.
Programmatische navigatie met de navigatieservice
U hoeft niets te weten over NavigationService als navigatie declaratief wordt geïmplementeerd in opmaaktaal met behulp van Hyperlink, omdat Hyperlink namens u de NavigationService gebruikt. Dit betekent dat, zolang het directe of indirecte bovenliggende element van een Hyperlink een navigatiehost is (zie Navigatiehosts), Hyperlink de navigatieservice van de navigatiehost kan vinden en gebruiken om een navigatieaanvraag te verwerken.
Er zijn echter situaties waarin u rechtstreeks moet gebruiken NavigationService , waaronder het volgende:
Wanneer u een Page moet maken met een constructor zonder parameters.
Wanneer u eigenschappen van de Page moet instellen voordat u ernaar navigeert.
Wanneer de Page die genavigeerd moet worden, alleen kan worden bepaald tijdens de uitvoeringsfase.
In deze situaties moet u code schrijven om programmatisch navigatie te initiëren door de Navigate methode van het NavigationService object aan te roepen. Hiervoor moet een verwijzing naar een NavigationService.
Een verwijzing naar de NavigationService verkrijgen
Om redenen die worden behandeld in de sectie Navigatiehosts, kan een WPF-toepassing meer dan één NavigationService hebben. Dit betekent dat uw code een manier nodig heeft om een NavigationService te vinden, welke meestal de NavigationService is die naar de huidige Page heeft genavigeerd. U kunt een verwijzing naar een NavigationService krijgen door de staticNavigationService.GetNavigationService methode aan te roepen. Als u de NavigationService navigatie naar een bepaalde Pagewilt ophalen, geeft u een verwijzing door naar het Page argument van de GetNavigationService methode. De volgende code laat zien hoe u de NavigationService voor de huidige Page kunt ophalen.
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 snelkoppeling voor het vinden van de NavigationService voor een Page, implementeert de Page de NavigationService eigenschap. Dit wordt weergegeven in het volgende voorbeeld.
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
Opmerking
Een Page kan alleen een verwijzing naar zijn NavigationService verkrijgen wanneer Page het Loaded-evenement activeert.
Programmatische navigatie naar een paginaobject
In het volgende voorbeeld wordt getoond hoe u via NavigationService programmatig kunt navigeren naar een Page. Programmatische navigatie is vereist omdat de Page, waarheen wordt genavigeerd, slechts kan worden geïnstantieerd met behulp van een constructor zonder parameters. De Page met de niet-parameterloze constructor wordt weergegeven in de volgende markeringen en 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
De Page die naar de Page met de niet-parameterloze constructor navigeert, wordt weergegeven in de volgende markeringen en 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
Wanneer op Hyperlink op deze Page wordt geklikt, wordt de navigatie gestart door een Page te creëren met de constructor die niet parameterloos is, en vervolgens de NavigationService.Navigate-methode aan te roepen. Navigate accepteert een verwijzing naar het object waarnaar het NavigationService navigeert, in plaats van naar een pack-URI.
Programmatische navigatie met een pack-URI
Als u een pakket-URI programmatisch moet maken (wanneer u bijvoorbeeld alleen de pack-URI tijdens runtime kunt bepalen), kunt u de NavigationService.Navigate methode gebruiken. Dit wordt weergegeven in het volgende voorbeeld.
<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
De huidige pagina vernieuwen
A Page wordt niet gedownload als deze dezelfde pack-URI heeft als de pack-URI die is opgeslagen in de NavigationService.Source eigenschap. Als u wilt afdwingen dat WPF de huidige pagina opnieuw downloadt, kunt u de NavigationService.Refresh methode aanroepen, zoals wordt weergegeven in het volgende voorbeeld.
<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
Levensduur van navigatie
Er zijn veel manieren om navigatie te initiëren, zoals u hebt gezien. Wanneer de navigatie wordt gestart en terwijl de navigatie wordt uitgevoerd, kunt u de navigatie volgen en beïnvloeden met behulp van de volgende gebeurtenissen die worden geïmplementeerd door NavigationService:
Navigating. Treedt op wanneer een nieuwe navigatie wordt aangevraagd. Kan worden gebruikt om de navigatie te annuleren.
NavigationProgress. Vindt periodiek plaats tijdens een download om informatie over de voortgang van de navigatie op te geven.
Navigated. Vindt plaats wanneer de pagina is gevonden en gedownload.
NavigationStopped. Treedt op wanneer de navigatie wordt gestopt (door aan te roepen StopLoading) of wanneer een nieuwe navigatie wordt aangevraagd terwijl er een huidige navigatie wordt uitgevoerd.
NavigationFailed. Treedt op wanneer er een fout optreedt tijdens het navigeren naar de aangevraagde inhoud.
LoadCompleted. Treedt op wanneer inhoud waarnaar is genavigeerd, wordt geladen en geparseerd en is begonnen met renderen.
FragmentNavigation. Treedt op wanneer de navigatie naar een inhoudsfragment begint, wat gebeurt:
Onmiddellijk, als het gewenste fragment zich in de huidige inhoud bevindt.
Nadat de broninhoud is geladen, als het gewenste fragment in verschillende inhoud staat.
De navigatiegebeurtenissen worden gegenereerd in de volgorde die wordt geïllustreerd door de volgende afbeelding.
Over het algemeen maakt een Page zich geen zorgen over deze gebeurtenissen. Het is waarschijnlijker dat een toepassing zich hierbij bezighoudt en daarom worden deze gebeurtenissen ook door de Application klasse gegenereerd:
Telkens wanneer NavigationService een gebeurtenis activeert, activeert de Application-klasse de bijbehorende gebeurtenis. Frame en NavigationWindow bieden dezelfde events om navigatie binnen hun reikwijdtes te detecteren.
In sommige gevallen is een Page mogelijk geïnteresseerd in deze gebeurtenissen. Een Page kan bijvoorbeeld de NavigationService.Navigating gebeurtenis afhandelen om te bepalen of de navigatie moet worden geannuleerd. Dit wordt weergegeven in het volgende voorbeeld.
<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
Als u een handler registreert met een navigatie-gebeurtenis van een Page, zoals in het voorgaande voorbeeld, moet u ook de registratie van de gebeurtenis-handler ongedaan maken. Als u dit niet doet, kunnen er bijwerkingen zijn met betrekking tot hoe WPF-navigatie navigatie onthoudt Page met behulp van het logboek.
Navigatie onthouden met het logboek
WPF gebruikt twee stacks om de pagina's te onthouden waaruit u bent genavigeerd: een back-stack en een vooruitstack. Wanneer u van de huidige Page naar een nieuwe Page of naar een bestaande Pagenavigeert, wordt de huidige Page toegevoegd aan de back-stack. Wanneer u van de huidige Page terug naar de vorige Pagenavigeert, wordt de huidige Page toegevoegd aan de volgende stack. De terugstapel, de vooruitstapel en de functies om ze te beheren worden samen het logboek genoemd. Elk item in de backstack en de forward-stack is een exemplaar van de JournalEntry klasse en wordt een logboekvermelding genoemd.
Navigeren in het logboek vanuit Internet Explorer
Conceptueel werkt het logboek op dezelfde manier als de knoppen Vorige en Doorsturen in Internet Explorer. Deze worden weergegeven in de volgende afbeelding.
Voor XBAPs die worden gehost door Internet Explorer, integreert WPF het logboek in de navigatie-UI van Internet Explorer. Hiermee kunnen gebruikers door pagina's in een XBAP navigeren met behulp van de knoppen Vorige, Doorsturen en Recente pagina's in Internet Explorer.
Belangrijk
Wanneer een gebruiker in Internet Explorer van en naar een XBAP navigeert, worden alleen de logboekvermeldingen voor pagina's die niet in leven zijn gehouden, bewaard in het logboek. Zie De levensduur van pagina's en het logboek verderop in dit onderwerp voor meer informatie over het in leven houden van pagina's.
Standaard is de tekst voor elke Page die wordt weergegeven in de lijst Recent Pages van Internet Explorer de URI voor de Page. In veel gevallen is dit niet bijzonder zinvol voor de gebruiker. Gelukkig kunt u de tekst wijzigen met een van de volgende opties:
De waarde van het gekoppelde
JournalEntry.Namekenmerk.De
Page.Titlekenmerkwaarde.De
Page.WindowTitlekenmerkwaarde en de URI voor de huidige Page.De URI voor de huidige Page. (Standaard)
De volgorde waarin de opties worden weergegeven, komt overeen met de volgorde van prioriteit voor het zoeken naar de tekst. Als deze bijvoorbeeld JournalEntry.Name is ingesteld, worden de andere waarden genegeerd.
In het volgende voorbeeld wordt het Page.Title kenmerk gebruikt om de tekst te wijzigen die wordt weergegeven voor een logboekvermelding.
<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
Navigeren in het logboek met WPF
Hoewel een gebruiker door het logboek kan navigeren met behulp van de back-, forward- en recente pagina's in Internet Explorer, kunt u ook door het logboek navigeren met behulp van zowel declaratieve als programmatische mechanismen van WPF. Een van de redenen hiervoor is om aangepaste navigatie-UIS's op uw pagina's te bieden.
U kunt declaratief ondersteuning voor logboeknavigatie toevoegen met behulp van de navigatieopdrachten die worden weergegeven door NavigationCommands. In het volgende voorbeeld ziet u hoe u de BrowseBack navigatieopdracht gebruikt.
<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>
U kunt programmatisch door het logboek navigeren met behulp van een van de volgende leden van de NavigationService klasse:
Het logboek kan ook programmatisch worden bewerkt, zoals besproken in Inhoudsstatus behouden met navigatiegeschiedenis verderop in dit onderwerp.
Levensduur van pagina en logboek
Overweeg een XBAP met verschillende pagina's met uitgebreide inhoud, waaronder afbeeldingen, animaties en media. De geheugenvoetafdruk voor pagina's zoals deze kan behoorlijk groot zijn, met name als video- en audiomedia worden gebruikt. Aangezien het logboek pagina's onthoudt waarnaar is genavigeerd, kan een dergelijke XBAP snel een grote en merkbare hoeveelheid geheugen verbruiken.
Daarom is het standaardgedrag van het logboek het opslaan Page van metagegevens in elk logboekitem in plaats van een verwijzing naar een Page object. Wanneer er naar een journaalpost wordt genavigeerd, worden de Page-metagegevens gebruikt om een nieuw exemplaar van de bepaalde Page-instantie te maken. Als gevolg hiervan heeft elk Page dat wordt genavigeerd de levensduur die wordt geïllustreerd door de volgende afbeelding.
Hoewel het gebruik van het standaardlogboekgedrag kan besparen op geheugenverbruik, kunnen de renderingprestaties per pagina worden verminderd; het opnieuw inbouwen van een Page kan tijdrovend zijn, met name als het veel inhoud heeft. Als u een Page instantie in het logboek wilt bewaren, kunt u twee technieken gebruiken om dat te doen. Eerst kunt u programmatisch naar een Page object navigeren door de methode aan te NavigationService.Navigate roepen.
Ten tweede kunt u opgeven dat WPF een exemplaar van een Page in de journal behoudt door de eigenschap KeepAlive in te stellen op true (de standaardwaarde is false). Zoals in het volgende voorbeeld wordt weergegeven, kunt u KeepAlive declaratief instellen in de 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>
De levensduur van een Page die in leven wordt gehouden, is op subtiele wijze anders dan een die dat niet is. De eerste keer dat een Page levend leven wordt genavigeerd, wordt het geïnstantieerd, net als een Page die niet levend wordt gehouden. Echter, omdat een exemplaar van de Page wordt bewaard in het logboek, wordt het nooit meer geïnstantieerd zolang het in het logboek staat. Als een Page initialisatielogica heeft die elke keer moet worden aangeroepen wanneer naar het Page wordt genavigeerd, moet u deze van de constructor naar een handler voor de Loaded gebeurtenis verplaatsen. Zoals in de volgende afbeelding wordt weergegeven, worden de Loaded en Unloaded gebeurtenissen nog steeds getriggerd elke keer dat een Page naar en van wordt genavigeerd, respectievelijk.
,
Wanneer een Page niet levend wordt gehouden, moet u een van de volgende handelingen niet uitvoeren:
Sla een verwijzing naar het bestand of een deel ervan op.
Registreer gebeurtenis-handlers met gebeurtenissen die niet door deze zijn geïmplementeerd.
Door één van deze twee dingen te doen, worden verwijzingen gemaakt die ervoor zorgen dat de Page in het geheugen wordt bewaard, zelfs nadat het uit het journaal is verwijderd.
Over het algemeen verdient het de voorkeur om het standaardgedrag te volgen waarbij Page niet in leven wordt gehouden. Dit heeft echter implicaties voor de staat die in de volgende sectie worden besproken.
Inhoudsstatus behouden met navigatiegeschiedenis
Als een Page niet actief wordt gehouden en er besturingselementen zijn waarmee gegevens van de gebruiker worden verzameld, wat gebeurt er met de gegevens als een gebruiker van en naar de Page? Vanuit het perspectief van de gebruikerservaring verwacht de gebruiker de gegevens te zien die ze eerder hebben ingevoerd. Helaas gaat de gegevens verloren, omdat bij elke navigatie een nieuw exemplaar van de Page wordt gemaakt, waardoor de besturingselementen die de gegevens hebben verzameld opnieuw worden geïnstantieerd.
Gelukkig biedt het logboek ondersteuning voor het onthouden van gegevens in Page navigaties, inclusief controlegegevens. In het bijzonder fungeert het logboekitem voor elk Page item als een tijdelijke container voor de bijbehorende Page status. In de volgende stappen wordt beschreven hoe deze ondersteuning wordt gebruikt wanneer er Page wordt genavigeerd vanuit:
Een vermelding voor de huidige Page wordt toegevoegd aan het logboek.
De status van de Page pagina wordt opgeslagen met het logboekitem voor die pagina, die wordt toegevoegd aan de backstack.
Er wordt naar de nieuwe Page genavigeerd.
Wanneer de pagina Page terug wordt genavigeerd met behulp van het logboek, worden de volgende stappen uitgevoerd:
De Page (bovenste logboekvermelding op de backstack) wordt geïnstantieerd.
De Page status wordt vernieuwd met de status die is opgeslagen met het logboekitem voor de Page.
Er wordt terug genavigeerd naar de Page.
WPF gebruikt deze ondersteuning automatisch wanneer de volgende elementen worden gebruikt op een Page:
Als een Page deze besturingselementen gebruikt, worden gegevens die erin zijn ingevoerd onthouden tijdens Page-navigaties, zoals gedemonstreerd door de Favoriete KleurListBox in de volgende afbeelding.
Wanneer een Page andere besturingselementen heeft dan die in de voorgaande lijst of wanneer de status wordt opgeslagen in aangepaste objecten, moet u code schrijven om ervoor te zorgen dat het logboek de status onthoudt tijdens Page navigatie.
Als u kleine stukjes status Page in navigatie moet onthouden, kunt u afhankelijkheidseigenschappen (zie DependencyProperty) gebruiken die zijn geconfigureerd met de FrameworkPropertyMetadata.Journal metagegevensvlag.
Als de status die u Page nodig hebt voor het onthouden van navigaties uit meerdere stukjes gegevens bestaat, is het mogelijk minder code-intensief om uw status in één klasse in te kapselen en de IProvideCustomContentState interface te implementeren.
Als u door verschillende statussen van een enkele Page wilt navigeren zonder het Page zelf te benaderen, kunt u IProvideCustomContentState en NavigationService.AddBackEntry gebruiken.
Koekjes
Een andere manier waarop WPF-toepassingen gegevens kunnen opslaan, is met cookies, die worden gemaakt, bijgewerkt en verwijderd met behulp van de SetCookie en GetCookie methoden. De cookies die u in WPF kunt maken, zijn dezelfde cookies die andere typen webtoepassingen gebruiken; cookies zijn willekeurige stukjes gegevens die door een toepassing op een clientcomputer worden opgeslagen tijdens of in toepassingssessies. Cookiegegevens hebben doorgaans de vorm van een naam/waardepaar in de volgende indeling.
Naam=Waarde
Wanneer de gegevens worden doorgegeven aan SetCookie, samen met de Uri locatie waarvoor de cookie moet worden ingesteld, wordt er een cookie in het geheugen gemaakt en is deze alleen beschikbaar voor de duur van de huidige toepassingssessie. Dit type cookie wordt een sessiecookie genoemd.
Als u een cookie wilt opslaan in toepassingssessies, moet er een vervaldatum aan de cookie worden toegevoegd met behulp van de volgende indeling.
NAAM=WAARDE; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT
Een cookie met een vervaldatum wordt opgeslagen in de map Tijdelijke internetbestanden van de huidige Windows-installatie totdat de cookie verloopt. Een dergelijke cookie wordt een permanente cookie genoemd omdat deze zich blijft voordoen in toepassingssessies.
U haalt zowel sessie- als permanente cookies op door de GetCookie methode aan te roepen, waarbij u de Uri locatie doorgeeft waar de cookie is ingesteld met de SetCookie methode.
Hier volgen enkele van de manieren waarop cookies worden ondersteund in WPF:
Zelfstandige WPF-toepassingen en XBAPs kunnen cookies maken en beheren.
Cookies die door een XBAP worden gemaakt, kunnen worden geopend vanuit de browser.
XBAPs uit hetzelfde domein kunnen cookies maken en delen.
XBAPs en HTML-pagina's uit hetzelfde domein kunnen cookies maken en delen.
Cookies worden verzonden wanneer XBAPs en losse XAML-pagina's webaanvragen indienen.
Zowel XBAPs op het hoogste niveau als XBAPs die worden gehost in IFRAMES, hebben toegang tot cookies.
Cookieondersteuning in WPF is hetzelfde voor alle ondersteunde browsers.
In Internet Explorer wordt het P3P-beleid dat betrekking heeft op cookies gerespecteerd door WPF, met name met betrekking tot eerste- en derdepartij-XBAPs.
Gestructureerde navigatie
Als u gegevens van het ene Page naar het andere wilt doorgeven, kunt u de gegevens doorgeven als argumenten aan een niet-parameterloze constructor van de Page. Houd er rekening mee dat als u deze techniek gebruikt, u de Page actief moet houden; zo niet, dan wordt de volgende keer dat u naar de Page navigeert, de Page opnieuw geïnstantieerd door WPF met behulp van de parameterloze constructor.
U kunt ook Page eigenschappen implementeren die worden ingesteld met de gegevens die moeten worden doorgegeven. Het wordt echter lastig wanneer een Page gegevens moet terugsturen naar de Page die ernaartoe zijn genavigeerd. Het probleem is dat navigatie onvoldoende systemen biedt om te waarborgen dat men terugkeert naar een Page wanneer daar vandaan is vertrokken. In wezen biedt navigatie geen ondersteuning voor semantiek voor oproepen/retourneren. Om dit probleem op te lossen, biedt WPF de PageFunction<T> klasse die u kunt gebruiken om ervoor te zorgen dat een Page wordt geretourneerd op een voorspelbare en gestructureerde manier. Zie Overzicht van gestructureerde navigatie voor meer informatie.
De klasse NavigationWindow
Tot nu toe hebt u het gamut van navigatieservices gezien die u waarschijnlijk zult gebruiken om toepassingen te bouwen met bevaarbare inhoud. Deze services werden besproken in de context van XBAPs, hoewel ze niet beperkt zijn tot XBAPs. Moderne besturingssystemen en Windows-toepassingen maken gebruik van de browserervaring van moderne gebruikers om navigatie in browserstijl op te nemen in zelfstandige toepassingen. Dit zijn enkele veel voorkomende voorbeelden:
Word-synoniemenlijst: Door woordkeuzen navigeren.
Verkenner: Door bestanden en mappen navigeren.
Wizards: Een complexe taak opsplitsen in meerdere pagina's die kunnen worden genavigeerd tussen. Een voorbeeld is de wizard Windows-onderdelen die het toevoegen en verwijderen van Windows-functies afhandelt.
Als u navigatie in browserstijlen wilt opnemen in uw zelfstandige toepassingen, kunt u de NavigationWindow klasse gebruiken. NavigationWindow is afgeleid van Window en breidt het uit met dezelfde ondersteuning voor navigatie die XBAPs bieden. U kunt het hoofdvenster van uw zelfstandige toepassing of als een secundair venster, zoals een dialoogvenster, gebruiken NavigationWindow .
Als u een NavigationWindow, net als bij de meeste klassen op het hoogste niveau in WPF (Window, Pageenzovoort), wilt implementeren, gebruikt u een combinatie van markeringen en code-achter. Dit wordt weergegeven in het volgende voorbeeld.
<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
Met deze code maakt u een NavigationWindow die automatisch naar een Page (HomePage.xaml) navigeert wanneer de NavigationWindow code wordt geopend. Als het NavigationWindow hoofdtoepassingsvenster is, kunt u het StartupUri kenmerk gebruiken om het te starten. Dit wordt weergegeven in de volgende markeringen.
<Application
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
StartupUri="MainWindow.xaml" />
In de volgende afbeelding ziet u het NavigationWindow hoofdvenster van een zelfstandige toepassing.
In de afbeelding ziet u dat de NavigationWindow titel een titel heeft, ook al is deze niet ingesteld in de NavigationWindow implementatiecode uit het voorgaande voorbeeld. In plaats daarvan wordt de titel ingesteld met behulp van de WindowTitle eigenschap, die wordt weergegeven in de volgende code.
<Page
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
Title="Home Page"
WindowTitle="NavigationWindow">
</Page>
Het instellen van de WindowWidth en WindowHeight eigenschappen heeft ook invloed op de NavigationWindow.
Meestal implementeert u uw eigen NavigationWindow implementatie wanneer u het gedrag of het uiterlijk ervan moet aanpassen. Als u geen van beide doet, kunt u een snelkoppeling gebruiken. Als u de pack-URI van een Page als de StartupUri in een zelfstandige toepassing opgeeft, Application maakt u automatisch een NavigationWindow om de Pagete hosten. In de volgende markeringen ziet u hoe u dit inschakelt.
<Application
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
StartupUri="HomePage.xaml" />
Als u wilt dat een secundair toepassingsvenster, zoals een dialoogvenster, een NavigationWindowdialoogvenster is, kunt u de code in het volgende voorbeeld gebruiken om het te openen.
// 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()
In de volgende afbeelding ziet u het resultaat.
Zoals u kunt zien, NavigationWindow worden de knoppen Vorige en Doorsturen van Internet Explorer weergegeven waarmee gebruikers door het logboek kunnen navigeren. Deze knoppen bieden dezelfde gebruikerservaring, zoals wordt weergegeven in de volgende afbeelding.
Als uw pagina's hun eigen ondersteuning bieden voor logboeknavigatie en gebruikersinterface, kunt u de knoppen Vorige en Doorsturen verbergen NavigationWindow door de waarde van de ShowsNavigationUI eigenschap in te stellen op false.
U kunt ook aanpassingsondersteuning in WPF gebruiken om de gebruikersinterface van de NavigationWindow zelf te vervangen.
De frameklasse
Zowel de browser als NavigationWindow zijn vensters die navigeerbare inhoud hosten. In sommige gevallen hebben toepassingen inhoud die niet door een heel venster hoeft te worden gehost. In plaats daarvan wordt dergelijke inhoud gehost in andere inhoud. U kunt bevaarbare inhoud invoegen in andere inhoud met behulp van de Frame klasse. Frame biedt dezelfde ondersteuning als NavigationWindow XBAPs.
In het volgende voorbeeld ziet u hoe u een Frame declaratief aan een Page element toevoegt met behulp van het 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>
Met deze markering wordt het Source kenmerk van het Frame element ingesteld met een pack-URI voor de Page waarde waarnaar de Frame in eerste instantie moet navigeren. In de volgende afbeelding ziet u een XBAP met een Page die tussen verschillende Frame pagina's heeft genavigeerd.
U hoeft niet alleen te gebruiken Frame in de inhoud van een Page. Het is ook gebruikelijk om een Frame in de inhoud van een Window te hosten.
Frame Standaard wordt alleen een eigen logboek gebruikt bij afwezigheid van een ander logboek. Als een Frame deel uitmaakt van inhoud die wordt gehost in een NavigationWindow of een XBAP, Frame gebruikt u het logboek dat deel uitmaakt van de NavigationWindow of XBAP. Soms moet een Frame echter zelf verantwoordelijk zijn voor zijn eigen logboek. Een van de redenen hiervoor is om logboeknavigatie toe te staan binnen de pagina's die worden gehost door een Frame. Dit wordt geïllustreerd door de volgende afbeelding.
In dit geval kunt u de Frame eigenschap van de JournalOwnership configureren om het Frame zijn eigen logboek te laten gebruiken door OwnsJournal in te stellen. Dit wordt weergegeven in de volgende markeringen.
<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>
De volgende afbeelding toont het effect van navigeren binnen een Frame dat zijn eigen journal gebruikt.
U ziet dat de logboekvermeldingen worden weergegeven door de navigatiegebruikersinterface in de Frame, in plaats van door Internet Explorer.
Opmerking
Als een Frame deel uitmaakt van inhoud die wordt gehost in een Window, gebruikt Frame zijn eigen logboek en geeft daarom zijn eigen navigatie-UI weer.
Als uw gebruikerservaring vereist dat een Frame zijn eigen logboek biedt zonder de navigatiegebruikersinterface weer te geven, kunt u de navigatiegebruikersinterface verbergen door NavigationUIVisibility in te stellen op Hidden. Dit wordt weergegeven in de volgende markeringen.
<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>
Navigatiehosts
Frame en NavigationWindow zijn klassen die ook wel navigatiehosts worden genoemd. Een navigatiehost is een klasse die naar inhoud kan navigeren en weergeven. Om dit te bereiken, gebruikt elke navigatiehost een eigen NavigationService en logboek. De basisconstructie van een navigatiehost wordt weergegeven in de volgende afbeelding.
In wezen kunnen NavigationWindow en Frame dezelfde navigatieondersteuning bieden die een XBAP biedt wanneer deze in de browser wordt gehost.
Naast het gebruik van NavigationService en een logboek, implementeren navigatiehosts dezelfde leden als NavigationService implementeert. Dit wordt geïllustreerd door de volgende afbeelding.
Hiermee kunt u navigatieondersteuning rechtstreeks tegen hen programmeren. U kunt dit overwegen als u een aangepaste navigatiegebruikersinterface moet opgeven voor een Frame die is ondergebracht in een Window. Bovendien implementeren beide typen aanvullende, navigatiegerelateerde leden, waaronder BackStack (NavigationWindow.BackStack, Frame.BackStack) en ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), waarmee u de logboekvermeldingen in de back-stack en de volgende stack kunt inventariseren.
Zoals eerder vermeld, kunnen er meer dan één logboek bestaan in een toepassing. In de volgende afbeelding ziet u een voorbeeld van wanneer dit kan gebeuren.
Navigeren naar inhoud anders dan XAML-pagina's
Gedurende dit onderwerp zijn Page en XBAP-pakketten gebruikt om de verschillende navigatiemogelijkheden van WPF te demonstreren. Een Page die in een toepassing is gecompileerd is echter niet het enige type inhoud waarnaar kan worden genavigeerd, en het verpakken van XBAPs is niet de enige methode om inhoud te identificeren.
Zoals in deze sectie wordt gedemonstreerde, kunt u ook navigeren naar losse XAML-bestanden, HTML-bestanden en objecten.
Navigeren naar losse XAML-bestanden
Een los XAML-bestand is een bestand met de volgende kenmerken:
Bevat alleen XAML (dat wil gezegd, geen code).
Heeft een geschikte naamruimtedeclaratie.
Heeft de bestandsnaamextensie .xaml.
Denk bijvoorbeeld aan de volgende inhoud die is opgeslagen als een los XAML-bestand, 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>
Wanneer u dubbelklikt op het bestand, wordt de browser geopend, navigeert deze naar de inhoud en wordt deze weergegeven. Dit wordt weergegeven in de volgende afbeelding.
U kunt een los XAML-bestand weergeven op de volgende manieren:
Een website op de lokale computer, het intranet of internet.
Een UNC-bestandsshare (Universal Naming Convention).
De lokale schijf.
Een los XAML-bestand kan worden toegevoegd aan de favorieten van de browser of als de startpagina van de browser.
Opmerking
Zie Een WPF-toepassing implementeren voor meer informatie over het publiceren en starten van losse XAML-pagina's.
Een beperking met betrekking tot los XAML is dat u alleen inhoud kunt hosten die veilig kan worden uitgevoerd in gedeeltelijke vertrouwensrelatie. Kan bijvoorbeeld Window het hoofdelement van een los XAML-bestand niet zijn. Zie WPF Partial Trust Securityvoor meer informatie.
Navigeren naar HTML-bestanden met frame
Zoals u zou verwachten, kunt u ook naar HTML navigeren. U hoeft alleen een URI op te geven die gebruikmaakt van het HTTP-schema. In de volgende XAML ziet u bijvoorbeeld een Frame pagina die naar een HTML-pagina navigeert.
<Frame Source="http://www.microsoft.com/default.aspx" />
Voor het navigeren naar HTML zijn speciale machtigingen vereist. U kunt bijvoorbeeld niet navigeren vanuit een XBAP die wordt uitgevoerd in de gedeeltelijke vertrouwensbeveiligings sandbox van de internetzone. Zie WPF Partial Trust Securityvoor meer informatie.
Navigeren naar HTML-bestanden met behulp van het webbrowserbesturingselement
Het WebBrowser besturingselement ondersteunt het hosten van HTML-documenten, navigatie en script/beheerde code-interoperabiliteit. Voor gedetailleerde informatie over het besturingselement WebBrowser, zie WebBrowser.
Zoals Frame vereist het navigeren naar HTML met WebBrowser speciale machtigingen. U kunt bijvoorbeeld vanuit een toepassing voor gedeeltelijke vertrouwensrelatie alleen navigeren naar HTML die zich op de site van oorsprong bevindt. Zie WPF Partial Trust Securityvoor meer informatie.
Navigeren naar aangepaste objecten
Als u gegevens hebt die zijn opgeslagen als aangepaste objecten, kunt u die gegevens op één manier weergeven door een Page inhoud te maken die is gebonden aan die objecten (zie Overzicht van gegevensbinding). Als u de overhead van het maken van een hele pagina niet nodig hebt om de objecten weer te geven, kunt u er rechtstreeks naar navigeren.
Houd rekening met de Person klasse die in de volgende code is geïmplementeerd.
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
Als u ernaartoe wilt navigeren, roept u de NavigationWindow.Navigate methode aan, zoals wordt gedemonstreerd door de volgende 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
In de volgende afbeelding ziet u het resultaat.
In deze afbeelding ziet u dat er niets nuttigs wordt weergegeven. In feite is de waarde die wordt weergegeven de retourwaarde van de methode voor het ToString object Person . Dit is standaard de enige waarde die WPF kan gebruiken om uw object weer te geven. U kunt de ToString methode overschrijven om zinvollere informatie te retourneren, hoewel deze nog steeds alleen een tekenreekswaarde is. Een techniek die u kunt gebruiken om te profiteren van de presentatiemogelijkheden van WPF, is door een gegevenssjabloon te gebruiken. U kunt een gegevenssjabloon implementeren die WPF kan koppelen aan een object van een bepaald type. De volgende code toont een gegevenssjabloon voor het 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 is de gegevenssjabloon gekoppeld aan het Person type met behulp van de x:Type markeringsextensie in het DataType kenmerk. De gegevenssjabloon verbindt TextBlock vervolgens elementen (zie TextBlock) aan de eigenschappen van de Person klasse. In de volgende afbeelding ziet u het bijgewerkte uiterlijk van het Person object.
Een voordeel van deze techniek is de consistentie die u krijgt door de gegevenssjabloon opnieuw te gebruiken om uw objecten overal in uw toepassing consistent weer te geven.
Zie Overzicht van gegevenssjablonen voor meer informatie over gegevenssjablonen.
Veiligheid
Met WPF-navigatieondersteuning kunnen XBAPs naar internet worden genavigeerd en kunnen toepassingen inhoud van derden hosten. Om zowel toepassingen als gebruikers te beschermen tegen schadelijk gedrag, biedt WPF een verscheidenheid aan beveiligingsfuncties die worden besproken in Beveiliging en WPF Partial Trust Security.
Zie ook
Met ons samenwerken op GitHub
De bron voor deze inhoud vindt u op GitHub, waar u ook problemen en pull-aanvragen kunt maken en controleren. Bekijk onze gids voor inzenders voor meer informatie.
.NET Desktop feedback