Megosztás a következőn keresztül:

Navigáció – áttekintés

A Windows Presentation Foundation (WPF) támogatja a böngészőstílusú navigációt, amely kétféle alkalmazástípusban használható: önálló alkalmazásokban és XAML böngészőalkalmazásokban (XBAP-k). A tartalom navigációhoz való csomagolásához a WPF biztosítja az osztályt Page . Deklaratív módon, a Page segítségével, vagy programozott módon, a Hyperlink segítségével navigálhat az egyik NavigationService-ról a másikra. A WPF a naplóval megjegyzi az oldalakat, ahonnan navigáltak, és ahová vissza lehet navigálni.

Page, Hyperlinkés NavigationServicea napló képezi a WPF által kínált navigációs támogatás magját. Ez az áttekintés részletesen áttekinti ezeket a funkciókat, mielőtt a speciális navigációs támogatást nyújtanák, amely magában foglalja a laza XAML-fájlokra, HTML-fájlokra és objektumokra való navigálást.

Megjegyzés:

Ebben a témakörben a "böngésző" kifejezés csak a WPF-alkalmazásokat üzemeltető böngészőkre vonatkozik, amelyek jelenleg a Microsoft Internet Explorert és a Firefoxot is tartalmazzák. Ha az adott WPF-funkciókat csak egy adott böngésző támogatja, a böngésző verziójára hivatkozik.

Ez a témakör áttekintést nyújt a WPF főbb navigációs képességeiről. Ezek a képességek önálló alkalmazások és XBAP-k számára is elérhetők, bár ez a témakör az XBAP kontextusában mutatja be őket.

Megjegyzés:

Ez a témakör nem ismerteti az XBAP-k létrehozásának és üzembe helyezésének módját. További információ az XBAP-kről: WPF XAML Böngészőalkalmazások áttekintése.

Ez a szakasz a navigáció alábbi aspektusait ismerteti és mutatja be:

Oldal implementálása

A WPF-ben több olyan tartalomtípusra is navigálhat, amelyek tartalmazzák a .NET Framework-objektumokat, az egyéni objektumokat, az enumerálási értékeket, a felhasználói vezérlőket, az XAML-fájlokat és a HTML-fájlokat. A tartalmak csomagolásának leggyakoribb és legkényelmesebb módja azonban a használat Page. Emellett navigációs funkciókat is implementál a Page megjelenésük javítása és a fejlesztés egyszerűsítése érdekében.

A használatával Pagedeklaratív módon implementálhatja az XAML-tartalom egy navigálható oldalát az alábbihoz hasonló korrektúra használatával.

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

Egy Page elemet, amelyet XAML-jelölőben implementálnak, gyökérelemként Page-nak/nak kell megadni, és igényli a WPF XML névtér deklarációját. Az Page elem tartalmazza azokat a tartalmakat, amelyekre navigálni és megjeleníteni szeretne. A Page.Content tulajdonságelem beállításával adhat hozzá tartalmat, ahogyan az az alábbi jelölésben látható.

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

Page.Content csak egy gyermekelemet tartalmazhat; az előző példában a tartalom egyetlen sztring, "Hello, Page!" A gyakorlatban általában egy elrendezésvezérlőt fog használni gyermekelemként (lásd az Elrendezést) a tartalom elhelyezéséhez és megírásához.

Az Page elem gyermekelemei a Page tartalmának minősülnek, ezért nem szükséges a Page.Content explicit deklarációját használni. Az alábbi jelölés az előző minta deklaratív megfelelője.

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

Ebben az esetben Page.Content automatikusan beállításra kerül az Page elem gyermekelemeivel. További információ: WPF-tartalommodell.

A csak jelöléssel rendelkező Page hasznos a tartalom megjelenítésére. Azonban a Page olyan vezérlőket is megjeleníthet, amelyek lehetővé teszik a felhasználók számára, hogy az oldallal interakcióba lépjenek, és reagálhat a felhasználói interakciókra az események kezelésével és az alkalmazáslogika meghívásával. Az interaktív Page egy jelölőnyelv és háttérkód kombinációjának használatával valósítható meg, ahogy az a következő példában látható.

<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

Ahhoz, hogy egy korrektúrafájl és egy kód mögötti fájl működjön együtt, a következő konfiguráció szükséges:

  • A korrektúrában a Page elemnek tartalmaznia kell a x:Class attribútumot. Az alkalmazás létrehozásakor a korrektúrafájlban x:Class megléte miatt a Microsoft buildmotorja (MSBuild) létrehoz egy partial osztályt, amely a Page származik, és a x:Class attribútum által megadott névvel rendelkezik. Ehhez hozzá kell adnunk egy XML-névtér-deklarációt az XAML-sémához (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). A létrehozott partial osztály implementálja InitializeComponent, amelyet arra hívnak, hogy regisztrálja az eseményeket és beállítsa a jelölőnyelvben implementált tulajdonságokat.

  • A mögöttes kódban az osztálynak olyan partial osztálynak kell lennie, amelynek a neve megegyezik a jelölésben megadott x:Class attribútummal, és a Page-ből kell származnia. Ez lehetővé teszi, hogy a kód mögötti fájl az alkalmazás létrehozásakor a korrektúrafájlhoz létrehozott partial osztályhoz legyen társítva (lásd WPF-alkalmazás létrehozása).

  • A kód mögötti Page osztálynak olyan konstruktort kell implementálnia, amely meghívja a InitializeComponent metódust. InitializeComponent-t a jelölési fájl által létrehozott partial osztály implementálja, hogy regisztrálja az eseményeket, és beállítsa a jelölésben definiált tulajdonságokat.

Megjegyzés:

Amikor újat Page ad hozzá a projekthez a Visual Studióval, a Page rendszer a korrektúra és a kód mögötti kód használatával is implementálódik, és tartalmazza a szükséges konfigurációt a korrektúra és a kód mögötti fájlok közötti társítás létrehozásához az itt leírtak szerint.

Ha már rendelkezik ezzel a lehetőségel Page, navigálhat hozzá. Az első Page, amelyhez az alkalmazás navigál, megadásához a kezdőpontot kell konfigurálnia Page.

Kezdőlap konfigurálása

Az XBAP-k használatához bizonyos mennyiségű alkalmazásinfrastruktúra szükséges egy böngészőben. A WPF-ben az Application osztály egy alkalmazásdefiníció része, amely létrehozza a szükséges alkalmazásinfrastruktúrát (lásd : Alkalmazáskezelés áttekintése).

Az alkalmazásdefiníciók általában korrektúra és kód mögötti kód használatával implementálhatók, és a korrektúrafájl MSBuild elemként van konfigurálvaApplicationDefinition . Az alábbiakban egy XBAP alkalmazásdefiníciója található.

<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

Az XBAP az alkalmazásdefiníciójával megadhat egy indítást Page, amely az Page XBAP indításakor automatikusan betöltődik. Ezt úgy teheti meg, hogy a StartupUri tulajdonságot a kívánt Pageerőforrás-azonosítóval (URI) állítja be.

Megjegyzés:

A legtöbb esetben a Page rendszer egy alkalmazásba fordítja vagy telepíti azokat. Ezekben az esetekben az URI, amely azonosít egy Page csomag URI-t, amely egy olyan URI, amely megfelel a csomag sémájának. A csomag URI-jait a WPF-ben található Pack URI-k részletesebben tárgyalják. A http-sémával is navigálhat a tartalomhoz, amelyet az alábbiakban ismertetünk.

Deklaratív módon is megadható StartupUri a korrektúra, ahogy az alábbi példában is látható.

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

Ebben a példában az StartupUri attribútum egy relatív csomag URI-jával van beállítva, amely azonosítja a HomePage.xaml fájlt. Az XBAP indításakor a HomePage.xaml automatikusan navigál és megjelenik. Ezt az alábbi ábra szemlélteti, amely egy webkiszolgálóról indított XBAP-t mutat be.

XBAP-lap

Megjegyzés:

Az XBAP-k fejlesztésével és üzembe helyezésével kapcsolatos további információkért tekintse meg a WPF XAML böngészőalkalmazások áttekintését és a WPF-alkalmazások üzembe helyezését ismertető témakört.

A gazdaablak címének, szélességének és magasságának beállítása

Az egyik dolog, amit észrevett az előző ábrán, hogy mind a böngésző, mind a lap panel címei az XBAP URI-ja. Amellett, hogy hosszú, a cím nem vonzó és nem informatív. Ezért a Page tulajdonság beállításával WindowTitle módot kínál a cím megváltoztatására. Emellett a böngészőablak szélességét és magasságát a WindowWidth és WindowHeight beállításával konfigurálhatja.

WindowTitle, WindowWidth, és WindowHeight deklaratív módon beállítható a jelölésben, ahogyan az alábbi példában is látható.

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

Az eredmény az alábbi ábrán látható.

Ablak címe, magassága, szélessége

Egy tipikus XBAP több oldalból áll. A legegyszerűbb módja annak, hogy az egyik oldalról a másikra navigáljon, az egy Hyperlink használata. Az elem használatával deklaratív módon hozzáadhat egy Hyperlink-t egy Page-hez a Hyperlink elem segítségével, mely az alábbi jelölésben látható.

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

Egy Hyperlink elemhez a következők szükségesek:

  • A Page attribútum által megadott, a navigálási célként megadott csomag URI-ja NavigateUri.

  • A felhasználó által a navigáció elindításához kattintható tartalom, például szöveg és képek (az elem által tartalmazhatott tartalom Hyperlink esetén lásd Hyperlink: ).

Az alábbi ábra mutat egy XBAP Page, amely rendelkezik Hyperlink.

Hivatkozással ellátott lap

Mint ahogy elvárható, a Hyperlink kattintása arra készteti az XBAP-ot, hogy a Page attribútum által azonosított NavigateUri-hoz navigáljon. Emellett az XBAP hozzáad egy bejegyzést az előzőhöz Page az Internet Explorer Legutóbbi lapok listájához. Ez az alábbi ábrán látható.

A Vissza és a Továbbítás gomb

Amellett, hogy támogatja a navigációt egymástól Page a másikig, Hyperlink támogatja a töredezett navigációt is.

Navigáció töredékenként

A töredékalapú navigáció az aktuális Page vagy egy másik Pagetartalomtöredékre való navigálás. A WPF-ben a tartalomrészlet az a tartalom, amelyet egy elnevezett elem tartalmaz. A névvel ellátott elem olyan elem, amelynek attribútumkészlete Name van. Az alábbi korrektúra egy elnevezett TextBlock elemet jelenít meg, amely tartalomtöredéket tartalmaz.

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

Hyperlink Egy tartalomtöredékre való navigáláshoz az NavigateUri attribútumnak tartalmaznia kell a következőket:

  • A Page URI-ja a navigálni kívánt tartalomtöredékhez.

  • Egy "#" karakter.

  • A tartalomtöredéket tartalmazó elem Page neve.

A töredék URI formátuma a következő.

PageURI#Elemnév

Az alábbiakban egy olyan példát Hyperlink mutatunk be, amely egy tartalomtöredékre való navigálásra van konfigurálva.

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

Megjegyzés:

Ez a szakasz a WPF alapértelmezett töredékes navigációs implementációjának leírását ismerteti. A WPF lehetővé teszi a saját töredék navigációs sémájának implementálását is, amely részben az NavigationService.FragmentNavigation esemény kezelését igényli.

Fontos

Csak akkor navigálhat laza XAML-lapokra (csak jelöléses XAML-fájlok, amelyek gyökérelema Page), ha a lapok HTTP-n keresztül böngészhetők.

Egy laza XAML-oldal azonban a saját töredékeihez is navigálhat.

Bár a Hyperlink lehetővé teszi a felhasználó számára, hogy navigálást kezdeményezzen egy adott Page-re, a NavigationService osztály végzi a lap megkeresését és letöltését. Lényegében NavigationService lehetővé teszi egy navigációs kérés feldolgozását az ügyfélkód, mint például a Hyperlink. Emellett NavigationService a navigációs kérések nyomon követésének és befolyásolásának magasabb szintű támogatását is megvalósítja.

Amikor a Hyperlink-ra kattintanak, a WPF meghívja a NavigationService.Navigate-et, hogy megkeresse és letöltse a megadott csomag URI-ját. A letöltött Page fájl olyan objektumfává lesz konvertálva, amelynek gyökérobjektuma a letöltött Pagepéldány. A Page gyökérobjektre mutató hivatkozás a NavigationService.Content tulajdonságban van tárolva. A kívánt tartalom csomag URI-ja a NavigationService.Source tulajdonságban van tárolva, míg a NavigationService.CurrentSource tulajdonság az utolsó oldalra navigált csomag URI-ját tárolja.

Megjegyzés:

Előfordulhat, hogy egy WPF-alkalmazás egynél több aktív NavigationServicealkalmazással rendelkezik. További információ: Navigációs gazdagépek a jelen témakör későbbi részében.

Programozott navigáció a navigációs szolgáltatással

Nem kell tudnia NavigationService, ha a navigációt deklaratív módon, Hyperlink használatával valósítják meg a jelölésben, mert Hyperlink az Ön helyett használja a NavigationService-t. Ez azt jelenti, hogy mindaddig, amíg egy navigációs gazdagép közvetlen vagy közvetett szülője Hyperlink (lásd a navigációs gazdagépeket) Hyperlink megtalálja és használhatja a navigációs gazdagép navigációs szolgáltatását egy navigációs kérés feldolgozásához.

Vannak azonban olyan helyzetek, amikor közvetlenül kell használnia NavigationService , beleértve a következőket:

  • Amikor egy Page példányosítására van szükség nem paraméter nélküli konstruktorral.

  • Ha be kell állítania a tulajdonságokat a Page navigálás előtt.

  • Ha a Page navigálni kívánt elemeket csak futásidőben lehet meghatározni.

Ezekben az esetekben kódokat kell írnia, hogy programozott módon kezdeményezze a navigációt az NavigateNavigationService objektum metódusának meghívásával. Ehhez hivatkozni kell egy NavigationService

Hivatkozás lekérése a NavigationService szolgáltatásra

A Navigációs gazdagépek szakaszban ismertetett okok miatt egy WPF-alkalmazás több NavigationService-al is rendelkezhet. Ez azt jelenti, hogy a kódnak szüksége van egy olyan módszerre NavigationService, amely általában az NavigationService aktuálisra Pagenavigál. A metódus meghívásával NavigationServicestatic hivatkozhat ráNavigationService.GetNavigationService. Ahhoz, hogy megkapja azt a NavigationService-t, amely egy adott Page-hez navigált, adja át a Page-re mutató hivatkozást a GetNavigationService metódus argumentumaként. Az alábbi kód bemutatja, hogyan érheti el az NavigationService a jelenlegi 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)

A NavigationServicePage számára Page megkeresését gyorsító parancsikonként a NavigationService tulajdonság került megvalósításra. Ez az alábbi példában látható.

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

Megjegyzés:

Egy Page csak akkor kaphat hivatkozást a saját NavigationService-ére, ha Page kiváltja a Loaded eseményt.

Programozott navigáció lapobjektumra

Az alábbi példa bemutatja, hogyan lehet programozottan egy NavigationServicePage-re navigálni. Programozott navigációra van szükség, mert a navigált elem csak egy nem paraméter nélküli konstruktor használatával hozható létre. A Page nem paraméter nélküli konstruktor a következő korrektúrában és kódban jelenik meg.

<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

A PagePage nem paramétermentes konstruktorhoz navigáló elemek az alábbi jelölésben és kódban láthatók.

<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

Ha erre HyperlinkPage a gombra kattint, a rendszer elindítja Page a navigációt a nem paraméter nélküli konstruktor használatára való navigáláshoz, és meghívja a metódust NavigationService.Navigate . Navigate A csomag URI-ja helyett egy hivatkozást fogad el arra az objektumra, amelybe a NavigationService program navigál.

Programozott navigáció pack URI-val

Ha programozott módon kell összeállítania egy csomag URI-t (ha például futásidőben csak a csomag URI-ját tudja meghatározni), használhatja a NavigationService.Navigate módszert. Ez az alábbi példában látható.

<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

Az aktuális lap frissítése

A Page nem töltődik le, ha ugyanaz a csomag URI-ja, mint ami a NavigationService.Source tulajdonságban van tárolva. Ha a WPF-et az aktuális lap ismételt letöltésére szeretné kényszeríteni, meghívhatja a NavigationService.Refresh metódust, ahogy az az alábbi példában látható.

<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

A navigációt számos módon kezdeményezheti, ahogy azt már látta. A navigáció indításakor és a navigáció közben a következő események segítségével követheti nyomon és befolyásolhatja a navigációt NavigationService:

  • Navigating. Új navigáció kérése esetén fordul elő. A navigáció megszakításához használható.

  • NavigationProgress. A letöltés során rendszeresen előfordul a navigációs állapot információinak megadása érdekében.

  • Navigated. Akkor fordul elő, ha a lap található és letöltődött.

  • NavigationStopped. Ez akkor fordul elő, ha a navigáció le van állítva (hívással StopLoading), vagy amikor új navigációt kérnek, miközben folyamatban van egy aktuális navigáció.

  • NavigationFailed. Akkor fordul elő, ha hiba merül fel a kért tartalomra való navigálás során.

  • LoadCompleted. Ez akkor fordul elő, ha a navigált tartalmat betöltik és elemzik, és megkezdik a renderelést.

  • FragmentNavigation. A tartalomtöredékre való navigálás kezdetekor következik be, ami a következő:

    • Azonnal, ha a kívánt töredék az aktuális tartalomban található.

    • A forrástartalom betöltése után, ha a kívánt töredék más tartalomban található.

A navigációs események az alábbi ábrán látható sorrendben jelennek meg.

Oldalnavigációs folyamatábra

Általában a Page-t nem érdeklik ezek az események. Valószínűbb, hogy egy alkalmazás foglalkozik velük, és ezért ezeket az eseményeket az Application osztály is felveti:

Minden alkalommal, amikor NavigationService előhoz egy eseményt, az Application osztály a megfelelő eseményt emeli ki. Frame és NavigationWindow ugyanazokat az eseményeket kínálják, hogy észleljék a navigációt a saját hatókörükön belül.

Bizonyos esetekben előfordulhat, hogy a Page érdeklődhet ezek iránt az események iránt. Például egy Page kezelheti a NavigationService.Navigating eseményt annak meghatározására, hogy megszünteti-e a navigációt önmagától. Ez az alábbi példában látható.

<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

Ha egy eseménykezelőt regisztrál egy navigációs eseményhez, Page ahogyan az előző példában is szerepel, akkor az eseménykezelőt is törölnie kell. Ha ezt nem teszi meg, akkor előfordulhatnak mellékhatások a WPF-navigációban, amikor a napló segítségével történik a navigáció.

A navigáció emlékezése a naplóval

A WPF két veremet használ a navigált lapok megjegyzésére: egy visszahívási verem (back stack) és egy előrehaladási verem (forward stack). Amikor az aktuális Page-ról egy új Page-ra vagy egy meglévő Page-re navigál, az aktuális Page hozzáadódik a visszalépési veremhez. Amikor visszanavigál az aktuális Page-ról az előző Page-re, az aktuális Page hozzáadódik a továbbítási veremhez. A back stacket, az előre vermet és az azokat kezelő funkciókat együttesen naplónak nevezzük. A háttérverem és az előre verem minden eleme az JournalEntry osztály egy példánya, amelyet naplóbejegyzésnek neveznek.

A napló elméletileg ugyanúgy működik, mint az Internet Explorer Vissza és Továbbítás gombja. Ezek az alábbi ábrán láthatók.

A Vissza és a Továbbítás gomb

Az Internet Explorer által üzemeltetett XBAP-k esetében a WPF integrálja a naplót az Internet Explorer navigációs felhasználói felületébe. Ez lehetővé teszi, hogy a felhasználók az Internet Explorer Back, Forward és Recent Pages gombjaival navigáljanak az XBAP lapjai között.

Fontos

Az Internet Explorerben, amikor egy felhasználó egy XBAP-ről visszalép, csak az életben nem tartott lapok naplóbejegyzései maradnak meg a naplóban. A lapok életben tartásáról a jelen témakör későbbi részében, a Lap élettartama és a Napló című témakörben olvashat bővebben.

Alapértelmezés szerint az Internet Explorer Page listájában megjelenő minden egyes szöveg a Page URI-ja. Ez sok esetben nem különösen hasznos a felhasználó számára. Szerencsére az alábbi lehetőségek egyikével módosíthatja a szöveget:

  1. A csatolt JournalEntry.Name attribútum értéke.

  2. Az Page.Title attribútum értéke.

  3. Az Page.WindowTitle aktuális Pageattribútum értéke és URI-ja.

  4. Az aktuális Page URI. (Alapértelmezett)

A beállítások felsorolási sorrendje megegyezik a szöveg megkeresésének sorrendjében megadott sorrenddel. Ha például JournalEntry.Name be van állítva, a többi érték figyelmen kívül lesz hagyva.

Az alábbi példa az Page.Title attribútum használatával módosítja a naplóbejegyzéshez megjelenő szöveget.

<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

Bár a felhasználó az Internet Explorer Vissza, Előre és Legutóbbi lapjaival navigálhat a naplóban, a WPF által biztosított deklaratív és programozott mechanizmusok használatával is navigálhat a naplóban. Ennek egyik oka, hogy egyéni navigációs felhasználói felületeket biztosít a lapokban.

Deklaratív módon hozzáadhat naplónavigációs támogatást a közzétett navigációs parancsok NavigationCommandshasználatával. Az alábbi példa bemutatja, hogyan használhatja a BrowseBack navigációs parancsot.

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

Programozott módon navigálhat a naplóban az osztály alábbi tagjainak egyikével NavigationService :

A napló programozott módon is módosítható, ahogy azt a jelen témakör későbbi, Tartalomállapot megőrzése navigációs előzményekkel című szakaszában is ismertetjük.

Az oldal élettartama és a napló

Fontolja meg az XBAP-t több olyan oldallal, amelyek gazdag tartalmat tartalmaznak, beleértve a grafikus elemeket, animációkat és médiatartalmakat. Az ilyen oldalak memóriaigénye meglehetősen nagy lehet, különösen akkor, ha video- és hanganyagokat használnak. Mivel a napló "megjegyzi" azokat az oldalakat, amelyekre navigáltak, egy ilyen XBAP gyorsan nagy és észrevehető mennyiségű memóriát képes felhasználni.

Ezért a napló alapértelmezett viselkedése az, hogy a metaadatokat az egyes naplóbejegyzésekben tárolja Page , nem pedig egy Page objektumra mutató hivatkozást. Amikor egy naplóbejegyzésre navigálnak, annak Page metaadatait használják a megadott Page új példányának létrehozásához. Ennek következtében minden navigált Page elem élettartamát az alábbi ábra szemlélteti.

Lap élettartama

Bár az alapértelmezett naplózási viselkedés csökkentheti a memóriahasználatot, az oldalonkénti renderelési teljesítmény csökkenhet, ha egy Page újrainstanciálása időigényes, különösen akkor, ha sok tartalom van benne. Ha meg kell őriznie egy példányt Page a naplóban, ehhez két módszert használhat. Először a metódus meghívásával programozott módon navigálhat egy Page objektumra NavigationService.Navigate .

Másodszor megadhatja, hogy a WPF megtartsa egy Page példányt a naplóban a tulajdonság KeepAlive beállításával true (az alapértelmezett értékfalse). Az alábbi példában látható módon deklaratív módon állíthatja be a KeepAlive jelölésében.

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

Az életben tartott Page élettartama némileg eltér attól, amelyet nem tartanak életben. Az első alkalommal, amikor egy életben tartott Page navigálásra kerül sor, pontosan úgy kerül példányosításra, mint egy Page, amelyet nem tartanak életben. Azonban mivel a Page példánya megmarad a naplóban, soha nem lesz újra példányosítva, amíg a naplóban marad. Ha egy Page inicializálási logikát minden alkalommal meg kell hívni, amikor a Page-re navigál, át kell helyeznie azt a konstruktorból az Loaded esemény kezelőjébe. Az alábbi ábrán látható módon a Loaded és Unloaded események mindig előjönnek, amikor a Page-hez navigálunk, illetve onnan visszatérünk.

Amikor a betöltött és a kipakolt eseményeket emeli ki

Ha nem tartja életben a Page, ne tegye meg a következőket:

  • Tároljon rá mutató hivatkozást vagy annak bármely részét.

  • Eseménykezelők regisztrálása az általa nem implementált eseményekre.

Ezeknek bármelyikének elvégzése olyan hivatkozásokat hoz létre, amelyek arra kényszerítik, hogy a Page megmaradjon a memóriában, miután eltávolították a naplóból.

Általában előnyben kell részesítenie az alapértelmezett Page viselkedést, amely nem tartja életben a Page-t. Ennek azonban vannak olyan állapotkövetkezményei, amelyeket a következő szakaszban tárgyalunk.

Tartalomállapot megőrzése navigációs előzményekkel

Ha a Page nem marad életben, és olyan vezérlőket tartalmaz, amelyek adatokat gyűjtenek a felhasználótól, mi történik az adatokkal, ha a felhasználó elnavigál a Page-ről és visszatér oda? Felhasználói élmény szempontjából a felhasználónak látnia kell a korábban megadott adatokat. Sajnos, mivel minden Page egyes navigációhoz létrejön egy új példány, az adatokat gyűjtő vezérlők újraindulnak, és az adatok elvesznek.

Szerencsére a napló segít megjegyezni az adatokat a navigációk között, beleértve a vezérlőadatokat is. Az egyes Page naplóbejegyzések a társított Page állapot ideiglenes tárolójaként szolgálnak. Az alábbi lépések ismertetik, hogyan használható ez a támogatás, amikor a Page-ról navigálnak.

  1. Az aktuális Page bejegyzés hozzáadódik a naplóhoz.

  2. A rendszer a lap naplóbejegyzésével tárolja az Page állapotot, amelyet a rendszer hozzáad a hátsó veremhez.

  3. A rendszer az új Page-ra navigál.

Amikor a lap Page vissza van léptetve a naplóval, a következő lépések történnek:

  1. A Page (a hátsó verem felső naplóbejegyzése) példányosítva lesz.

  2. A Page rendszer a naplóbejegyzéssel együtt tárolt állapottal frissül.Page

  3. A Page visszanavigálás történik.

A WPF automatikusan ezt a támogatást használja, ha a következő vezérlők vannak használatban egy Page esetén:

Ha egy Page vezérlőt használ, a beírt adatok a navigációs sávokon is Page meg lesznek jegyezve, ahogy azt az alábbi ábrán látható Kedvenc színListBox is mutatja.

állapotot visszaemlékeztető vezérlőket tartalmazó lapA beírt

Ha egy Page vezérlő eltér az előző listában szereplőktől, vagy ha az állapot egyéni objektumokban van tárolva, akkor olyan kódot kell írnia, amely lehetővé teszi, hogy a naplózási rendszer megjegyezze az állapotot a Page navigációk során.

Ha különböző navigációk között meg kell jegyeznie kis információrészeket, használhatja a metaadat jelzővel Page konfigurált függőségi tulajdonságokat (lásd DependencyProperty).

Ha az az állapot, amelyet Page a navigációk között meg kell jegyeznie, több adatból áll, akkor kevesebb kódra lehet szükség az állapot egyetlen osztályba való beágyazásához és a IProvideCustomContentState felület implementálásához.

Ha egyetlen Page különböző állapotai között kell navigálnia anélkül, hogy kilépne a Page-ből, használhatja a IProvideCustomContentState és NavigationService.AddBackEntry.

Sütik

A WPF-alkalmazások az adatok tárolásának egy másik módja a cookie-k, amelyeket a rendszer létrehoz, frissít és töröl a SetCookieGetCookie módszerekkel. A WPF-ben létrehozható cookie-k ugyanazok a cookie-k, amelyeket más típusú webalkalmazások használnak; A cookie-k tetszőleges adatrészletek, amelyeket egy alkalmazás tárol egy ügyfélszámítógépen az alkalmazás munkamenetei során vagy azok során. A cookie-adatok általában név/érték pár formájában, az alábbi formátumban kerülnek megjelenítésre.

Név=Érték

Amikor az adatok továbbítása SetCookietörténik , valamint annak a Uri helynek, amelyre a cookie-t be kell állítani, létrejön egy cookie a memóriában, és csak az aktuális alkalmazás munkamenetének időtartama alatt érhető el. Ezt a cookie-t munkamenet cookie-nak nevezzük.

A cookie-k alkalmazás-munkamenetek közötti tárolásához hozzá kell adni a cookie lejárati dátumát az alábbi formátum használatával.

NÉV=ÉRTÉK; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

A lejárati dátummal rendelkező cookie-kat a rendszer az aktuális Windows-telepítés Ideiglenes internetfájlok mappájában tárolja, amíg a cookie lejár. Az ilyen cookie-k állandó cookie-ként ismertek, mert az alkalmazás-munkamenetek során is megmarad.

A munkamenet és az állandó cookie-k lekéréséhez hívja meg a GetCookie metódust, és adja meg annak a Uri helynek a helyét, ahol a cookie be lett állítva a SetCookie módszerrel.

Az alábbiakban bemutatjuk, hogyan támogatják a cookie-kat a WPF- ben:

  • A WPF önálló alkalmazásai és az XBAP-k egyaránt létrehozhatnak és kezelhetnek cookie-kat.

  • Az XBAP által létrehozott cookie-k a böngészőből érhetők el.

  • Az egyazon tartományból származó XBAP-k cookie-kat hozhatnak létre és oszthatnak meg.

  • Az egyazon tartományból származó XBAP-k és HTML-oldalak cookie-kat hozhatnak létre és oszthatnak meg.

  • A cookie-k akkor lesznek elküldve, amikor az XBAP-k és a laza XAML-oldalak webes kéréseket küldenek.

  • Az IFRAMES-ben üzemeltetett legfelső szintű XBAP-k és XBAP-k egyaránt hozzáférhetnek a cookie-khoz.

  • A COOKIE-k támogatása a WPF-ben minden támogatott böngésző esetében ugyanaz.

  • Az Internet Explorerben a cookie-kra vonatkozó P3P-szabályzatot a WPF betartja, különösen az első és harmadik féltől származó XBAP-k tekintetében.

Strukturált navigáció

Ha adatokat kell átadnia egyik Page-ról a másikra, argumentumként továbbíthatja az adatokat a nem paraméter nélküli konstruktorának.Page Vegye figyelembe, hogy ha ezt a technikát használja, életben kell tartania a Page-t; ha nem, akkor a következő alkalommal, amikor a Page-re navigál, a WPF a Page-t a paraméter nélküli konstruktor használatával újra példányosítja.

Másik lehetőségként olyan tulajdonságokat is implementálhat, Page amelyek a továbbítandó adatokkal vannak beállítva. A dolgok azonban nehézkessé válnak, amikor egy Page-nak adatokat kell visszajuttatnia annak a Page-nak, amelyik hozzá navigált. A probléma az, hogy a navigáció nem támogatja natívan azokat a mechanizmusokat, amelyek garantálják, hogy a Page-ra visszatérünk, miután navigáltunk onnan. A navigáció lényegében nem támogatja a hívás-vissza szemantikát. A probléma megoldásához a WPF biztosítja a PageFunction<T> osztályt, amellyel biztosítani lehet, hogy a Page kiszámítható és strukturált módon legyen visszajuttatva. További információ: Strukturált navigáció – áttekintés.

A NavigationWindow osztály

Eddig a pontig láthatta a navigációs szolgáltatások azon skáláját, amelyet nagy valószínűséggel használhat navigálásra alkalmas tartalommal rendelkező alkalmazások létrehozásához. Ezeket a szolgáltatásokat az XBAP-k kontextusában vitatták meg, bár ezek nem korlátozódnak az XBAP-kre. A modern operációs rendszerek és Windows-alkalmazások kihasználják a modern felhasználók böngészőélményét, hogy böngészőstílusú navigációt építsenek be önálló alkalmazásokba. Néhány általános példa:

  • Szószótár: Navigálás a szóválasztásban.

  • Fájlkezelő: Navigálás fájlokban és mappákban.

  • Varázslók: Összetett feladat több lapra bontása, amelyek között navigálhat. Ilyen például a Windows-összetevők varázsló, amely kezeli a Windows-szolgáltatások hozzáadását és eltávolítását.

Ha böngészőstílusú navigációt szeretne beépíteni az önálló alkalmazásokba, használhatja az osztályt NavigationWindow . NavigationWindow a Window-ból származik, és ugyanazzal a navigációs támogatással terjeszti ki, amit az XBAP-ek biztosítanak. NavigationWindow Használhatja önálló alkalmazás főablakaként vagy másodlagos ablakként, például párbeszédpanelként.

NavigationWindow A legtöbb legfelső szintű osztály megvalósításához a WPF-ben (Window, Page stb.) a jelölőnyelv és a kód-behind kombinációját használja. Ez az alábbi példában látható.

<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

Ez a kód létrehoz egy NavigationWindow, amely megnyitáskor automatikusan a Page (HomePage.xaml) lapra navigál. Ha ez NavigationWindow a fő alkalmazásablak, az StartupUri attribútummal indíthatja el. Ez az alábbi jelölésekben jelenik meg.

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

Az alábbi ábrán egy NavigationWindow önálló alkalmazás főablaka látható.

Főablak

Az ábrán látható, hogy a NavigationWindow címmel rendelkezik, annak ellenére, hogy az előző példa implementációs kódjában NavigationWindow nem volt beállítva. Ehelyett a cím a WindowTitle tulajdonság használatával van beállítva, amely az alábbi kódban látható.

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

</Page>

A WindowWidth és WindowHeight tulajdonságok beállítása hatással van a NavigationWindow-re is.

Általában akkor valósítja meg a sajátját NavigationWindow , ha testre kell szabnia a viselkedését vagy megjelenését. Ha egyiket sem teszi meg, használhat egy parancsikont. Ha egy különálló alkalmazásban a Page csomag URI-ját adja meg, a StartupUri automatikusan létrehoz egy Application-t a NavigationWindow fogadására. Az alábbi jelölés mutatja, hogyan engedélyezheti ezt.

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

Ha azt szeretné, hogy egy másodlagos alkalmazásablak, például egy párbeszédpanel legyen NavigationWindow, az alábbi példában szereplő kóddal nyithatja meg.

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

Az alábbi ábrán az eredmény látható.

Párbeszédpanel

Mint látható, az Internet Explorer-stílusú NavigationWindow és továbbítás gombokat jeleníti meg, amelyek lehetővé teszik a felhasználók számára a naplóban való navigálást. Ezek a gombok ugyanazt a felhasználói élményt biztosítják, mint az alábbi ábrán látható.

Vissza és Előre gombok a NavigationWindow navigációs ablakban

Ha a lapok saját navigációs támogatást és felhasználói felületet (UI) biztosítanak, a tulajdonság értékét -re állítva elrejtheti a NavigationWindow és ShowsNavigationUI gombokat.

Alternatív megoldásként a WPF testreszabási támogatását használhatja a NavigationWindow felhasználói felületének lecserélésére.

A keretosztály

Mind a böngésző, mind pedig a NavigationWindow olyan ablakok, amelyek navigálható tartalmakat tartalmaznak. Bizonyos esetekben az alkalmazások olyan tartalommal rendelkeznek, amelyet nem kell teljes ablakban üzemeltetni. Ehelyett az ilyen tartalmakat más tartalmakon belül kell üzemeltetni. A Frame osztály használatával navigálható tartalmat illeszthet be más tartalmakba. Frame ugyanazt a támogatást nyújtja, mint NavigationWindow az XBAP-k.

Az alábbi példa bemutatja, hogyan lehet deklaratív módon hozzáadni egy Frame a Page-hez az Frame elem használatával.

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

Ez a jelölés a Source elem Frame attribútumát egy pack URI-val állítja be ahhoz a Page csomaghoz, amelyhez a Frame kezdetben navigálnia kell. Az alábbi ábrán egy XBAP látható Page amely Frame több oldal között navigál.

Több oldal között navigáló keret

Nem csak a Frame tartalmában kell használnia a Page-t. Az is gyakori, hogy egy Frame-t belül a Window tartalmán helyeznek el.

Alapértelmezés szerint Frame csak a saját naplóját használja egy másik napló hiányában. Ha egy Frame a tartalom része, amelyet egy NavigationWindow vagy Frame vagy XBAP-ben üzemeltetnek, akkor NavigationWindow a Frame vagy az XBAP-hez tartozó naplót használja. Néha azonban előfordulhat, hogy egy Frame saját naplóért kell felelősnek lennie. Ennek egyik oka, hogy engedélyezi a naplónavigációt az adott Framelap által üzemeltetett oldalakon. Ezt az alábbi ábra szemlélteti.

Keret- és lapdiagram

Ebben az esetben konfigurálhatja a Frame-t úgy, hogy a JournalOwnership tulajdonságát Frame értékre állítja, így a saját naplóját használja. Ez az alábbi jelölésekben jelenik meg.

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

Az alábbi ábra azt szemlélteti, milyen hatással van a Frame-n belüli navigálás, aminek saját naplója van.

Saját naplót használó keret

Figyelje meg, hogy a naplóbejegyzéseket az Internet Explorer helyett a Framenavigációs felhasználói felület jeleníti meg.

Megjegyzés:

Ha egy Frame részét képezi egy tartalomnak, amely Window-ban található, akkor a Frame saját naplót használ, és ennek eredményeképpen megjeleníti a saját navigációs felhasználói felületét.

Ha a felhasználói élményhez szükséges, hogy saját naplót Frame biztosítson a navigációs felhasználói felület megjelenítése nélkül, elrejtheti a navigációs felhasználói felületet úgy, hogy a NavigationUIVisibilityHidden értékre állítja. Ez az alábbi jelölésekben jelenik meg.

<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 és NavigationWindow azok az osztályok, amelyeket navigációs gazdagépként ismerünk. A navigációs vezérlő egy olyan osztály, amely navigálni és megjeleníteni tudja a tartalmat. Ehhez minden navigációs gazdagép saját NavigationService-ot és naplót használ. A navigációs eszköz alapfelépítése az alábbi ábrán látható.

Navigátordiagramok

Ez lényegében lehetővé teszi, hogy NavigationWindow és Frame ugyanazt a navigációs támogatást biztosítsák, amelyet az XBAP nyújt a böngészőben való üzemeltetéskor.

A NavigationService és napló használatán kívül a navigációs gazdagépek ugyanazokat a tagokat implementálják, mint NavigationService. Ezt az alábbi ábra szemlélteti.

Napló egy keretben és egy navigációs ablakban

Ez lehetővé teszi, hogy közvetlenül ellenük programozza a navigációs támogatást. Ezt akkor érdemes megfontolnia, ha egyéni navigációs felhasználói felületet kell biztosítania egy Frame részére, amelyet egy Window adott helyen üzemeltetnek. Emellett mindkét típus további, navigációval kapcsolatos tagokat is implementál, beleértve BackStack (NavigationWindow.BackStack, Frame.BackStack) és ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), amelyek lehetővé teszik a naplóbejegyzések számbavételét a visszafelé veremben és az előre veremben.

Ahogy korábban említettük, egy alkalmazáson belül több napló is létezhet. Az alábbi ábra egy példát mutat be arra, hogy ez mikor fordulhat elő.

Több napló egy alkalmazásban

Navigálás az XAML-oldalaktól eltérő tartalomra

Ebben a témakörben a Page és a XBAP-okat használták a WPF különböző navigációs képességeinek bemutatására. Page Az alkalmazásba lefordított tartalom azonban nem az egyetlen olyan tartalomtípus, amelybe navigálhat, és az XBAP-k csomagolása nem az egyetlen módja a tartalom azonosításának.

Ahogy ez a szakasz is mutatja, a laza XAML-fájlokhoz, HTML-fájlokhoz és objektumokhoz is navigálhat.

A laza XAML-fájlok az alábbi jellemzőkkel rendelkező fájlok:

  • Csak XAML-t tartalmaz (azaz nem tartalmaz kódot).

  • Rendelkezik egy megfelelő névtér-deklarációval.

  • .xaml fájlnévkiterjesztéssel rendelkezik.

Vegyük például a következő tartalmat, amelyet laza XAML-fájlként, Person.xaml-fájlként tárolunk.

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

Amikor duplán kattint a fájlra, a böngésző megnyílik, és megnyitja és megjeleníti a tartalmat. Ez az alábbi ábrán látható.

A Person.XAML fájl tartalmának megjelenítése

Egy laza XAML-fájlt az alábbiakból jeleníthet meg:

  • Webhely a helyi gépen, az intraneten vagy az interneten.

  • Univerzális elnevezési konvenció (UNC) fájlmegosztás.

  • A helyi lemez.

Egy laza XAML-fájl hozzáadható a böngésző kedvenceihez, vagy lehet a böngésző kezdőlapja.

Megjegyzés:

További információ a laza XAML-lapok közzétételéről és elindításáról: WPF-alkalmazás üzembe helyezése.

A laza XAML egyik korlátozása, hogy csak olyan tartalmakat üzemeltethet, amelyek biztonságosan futtathatók részleges megbízhatósággal. Nem lehet például Window egy laza XAML-fájl gyökéreleme. További információ: WPF részleges biztonsági megbízhatóság.

Ahogy várható, a HTML-fájlra is navigálhat. Egyszerűen meg kell adnia egy URI-t, amely a HTTP-sémát használja. Az alábbi XAML például egy Frame HTML-lapra navigál.

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

A HTML-hez való navigáláshoz speciális engedélyekre van szükség. Nem navigálhat például olyan XBAP-ről, amely az internetzónában futó részleges megbízhatósági biztonsági tesztkörnyezetben fut. További információ: WPF részleges biztonsági megbízhatóság.

A WebBrowser vezérlő támogatja a HTML-dokumentumok üzemeltetését, a navigációt és a szkript/felügyelt kód együttműködési képességét. A vezérlővel kapcsolatos részletes információkért WebBrowser lásd: WebBrowser.

Például Framea HTML-hez WebBrowser való navigáláshoz speciális engedélyekre van szükség. Egy részleges megbízhatósági alkalmazásból például csak a forráshelyen található HTML-fájlra navigálhat. További információ: WPF részleges biztonsági megbízhatóság.

Ha egyéni objektumként tárolt adatokkal rendelkezik, az adatok megjelenítésének egyik módja egy Page olyan tartalom létrehozása, amely ezekhez az objektumokhoz van kötve (lásd : Adatkötés áttekintése). Ha nincs szüksége arra, hogy csak az objektumok megjelenítéséhez hozzon létre egy teljes lapot, közvetlenül hozzájuk navigálhat.

Vegye figyelembe az Person alábbi kódban implementált osztályt.

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

Az ehhez való navigáláshoz hívja meg a NavigationWindow.Navigate metódust, ahogy azt az alábbi kód is mutatja.

<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

Az alábbi ábrán az eredmény látható.

Egy osztályba navigáló lap

Ebből az ábrából láthatja, hogy semmi hasznos nem jelenik meg. A megjelenített érték valójában a ToString objektum metódusának visszatérési értéke; alapértelmezés szerint ez az egyetlen érték, amelyet a WPF használhat az objektum megjelenítéséhez. Felülbírálhatja a ToString metódust, hogy értelmesebb információkat adjon vissza, bár az továbbra is csak egy sztring érték lesz. A WPF megjelenítési képességeinek előnyeit kihasználó egyik technika egy adatsablon használata. Implementálhat egy adatsablont, amelyet a WPF egy adott típusú objektumhoz társíthat. Az alábbi kód egy adatsablont jelenít meg az Person objektumhoz.

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

Itt az adatsablon az Person jelölés kiterjesztésével van összekapcsolva a x:Type attribútummal a DataType típushoz. Az adatsablon ezután az elemeket (lásdTextBlock) az osztály tulajdonságaihoz köti TextBlockPerson. Az alábbi ábra az objektum frissített megjelenését Person mutatja.

Navigálás olyan osztályra, amely adatsablonnal rendelkezik, és

Ennek a technikának az előnye az a konzisztencia, amelyet azzal nyerhet, hogy újra felhasználhatja az adatsablont az objektumok egységes megjelenítéséhez az alkalmazásban bárhol.

Az adatsablonokról további információt a Data Templating áttekintésében talál.

Biztonság

A WPF navigációs támogatása lehetővé teszi az XBAP-k internetes navigálását, és lehetővé teszi az alkalmazások számára, hogy külső tartalmakat tároljanak. Az alkalmazások és a felhasználók káros viselkedés elleni védelme érdekében a WPF számos biztonsági funkciót biztosít, amelyekről a Biztonság és a WPF Részleges megbízhatósági biztonság című témakörben van szó.

Lásd még

  • Last updated on