Cenni preliminari sulla navigazioneNavigation Overview

Windows Presentation Foundation (WPF) supporta la navigazione in stile browser che può essere usata in due tipi di applicazioni: applicazioni autonome e applicazioni browser XAML (XBAPs).Windows Presentation Foundation (WPF) supports browser-style navigation that can be used in two types of applications: standalone applications and XAML browser applications (XBAPs). Per creare un pacchetto di contenuto per la navigazione, WPF fornisce la classe Page.To package content for navigation, WPF provides the Page class. È possibile passare da una Page a un'altra in modo dichiarativo, usando un Hyperlink, o a livello di codice, usando il NavigationService.You can navigate from one Page to another declaratively, by using a Hyperlink, or programmatically, by using the NavigationService. WPF usa il Journal per ricordare le pagine che sono state spostate da e per tornare a esse.WPF uses the journal to remember pages that have been navigated from and to navigate back to them.

Page, Hyperlink, NavigationServicee il journal costituiscono il nucleo del supporto per la navigazione offerto da WPF.Page, Hyperlink, NavigationService, and the journal form the core of the navigation support offered by WPF. In questa panoramica vengono esaminate in dettaglio queste funzionalità prima di coprire il supporto per la navigazione avanzata che include la navigazione per Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) file separati, file HTML e oggetti.This overview explores these features in detail before covering advanced navigation support that includes navigation to loose Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) files, HTML files, and objects.

Nota

In questo argomento, il termine "browser" si riferisce solo ai browser che possono ospitare applicazioni WPF, che attualmente includono Microsoft Internet Explorer e Firefox.In this topic, the term "browser" refers only to browsers that can host WPF applications, which currently includes Microsoft Internet Explorer and Firefox. Quando specifiche funzionalità WPF sono supportate solo da un browser specifico, viene fatto riferimento alla versione del browser.Where specific WPF features are supported only by a particular browser, the browser version is referred to.

In questo argomento viene fornita una panoramica delle principali funzionalità di esplorazione di WPF.This topic provides an overview of the key navigation capabilities in WPF. Queste funzionalità sono disponibili sia per applicazioni autonome che per XBAP, sebbene in questo argomento vengano presentate nel contesto di un'applicazione XBAP.These capabilities are available to both standalone applications and XBAPs, although this topic presents them within the context of an XBAP.

Nota

In questo argomento non viene illustrato come compilare e distribuire le applicazioni XBAP.This topic doesn't discuss how to build and deploy XBAPs. Per ulteriori informazioni sulle applicazioni XBAP, vedere Cenni preliminari sulle applicazioni browser XAML WPF.For more information on XBAPs, see WPF XAML Browser Applications Overview.

In questa sezione vengono illustrati gli aspetti seguenti della navigazione:This section explains and demonstrates the following aspects of navigation:

Implementazione di una paginaImplementing a Page

In WPF è possibile spostarsi tra diversi tipi di contenuto che includono .NET Framework oggetti, oggetti personalizzati, valori di enumerazione, controlli utente, file di XAMLXAML e file HTML.In WPF, you can navigate to several content types that include .NET Framework objects, custom objects, enumeration values, user controls, XAMLXAML files, and HTML files. Tuttavia, si noterà che il modo più comune e pratico per creare pacchetti di contenuto consiste nell'usare Page.However, you'll find that the most common and convenient way to package content is by using Page. Inoltre, Page implementa funzionalità specifiche della navigazione per migliorarne l'aspetto e semplificare lo sviluppo.Furthermore, Page implements navigation-specific features to enhance their appearance and simplify development.

Utilizzando Page, è possibile implementare in modo dichiarativo una pagina navigabile di XAMLXAML contenuto utilizzando markup analogo al seguente.Using Page, you can declaratively implement a navigable page of XAMLXAML content by using markup like the following.

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

Un Page implementato in XAMLXAML markup ha Page come elemento radice e richiede la dichiarazione dello spazio dei nomi XML WPF.A Page that is implemented in XAMLXAML markup has Page as its root element and requires the WPF XML namespace declaration. L'elemento Page contiene il contenuto che si desidera esplorare e visualizzare.The Page element contains the content that you want to navigate to and display. Per aggiungere contenuto, impostare l'elemento Property Page.Content, come illustrato nel markup seguente.You add content by setting the Page.Content property element, as shown in the following markup.

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

Page.Content può contenere soltanto un elemento figlio. Nell'esempio precedente, il contenuto è una sola stringa, "Hello, Page!".Page.Content can only contain one child element; in the preceding example, the content is a single string, "Hello, Page!" In pratica, si userà in genere un controllo di layout come elemento figlio (vedere il layout) per contenere e comporre il contenuto.In practice, you will usually use a layout control as the child element (see Layout) to contain and compose your content.

Gli elementi figlio di un elemento Page sono considerati il contenuto di un Page e, di conseguenza, non è necessario utilizzare la dichiarazione esplicita di Page.Content.The child elements of a Page element are considered to be the content of a Page and, consequently, you don't need to use the explicit Page.Content declaration. Il markup seguente è l'equivalente dichiarativo dell'esempio precedente.The following markup is the declarative equivalent to the preceding sample.

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

In questo caso, Page.Content viene impostato automaticamente con gli elementi figlio dell'elemento Page.In this case, Page.Content is automatically set with the child elements of the Page element. Per altre informazioni, vedere Modello di contenuto WPF.For more information, see WPF Content Model.

Un Page di solo markup è utile per la visualizzazione del contenuto.A markup-only Page is useful for displaying content. Tuttavia, un Page può anche visualizzare controlli che consentono agli utenti di interagire con la pagina e possono rispondere all'interazione dell'utente gestendo gli eventi e chiamando la logica dell'applicazione.However, a Page can also display controls that allow users to interact with the page, and it can respond to user interaction by handling events and calling application logic. Un Page interattivo viene implementato utilizzando una combinazione di markup e code-behind, come illustrato nell'esempio seguente.An interactive Page is implemented by using a combination of markup and code-behind, as shown in the following example.

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

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

Imports System.Windows.Controls

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

Per consentire il funzionamento congiunto di un file di markup e di un file code-behind, è necessaria la configurazione seguente:To allow a markup file and code-behind file to work together, the following configuration is required:

  • Nel markup, l'elemento Page deve includere l'attributo x:Class.In markup, the Page element must include the x:Class attribute. Quando viene compilata l'applicazione, l'esistenza di x:Class nel file di markup fa sì che Microsoft Build Engine (MSBuild) crei una classe partial che deriva da Page e ha il nome specificato dall'attributo x:Class.When the application is built, the existence of x:Class in the markup file causes Microsoft build engine (MSBuild) to create a partial class that derives from Page and has the name that is specified by the x:Class attribute. Questa operazione richiede l'aggiunta di una dichiarazione dello spazio dei nomi XML per lo schema di XAMLXAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").This requires the addition of an XML namespace declaration for the XAMLXAML schema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). La classe partial generata implementa InitializeComponent, che viene chiamata per registrare gli eventi e impostare le proprietà implementate nel markup.The generated partial class implements InitializeComponent, which is called to register the events and set the properties that are implemented in markup.

  • Nel code-behind la classe deve essere una classe partial con lo stesso nome specificato dall'attributo x:Class nel markup e deve derivare da Page.In code-behind, the class must be a partial class with the same name that is specified by the x:Class attribute in markup, and it must derive from Page. Ciò consente di associare il file code-behind alla classe partial generata per il file di markup quando viene compilata l'applicazione (vedere compilazione di un'applicazione WPF).This allows the code-behind file to be associated with the partial class that is generated for the markup file when the application is built (see Building a WPF Application).

  • Nel code-behind la classe Page deve implementare un costruttore che chiama il metodo InitializeComponent.In code-behind, the Page class must implement a constructor that calls the InitializeComponent method. InitializeComponent viene implementato dalla classe partial generata del file di markup per registrare gli eventi e impostare le proprietà definite nel markup.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Nota

Quando si aggiunge un nuovo Page al progetto usando Visual Studio, il Page viene implementato usando markup e code-behind e include la configurazione necessaria per creare l'associazione tra i file di markup e code-behind, come descritto qui.When you add a new Page to your project using Visual Studio, the Page is implemented using both markup and code-behind, and it includes the necessary configuration to create the association between the markup and code-behind files as described here.

Quando si dispone di un Page, è possibile accedervi.Once you have a Page, you can navigate to it. Per specificare la prima Page a cui viene spostata un'applicazione, è necessario configurare il Pagedi avvio.To specify the first Page that an application navigates to, you need to configure the start Page.

Configurazione di una pagina inizialeConfiguring a Start Page

Le applicazioni XBAP richiedono una certa quantità di infrastruttura dell'applicazione da ospitare in un browser.XBAPs require a certain amount of application infrastructure to be hosted in a browser. In WPF, la classe Application fa parte di una definizione di applicazione che stabilisce l'infrastruttura dell'applicazione necessaria (vedere Cenni preliminari sulla gestione di applicazioni).In WPF, the Application class is part of an application definition that establishes the required application infrastructure (see Application Management Overview).

La definizione di un'applicazione viene in genere implementata tramite markup e code-behind, con il file di markup configurato come elemento MSBuildApplicationDefinition.An application definition is usually implemented using both markup and code-behind, with the markup file configured as an MSBuildApplicationDefinition item. Di seguito è riportata una definizione di applicazione per un'applicazione XBAP.The following is an application definition for an XBAP.

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

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

Imports System.Windows

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

Un'applicazione XBAP può utilizzare la definizione dell'applicazione per specificare un Pagedi inizio, ovvero la Page che viene caricata automaticamente al momento dell'avvio dell'applicazione XBAP.An XBAP can use its application definition to specify a start Page, which is the Page that is automatically loaded when the XBAP is launched. A tale scopo, impostare la proprietà StartupUri con l'URI (Uniform Resource Identifier) per la Pagedesiderata.You do this by setting the StartupUri property with the uniform resource identifier (URI) for the desired Page.

Nota

Nella maggior parte dei casi, la Page viene compilata o distribuita con un'applicazione.In most cases, the Page is either compiled into or deployed with an application. In questi casi, l'URI che identifica un Page è un URI di tipo pack, ovvero un URI conforme allo schema di tipo Pack .In these cases, the URI that identifies a Page is a pack URI, which is a URI that conforms to the pack scheme. Gli URI di pacchetto sono descritti ulteriormente in URI di Pack in WPF.Pack URIs are discussed further in Pack URIs in WPF. Per passare a contenuto specifico è anche possibile usare lo schema HTTP, illustrato più avanti.You can also navigate to content using the http scheme, which is discussed below.

È possibile impostare StartupUri in modo dichiarativo nel markup, come illustrato nell'esempio seguente.You can set StartupUri declaratively in markup, as shown in the following example.

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

In questo esempio, l'attributo StartupUri viene impostato con un URI di pacchetto relativo che identifica HomePage. XAML.In this example, the StartupUri attribute is set with a relative pack URI that identifies HomePage.xaml. Quando si avvia l'applicazione XBAP, HomePage. XAML viene automaticamente navigato e visualizzato.When the XBAP is launched, HomePage.xaml is automatically navigated to and displayed. Questa operazione viene illustrata nella figura seguente, che mostra un'applicazione XBAP avviata da un server Web.This is demonstrated by the following figure, which shows an XBAP that was launched from a Web server.

Pagina XBAPXBAP page

Nota

Per ulteriori informazioni sullo sviluppo e sulla distribuzione di applicazioni XBAP, vedere Cenni preliminari sulle applicazioni browser XAML WPF e distribuzione di un'applicazione WPF.For more information regarding the development and deployment of XBAPs, see WPF XAML Browser Applications Overview and Deploying a WPF Application.

Configurazione del titolo, della larghezza e dell'altezza della finestra hostConfiguring the Host Window's Title, Width, and Height

Una cosa che si può notare dalla figura precedente è che il titolo sia del browser che del pannello scheda è l'URI per l'applicazione XBAP.One thing you may have noticed from the previous figure is that the title of both the browser and the tab panel is the URI for the XBAP. Oltre a essere lungo, il titolo non è visivamente gradevole né informativo.Besides being long, the title is neither attractive nor informative. Per questo motivo, Page offre un modo per modificare il titolo impostando la proprietà WindowTitle.For this reason, Page offers a way for you to change the title by setting the WindowTitle property. Inoltre, è possibile configurare la larghezza e l'altezza della finestra del browser impostando rispettivamente WindowWidth e WindowHeight.Furthermore, you can configure the width and height of the browser window by setting WindowWidth and WindowHeight, respectively.

è possibile impostare WindowTitle, WindowWidthe WindowHeight in modo dichiarativo nel markup, come illustrato nell'esempio seguente.WindowTitle, WindowWidth, and WindowHeight can be set declaratively in markup, as shown in the following example.

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

Il risultato è illustrato nella figura seguente.The result is shown in the following figure.

Titolo della finestra, altezza, larghezzaWindow title, height, width

Una tipica applicazione XBAP comprende diverse pagine.A typical XBAP comprises several pages. Il modo più semplice per spostarsi da una pagina all'altra consiste nell'usare un Hyperlink.The simplest way to navigate from one page to another is to use a Hyperlink. È possibile aggiungere in modo dichiarativo un Hyperlink a un Page utilizzando l'elemento Hyperlink, illustrato nel markup seguente.You can declaratively add a Hyperlink to a Page by using the Hyperlink element, which is shown in the following markup.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page With Hyperlink"
  WindowWidth="250"
  WindowHeight="250">
<Hyperlink NavigateUri="UriOfPageToNavigateTo.xaml">
  Navigate to Another Page
</Hyperlink>
</Page>

Per un elemento Hyperlink sono necessari gli elementi seguenti:A Hyperlink element requires the following:

  • URI di pacchetto dell'Page a cui passare, come specificato dall'attributo NavigateUri.The pack URI of the Page to navigate to, as specified by the NavigateUri attribute.

  • Contenuto su cui un utente può fare clic per avviare la navigazione, ad esempio testo e immagini (per il contenuto che l'elemento Hyperlink può contenere, vedere Hyperlink).Content that a user can click to initiate the navigation, such as text and images (for the content that the Hyperlink element can contain, see Hyperlink).

Nella figura seguente è illustrata un'applicazione XBAP con un Page con una Hyperlink.The following figure shows an XBAP with a Page that has a Hyperlink.

Pagina con collegamento ipertestualePage with Hyperlink

Come ci si aspetterebbe, facendo clic sul Hyperlink si fa in modo che l'applicazione XBAP passi alla Page identificata dall'attributo NavigateUri.As you would expect, clicking the Hyperlink causes the XBAP to navigate to the Page that is identified by the NavigateUri attribute. Inoltre, l'applicazione XBAP aggiunge una voce per il Page precedente all'elenco pagine recenti in Internet Explorer.Additionally, the XBAP adds an entry for the previous Page to the Recent Pages list in Internet Explorer. come illustrato nella figura seguente.This is shown in the following figure.

Pulsanti indietro e indietroBack and Forward buttons

Oltre a supportare la navigazione da un Page a un altro, Hyperlink supporta anche l'esplorazione dei frammenti.As well as supporting navigation from one Page to another, Hyperlink also supports fragment navigation.

Navigazione in un frammentoFragment Navigation

L' esplorazione del frammento è la navigazione verso un frammento di contenuto nella Page corrente o in un'altra Page.Fragment navigation is the navigation to a content fragment in either the current Page or another Page. In WPF, un frammento di contenuto è il contenuto contenuto da un elemento denominato.In WPF, a content fragment is the content that is contained by a named element. Un elemento denominato è un elemento per il quale è impostato l'attributo Name.A named element is an element that has its Name attribute set. Il markup seguente mostra un elemento TextBlock denominato che contiene un frammento di contenuto.The following markup shows a named TextBlock element that contains a content fragment.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowTitle="Page With Fragments" >
<!-- Content Fragment called "Fragment1" -->
<TextBlock Name="Fragment1">
  Ea vel dignissim te aliquam facilisis ...
</TextBlock>
</Page>

Affinché un Hyperlink passi a un frammento di contenuto, l'attributo NavigateUri deve includere quanto segue:For a Hyperlink to navigate to a content fragment, the NavigateUri attribute must include the following:

  • URI del Page con il frammento di contenuto a cui spostarsi.The URI of the Page with the content fragment to navigate to.

  • Un carattere "#".A "#" character.

  • Nome dell'elemento nell'Page che contiene il frammento di contenuto.The name of the element on the Page that contains the content fragment.

Un URI del frammento ha il formato seguente.A fragment URI has the following format.

URIPage # NomeElementoPageURI # ElementName

Di seguito viene illustrato un esempio di Hyperlink configurato per passare a un frammento di contenuto.The following shows an example of a Hyperlink that is configured to navigate to a content fragment.

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

Nota

In questa sezione viene descritta l'implementazione predefinita di esplorazione dei frammenti in WPF.This section describes the default fragment navigation implementation in WPF. WPF consente inoltre di implementare uno schema di esplorazione dei frammenti personalizzato che, in parte, richiede la gestione dell'evento NavigationService.FragmentNavigation.WPF also allows you to implement your own fragment navigation scheme which, in part, requires handling the NavigationService.FragmentNavigation event.

Importante

È possibile passare a frammenti in pagine XAMLXAML separate (solo markup XAMLXAML file con Page come elemento radice) solo se le pagine possono essere visualizzate tramite HTTP.You can navigate to fragments in loose XAMLXAML pages (markup-only XAMLXAML files with Page as the root element) only if the pages can be browsed via HTTP.

Tuttavia, una pagina di XAMLXAML separata può spostarsi nei propri frammenti.However, a loose XAMLXAML page can navigate to its own fragments.

Mentre Hyperlink consente a un utente di avviare la navigazione a una Pageparticolare, il lavoro di individuazione e download della pagina viene eseguito dalla classe NavigationService.While Hyperlink allows a user to initiate navigation to a particular Page, the work of locating and downloading the page is performed by the NavigationService class. In sostanza, NavigationService fornisce la possibilità di elaborare una richiesta di navigazione per conto del codice client, ad esempio l'Hyperlink.Essentially, NavigationService provides the ability to process a navigation request on behalf of client code, such as the Hyperlink. Inoltre, NavigationService implementa un supporto di livello superiore per il rilevamento e l'influenza di una richiesta di navigazione.Additionally, NavigationService implements higher-level support for tracking and influencing a navigation request.

Quando si fa clic su un Hyperlink, WPF chiama NavigationService.Navigate per individuare e scaricare il Page nell'URI di pacchetto specificato.When a Hyperlink is clicked, WPF calls NavigationService.Navigate to locate and download the Page at the specified pack URI. Il Page scaricato viene convertito in una struttura ad albero di oggetti il cui oggetto radice è un'istanza del Pagescaricato.The downloaded Page is converted to a tree of objects whose root object is an instance of the downloaded Page. Un riferimento all'oggetto Page radice viene archiviato nella proprietà NavigationService.Content.A reference to the root Page object is stored in the NavigationService.Content property. L'URI di pacchetto per il contenuto su cui è stato fatto lo spostamento viene archiviato nella proprietà NavigationService.Source, mentre il NavigationService.CurrentSource archivia l'URI del pacchetto per l'ultima pagina a cui è stato fatto lo spostamento.The pack URI for the content that was navigated to is stored in the NavigationService.Source property, while the NavigationService.CurrentSource stores the pack URI for the last page that was navigated to.

Nota

Un'applicazione WPF può avere più di un NavigationServiceattualmente attivo.It is possible for a WPF application to have more than one currently active NavigationService. Per ulteriori informazioni, vedere host di navigazione più avanti in questo argomento.For more information, see Navigation Hosts later in this topic.

Navigazione a livello di codice tramite il servizio di navigazioneProgrammatic Navigation with the Navigation Service

Non è necessario conoscere NavigationService se la navigazione viene implementata in modo dichiarativo nel markup usando Hyperlink, perché Hyperlink usa il NavigationService per conto dell'utente.You don't need to know about NavigationService if navigation is implemented declaratively in markup using Hyperlink, because Hyperlink uses the NavigationService on your behalf. Ciò significa che, a condizione che l'elemento padre diretto o indiretto di un Hyperlink sia un host di navigazione (vedere host di navigazione), Hyperlink sarà in grado di trovare e utilizzare il servizio di navigazione dell'host di navigazione per elaborare una richiesta di navigazione.This means that, as long as either the direct or indirect parent of a Hyperlink is a navigation host (see Navigation Hosts), Hyperlink will be able to find and use the navigation host's navigation service to process a navigation request.

In alcune situazioni, tuttavia, è necessario usare direttamente NavigationService, inclusi i seguenti:However, there are situations when you need to use NavigationService directly, including the following:

  • Quando è necessario creare un'istanza di un Page usando un costruttore senza parametri.When you need to instantiate a Page using a non-parameterless constructor.

  • Quando è necessario impostare le proprietà nella Page prima di passare a essa.When you need to set properties on the Page before you navigate to it.

  • Quando il Page cui è necessario spostarsi può essere determinato solo in fase di esecuzione.When the Page that needs to be navigated to can only be determined at run time.

In questi casi, è necessario scrivere codice per avviare la navigazione a livello di programmazione chiamando il metodo di Navigate dell'oggetto NavigationService.In these situations, you need to write code to programmatically initiate navigation by calling the Navigate method of the NavigationService object. Questa operazione richiede il recupero di un riferimento a un NavigationService.That requires getting a reference to a NavigationService.

Ottenere un riferimento a NavigationServiceGetting a Reference to the NavigationService

Per motivi descritti nella sezione host di navigazione , un'applicazione WPF può avere più di un NavigationService.For reasons that are covered in the Navigation Hosts section, a WPF application can have more than one NavigationService. Questo significa che il codice necessita di un modo per trovare un NavigationService, che in genere è il NavigationService che ha navigato fino al Pagecorrente.This means that your code needs a way to find a NavigationService, which is usually the NavigationService that navigated to the current Page. È possibile ottenere un riferimento a un NavigationService chiamando il metodo di NavigationService.GetNavigationService static.You can get a reference to a NavigationService by calling the staticNavigationService.GetNavigationService method. Per ottenere la NavigationService che si è spostata a una Pageparticolare, passare un riferimento al Page come argomento del metodo GetNavigationService.To get the NavigationService that navigated to a particular Page, you pass a reference to the Page as the argument of the GetNavigationService method. Nel codice seguente viene illustrato come ottenere il NavigationService per l'Pagecorrente.The following code shows how to get the NavigationService for the current Page.

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

Come scelta rapida per trovare il NavigationService per un Page, Page implementa la proprietà NavigationService.As a shortcut for finding the NavigationService for a Page, Page implements the NavigationService property. come illustrato nell'esempio riportato di seguito.This is shown in the following example.

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

Nota

Un Page può ottenere un riferimento al relativo NavigationService solo quando Page genera l'evento Loaded.A Page can only get a reference to its NavigationService when Page raises the Loaded event.

Navigazione a livello di codice in un oggetto PageProgrammatic Navigation to a Page Object

Nell'esempio seguente viene illustrato come utilizzare il NavigationService per passare a una Pagea livello di codice.The following example shows how to use the NavigationService to programmatically navigate to a Page. La navigazione a livello di codice è necessaria perché è possibile creare un'istanza del Page a cui si sta eseguendo la navigazione solo utilizzando un singolo costruttore senza parametri.Programmatic navigation is required because the Page that is being navigated to can only be instantiated using a single, non-parameterless constructor. Il Page con il costruttore senza parametri viene mostrato nel markup e nel codice seguenti.The Page with the non-parameterless constructor is shown in the following markup and code.

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

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

            this.Content = message;
        }
    }
}

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

            Me.Content = message
        End Sub
    End Class
End Namespace

Il Page che passa alla Page con il costruttore senza parametri viene mostrato nel markup e nel codice seguenti.The Page that navigates to the Page with the non-parameterless constructor is shown in the following markup and code.

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

  <Hyperlink Click="hyperlink_Click">
    Navigate to Page with Non-Default Constructor
  </Hyperlink>

</Page>
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;

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

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Instantiate the page to navigate to
            PageWithNonDefaultConstructor page = new PageWithNonDefaultConstructor("Hello!");

            // Navigate to the page, using the NavigationService
            this.NavigationService.Navigate(page);
        }
    }
}

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

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

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

Quando si fa clic sul Hyperlink su questa Page, la navigazione viene avviata creando un'istanza della Page per passare a utilizzando il costruttore senza parametri e chiamando il metodo NavigationService.Navigate.When the Hyperlink on this Page is clicked, navigation is initiated by instantiating the Page to navigate to using the non-parameterless constructor and calling the NavigationService.Navigate method. Navigate accetta un riferimento all'oggetto a cui viene indirizzato il NavigationService, anziché un URI di pacchetto.Navigate accepts a reference to the object that the NavigationService will navigate to, rather than a pack URI.

Navigazione a livello di codice con un URI di tipo packProgrammatic Navigation with a Pack URI

Se è necessario creare un URI di pacchetto a livello di codice (quando, ad esempio, è possibile determinare solo l'URI del pacchetto in fase di esecuzione), è possibile usare il metodo NavigationService.Navigate.If you need to construct a pack URI programmatically (when you can only determine the pack URI at run time, for example), you can use the NavigationService.Navigate method. come illustrato nell'esempio riportato di seguito.This is shown in the following example.

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

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

        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Create a pack URI
            Uri uri = new Uri("AnotherPage.xaml", UriKind.Relative);

            // Get the navigation service that was used to 
            // navigate to this page, and navigate to 
            // AnotherPage.xaml
            this.NavigationService.Navigate(uri);
        }
    }
}

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

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

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

Aggiornamento della pagina correnteRefreshing the Current Page

Un Page non viene scaricato se ha lo stesso URI di pacchetto dell'URI di pacchetto archiviato nella proprietà NavigationService.Source.A Page is not downloaded if it has the same pack URI as the pack URI that is stored in the NavigationService.Source property. Per forzare WPF a scaricare nuovamente la pagina corrente, è possibile chiamare il metodo NavigationService.Refresh, come illustrato nell'esempio seguente.To force WPF to download the current page again, you can call the NavigationService.Refresh method, as shown in the following example.

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

namespace SDKSample
{
    public partial class NSRefreshNavigationPage : Page
    {

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

Come si è visto, esistono diversi modi per avviare una navigazione.There are many ways to initiate navigation, as you've seen. Quando viene avviata la navigazione e mentre è in corso la navigazione, è possibile rilevare e influenzare lo spostamento usando gli eventi seguenti che vengono implementati da NavigationService:When navigation is initiated, and while navigation is in progress, you can track and influence the navigation using the following events that are implemented by NavigationService:

  • Navigating.Navigating. Si verifica quando viene richiesta una nuova navigazione.Occurs when a new navigation is requested. Può essere usato per annullare la navigazione.Can be used to cancel the navigation.

  • NavigationProgress.NavigationProgress. Si verifica periodicamente durante un download per fornire informazioni sullo stato dello spostamento.Occurs periodically during a download to provide navigation progress information.

  • Navigated.Navigated. Si verifica quando la pagina è stata individuata e scaricata.Occurs when the page has been located and downloaded.

  • NavigationStopped.NavigationStopped. Si verifica quando la navigazione viene arrestata (chiamando StopLoading) o quando viene richiesta una nuova navigazione mentre è in corso una navigazione corrente.Occurs when the navigation is stopped (by calling StopLoading), or when a new navigation is requested while a current navigation is in progress.

  • NavigationFailed.NavigationFailed. Si verifica quando viene generato un errore durante la navigazione nel contenuto richiesto.Occurs when an error is raised while navigating to the requested content.

  • LoadCompleted.LoadCompleted. Si verifica quando il contenuto di destinazione della navigazione è stato caricato e analizzato ed è iniziata l'esecuzione del rendering.Occurs when content that was navigated to is loaded and parsed, and has begun rendering.

  • FragmentNavigation.FragmentNavigation. Si verifica quando inizia la navigazione in un frammento di contenuto, che avviene:Occurs when navigation to a content fragment begins, which happens:

    • Immediatamente, se il frammento desiderato si trova nel contenuto corrente.Immediately, if the desired fragment is in the current content.

    • Una volta caricato il contenuto di origine, se il frammento desiderato si trova in un contenuto diverso.After the source content has been loaded, if the desired fragment is in different content.

Gli eventi di navigazione vengono generati nell'ordine illustrato nella figura seguente.The navigation events are raised in the order that is illustrated by the following figure.

Grafico del flusso di navigazione delle paginePage navigation flow chart

In generale, un Page non è preoccupato per questi eventi.In general, a Page isn't concerned about these events. È più probabile che un'applicazione sia interessata e, per questo motivo, questi eventi vengono generati anche dalla classe Application:It is more likely that an application is concerned with them and, for that reason, these events are also raised by the Application class:

Ogni volta che NavigationService genera un evento, la classe Application genera l'evento corrispondente.Every time NavigationService raises an event, the Application class raises the corresponding event. Frame e NavigationWindow offrono gli stessi eventi per rilevare la navigazione all'interno dei rispettivi ambiti.Frame and NavigationWindow offer the same events to detect navigation within their respective scopes.

In alcuni casi, è possibile che un Page sia interessato a questi eventi.In some cases, a Page might be interested in these events. Ad esempio, un Page può gestire l'evento NavigationService.Navigating per determinare se annullare o meno la navigazione da se stessa.For example, a Page might handle the NavigationService.Navigating event to determine whether or not to cancel navigation away from itself. come illustrato nell'esempio riportato di seguito.This is shown in the following example.

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

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

            // Can only access the NavigationService when the page has been loaded
            this.Loaded += new RoutedEventHandler(CancelNavigationPage_Loaded);
            this.Unloaded += new RoutedEventHandler(CancelNavigationPage_Unloaded);
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Navigate(new Uri("AnotherPage.xaml", UriKind.Relative));
        }

        void CancelNavigationPage_Loaded(object sender, RoutedEventArgs e)
        {
            this.NavigationService.Navigating += new NavigatingCancelEventHandler(NavigationService_Navigating);
        }

        void CancelNavigationPage_Unloaded(object sender, RoutedEventArgs e)
        {
            this.NavigationService.Navigating -= new NavigatingCancelEventHandler(NavigationService_Navigating);
        }

        void NavigationService_Navigating(object sender, NavigatingCancelEventArgs e)
        {
            // Does the user really want to navigate to another page?
            MessageBoxResult result;
            result = MessageBox.Show("Do you want to leave this page?", "Navigation Request", MessageBoxButton.YesNo);

            // If the user doesn't want to navigate away, cancel the navigation
            if (result == MessageBoxResult.No) e.Cancel = true;
        }
    }
}

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

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

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

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

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

        Private Sub NavigationService_Navigating(ByVal sender As Object, ByVal e As NavigatingCancelEventArgs)
            ' Does the user really want to navigate to another page?
            Dim result As MessageBoxResult
            result = MessageBox.Show("Do you want to leave this page?", "Navigation Request", MessageBoxButton.YesNo)

            ' If the user doesn't want to navigate away, cancel the navigation
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End Sub
    End Class
End Namespace

Se si registra un gestore con un evento di navigazione da un Page, come nell'esempio precedente, è necessario annullare anche la registrazione del gestore eventi.If you register a handler with a navigation event from a Page, as the preceding example does, you must also unregister the event handler. In caso contrario, è possibile che si verifichino effetti collaterali sul modo in cui l'esplorazione WPF ricorda Page navigazione tramite il Journal.If you don't, there may be side effects with respect to how WPF navigation remembers Page navigation using the journal.

Memorizzazione della navigazione tramite journalRemembering Navigation with the Journal

WPF usa due stack per ricordare le pagine da cui è stato eseguito lo spostamento: uno stack indietro e uno stack di avanzamento.WPF uses two stacks to remember the pages that you have navigated from: a back stack and a forward stack. Quando si passa dalla Page corrente a una nuova Page o a una Pageesistente, il Page corrente viene aggiunto allo stack indietro.When you navigate from the current Page to a new Page or forward to an existing Page, the current Page is added to the back stack. Quando si passa dalla Page corrente alla Pageprecedente, il Page corrente viene aggiunto allo stack di avanzamento.When you navigate from the current Page back to the previous Page, the current Page is added to the forward stack. Per fare riferimento allo stack indietro, allo stack avanti e alla funzionalità di gestione degli stack nel loro complesso, si usa il termine journal.The back stack, the forward stack, and the functionality to manage them, are collectively referred to as the journal. Ogni elemento nello stack indietro e nello stack di avanzamento è un'istanza della classe JournalEntry e viene definito voce Journal.Each item in the back stack and the forward stack is an instance of the JournalEntry class, and is referred to as a journal entry.

Dal punto di vista concettuale, il Journal funziona allo stesso modo dei pulsanti indietro e indietro in Internet Explorer.Conceptually, the journal operates the same way that the Back and Forward buttons in Internet Explorer do. illustrati nella figura seguente.These are shown in the following figure.

Pulsanti indietro e indietroBack and Forward buttons

Per le applicazioni XBAP ospitate da Internet Explorer, WPF integra il Journal nel Interfaccia utenteUI di navigazione di Internet Explorer.For XBAPs that are hosted by Internet Explorer, WPF integrates the journal into the navigation Interfaccia utenteUI of Internet Explorer. In questo modo gli utenti possono spostarsi tra le pagine di un'applicazione XBAPutilizzando i pulsanti indietro, indietroe pagine recenti in Internet Explorer.This allows users to navigate pages in an XBAP by using the Back, Forward, and Recent Pages buttons in Internet Explorer.

Importante

In Internet Explorer, quando un utente passa da e a un'applicazione XBAP, solo le voci del journal per le pagine che non sono state mantenute attive vengono conservate nel journal.In Internet Explorer, when a user navigates away from and back to an XBAP, only the journal entries for pages that were not kept alive are retained in the journal. Per informazioni su come mantenere le pagine attive, vedere durata della pagina e Journal più avanti in questo argomento.For discussion on keeping pages alive, see Page Lifetime and the Journal later in this topic.

Per impostazione predefinita, il testo di ogni Page visualizzato nell'elenco pagine recenti di Internet Explorer è l'URI del Page.By default, the text for each Page that appears in the Recent Pages list of Internet Explorer is the URI for the Page. In molti casi questo testo non risulta molto significativo agli occhi dell'utente.In many cases, this is not particularly meaningful to the user. Fortunatamente è possibile modificarlo tramite una delle opzioni seguenti:Fortunately, you can change the text using one the following options:

  1. Valore dell'attributo JournalEntry.Name associato.The attached JournalEntry.Name attribute value.

  2. Valore dell'attributo Page.Title.The Page.Title attribute value.

  3. Il valore dell'attributo Page.WindowTitle e l'URI per l'Pagecorrente.The Page.WindowTitle attribute value and the URI for the current Page.

  4. URI per la Pagecorrente.The URI for the current Page. (predefinita)(Default)

L'ordine nel quale sono elencate le opzioni corrisponde all'ordine di precedenza usato per cercare il testo.The order in which the options are listed matches the order of precedence for finding the text. Se, ad esempio, si imposta JournalEntry.Name, gli altri valori verranno ignorati.For example, if JournalEntry.Name is set, the other values are ignored.

Nell'esempio seguente viene utilizzato l'attributo Page.Title per modificare il testo visualizzato per una voce del journal.The following example uses the Page.Title attribute to change the text that appears for a journal entry.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.PageWithTitle"
    Title="This is the title of the journal entry for this page.">
</Page>
using System.Windows.Controls;

namespace SDKSample
{
    public partial class PageWithTitle : Page
    {

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

Sebbene un utente possa esplorare il Journal utilizzando le pagine indietro, in direttae recenti in Internet Explorer, è anche possibile esplorare il Journal utilizzando i meccanismi dichiarativi e programmatici forniti da WPF.Although a user can navigate the journal by using the Back, Forward, and Recent Pages in Internet Explorer, you can also navigate the journal using both declarative and programmatic mechanisms provided by WPF. A tale scopo, è necessario fornire interfacce utente personalizzate per la navigazione nelle pagine.One reason to do this is to provide custom navigation UIs in your pages.

È possibile aggiungere in modo dichiarativo il supporto per la navigazione nel journal usando i comandi di navigazione esposti da NavigationCommands.You can declaratively add journal navigation support by using the navigation commands exposed by NavigationCommands. Nell'esempio seguente viene illustrato come utilizzare il comando di navigazione BrowseBack.The following example demonstrates how to use the BrowseBack navigation command.

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

È possibile esplorare il Journal a livello di codice utilizzando uno dei seguenti membri della classe NavigationService:You can programmatically navigate the journal by using one of the following members of the NavigationService class:

Il journal può anche essere modificato a livello di codice, come descritto in mantenere lo stato del contenuto con la cronologia di navigazione più avanti in questo argomento.The journal can also be manipulated programmatically, as discussed in Retaining Content State with Navigation History later in this topic.

Durata della pagina e journalPage Lifetime and the Journal

Si consideri un'applicazione XBAP con diverse pagine che contengono contenuti avanzati, tra cui grafica, animazioni e supporti.Consider an XBAP with several pages that contain rich content, including graphics, animations, and media. Il footprint di memoria per pagine simili può essere piuttosto grande, in particolare se vengono usati contenuti audio e video.The memory footprint for pages like these could be quite large, particularly if video and audio media are used. Dato che il Journal "memorizza" le pagine che sono state spostate in, tale applicazione XBAP potrebbe utilizzare rapidamente una quantità di memoria considerevole e notevole.Given that the journal "remembers" pages that have been navigated to, such an XBAP could quickly consume a large and noticeable amount of memory.

Per questo motivo, il comportamento predefinito del journal consiste nell'archiviare Page metadati in ogni voce del journal anziché in un riferimento a un oggetto Page.For this reason, the default behavior of the journal is to store Page metadata in each journal entry rather than a reference to a Page object. Quando si passa a una voce del Journal, i metadati Page vengono utilizzati per creare una nuova istanza della Pagespecificata.When a journal entry is navigated to, its Page metadata is used to create a new instance of the specified Page. Di conseguenza, ogni Page navigato ha la durata illustrata nella figura seguente.As a consequence, each Page that is navigated has the lifetime that is illustrated by the following figure.

Durata paginaPage lifetime

Sebbene l'utilizzo del comportamento predefinito del journal possa ridurre il consumo di memoria, le prestazioni di rendering per pagina potrebbero risultare ridotte. la ricreazione di un'istanza di un Page può richiedere molto tempo, in particolare se presenta molti contenuti.Although using the default journaling behavior can save on memory consumption, per-page rendering performance might be reduced; reinstantiating a Page can be time-intensive, particularly if it has a lot of content. Se è necessario mantenere un'istanza Page nel journal, è possibile creare due tecniche per eseguire questa operazione.If you need to retain a Page instance in the journal, you can draw on two techniques for doing so. Per prima cosa, è possibile passare a un oggetto Page a livello di codice chiamando il metodo NavigationService.Navigate.First, you can programmatically navigate to a Page object by calling the NavigationService.Navigate method.

In secondo luogo, è possibile specificare che WPF mantiene un'istanza di una Page nel journal impostando la proprietà KeepAlive su true (il valore predefinito è false).Second, you can specify that WPF retain an instance of a Page in the journal by setting the KeepAlive property to true (the default is false). Come illustrato nell'esempio seguente, è possibile impostare KeepAlive in modo dichiarativo nel markup.As shown in the following example, you can set KeepAlive declaratively in markup.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.KeepAlivePage"
    KeepAlive="True">
  
  An instance of this page is stored in the journal.
  
</Page>

Il ciclo di vita di un Page mantenuto attivo è leggermente diverso da quello che non lo è.The lifetime of a Page that is kept alive is subtly different from one that is not. La prima volta che si passa a un Page mantenuto attivo, ne viene creata un'istanza esattamente come un Page non mantenuto attivo.The first time a Page that is kept alive is navigated to, it is instantiated just like a Page that is not kept alive. Tuttavia, poiché un'istanza del Page viene mantenuta nel journal, non viene mai creata un'istanza per finché rimane nel journal.However, because an instance of the Page is retained in the journal, it is never instantiated again for as long as it remains in the journal. Di conseguenza, se un Page dispone di una logica di inizializzazione che deve essere chiamata ogni volta che viene eseguita la navigazione Page, è necessario spostarla dal costruttore in un gestore per l'evento di Loaded.Consequently, if a Page has initialization logic that needs to be called every time the Page is navigated to, you should move it from the constructor into a handler for the Loaded event. Come illustrato nella figura seguente, gli eventi Loaded e Unloaded vengono comunque generati ogni volta che si passa a un Page rispettivamente.As shown in the following figure, the Loaded and Unloaded events are still raised each time a Page is navigated to and from, respectively.

Quando vengono generati gli eventi caricati e scaricatiWhen the Loaded and Unloaded events are raised

Quando un Page non viene mantenuto attivo, non è necessario eseguire una delle operazioni seguenti:When a Page is not kept alive, you should not do either of the following:

  • Archiviare un riferimento all'oggetto o a parte di esso.Store a reference to it, or any part of it.

  • Registrare gestori eventi con eventi che non siano implementati dall'oggetto.Register event handlers with events that are not implemented by it.

Se si esegue una di queste azioni, verranno creati riferimenti che forzano la conservazione della Page in memoria, anche dopo che è stata rimossa dal Journal.Doing either of these will create references that force the Page to be retained in memory, even after it has been removed from the journal.

In generale, è preferibile usare il comportamento predefinito Page di non mantenere un Page attivo.In general, you should prefer the default Page behavior of not keeping a Page alive. Ciò comporta tuttavia alcune implicazioni sullo stato che vengono trattate nella prossima sezione.However, this has state implications that are discussed in the next section.

Mantenimento dello stato del contenuto tramite cronologia di navigazioneRetaining Content State with Navigation History

Se un Page non viene mantenuto attivo e dispone di controlli che raccolgono i dati dall'utente, cosa accade ai dati se un utente si sposta da un oggetto all'Page?If a Page is not kept alive, and it has controls that collect data from the user, what happens to the data if a user navigates away from and back to the Page? Dal punto di vista dell'esperienza utente, ci si potrebbe aspettare di visualizzare i dati immessi in precedenza.From a user experience perspective, the user should expect to see the data they entered previously. Sfortunatamente, poiché viene creata una nuova istanza del Page con ogni navigazione, viene ricreata un'istanza dei controlli che hanno raccolto i dati e i dati andranno perduti.Unfortunately, because a new instance of the Page is created with each navigation, the controls that collected the data are reinstantiated and the data is lost.

Fortunatamente, il Journal fornisce il supporto per la memorizzazione dei dati tra Page navigazione, inclusi i dati del controllo.Fortunately, the journal provides support for remembering data across Page navigations, including control data. In particolare, la voce Journal per ogni Page funge da contenitore temporaneo per lo stato di Page associato.Specifically, the journal entry for each Page acts as a temporary container for the associated Page state. Nei passaggi seguenti viene illustrato il modo in cui viene utilizzato questo supporto quando si Esplora un Page:The following steps outline how this support is used when a Page is navigated from:

  1. Al Journal viene aggiunta una voce per la Page corrente.An entry for the current Page is added to the journal.

  2. Lo stato del Page viene archiviato con la voce Journal per quella pagina, che viene aggiunta allo stack indietro.The state of the Page is stored with the journal entry for that page, which is added to the back stack.

  3. La nuova Page viene spostata a.The new Page is navigated to.

Quando si torna alla pagina Page, usando il Journal, viene eseguita la procedura seguente:When the page Page is navigated back to, using the journal, the following steps take place:

  1. Viene creata un'istanza del Page (la voce del Journal superiore nello stack indietro).The Page (the top journal entry on the back stack) is instantiated.

  2. Il Page viene aggiornato con lo stato archiviato con la voce Journal per l'Page.The Page is refreshed with the state that was stored with the journal entry for the Page.

  3. Il Page viene nuovamente spostato in.The Page is navigated back to.

WPF usa automaticamente questo supporto quando vengono usati i controlli seguenti in un Page:WPF automatically uses this support when the following controls are used on a Page:

Se un Page utilizza questi controlli, i dati immessi vengono memorizzati in Page navigazione, come dimostrato dal colore preferitoListBox nella figura seguente.If a Page uses these controls, data entered into them is remembered across Page navigations, as demonstrated by the Favorite ColorListBox in the following figure.

Pagina con controlli che memorizzano lo statoPage with controls that remember state

Quando un Page dispone di controlli diversi da quelli presenti nell'elenco precedente o quando lo stato è archiviato in oggetti personalizzati, è necessario scrivere codice per fare in modo che il Journal ricordi lo stato tra Page le navigazioni.When a Page has controls other than those in the preceding list, or when state is stored in custom objects, you need to write code to cause the journal to remember state across Page navigations.

Se è necessario ricordare piccole parti di stato tra Page navigazione, è possibile usare le proprietà di dipendenza (vedere DependencyProperty) configurate con il flag di metadati FrameworkPropertyMetadata.Journal.If you need to remember small pieces of state across Page navigations, you can use dependency properties (see DependencyProperty) that are configured with the FrameworkPropertyMetadata.Journal metadata flag.

Se lo stato che il Page deve ricordare tra le navigazioni è costituito da più tipi di dati, è possibile che si verifichi una minore quantità di codice per incapsulare lo stato in un'unica classe e implementare l'interfaccia IProvideCustomContentState.If the state that your Page needs to remember across navigations comprises multiple pieces of data, you may find it less code intensive to encapsulate your state in a single class and implement the IProvideCustomContentState interface.

Se è necessario spostarsi tra diversi Stati di una singola Page, senza spostarsi dalla Page stessa, è possibile utilizzare IProvideCustomContentState e NavigationService.AddBackEntry.If you need to navigate through various states of a single Page, without navigating from the Page itself, you can use IProvideCustomContentState and NavigationService.AddBackEntry.

CookieCookies

Un altro modo in cui le applicazioni WPF possono archiviare i dati è costituito dai cookie, che vengono creati, aggiornati ed eliminati mediante i metodi SetCookie e GetCookie.Another way that WPF applications can store data is with cookies, which are created, updated, and deleted by using the SetCookie and GetCookie methods. I cookie che è possibile creare in WPF sono gli stessi cookie usati da altri tipi di applicazioni Web. i cookie sono parti arbitrarie di dati archiviati da un'applicazione in un computer client durante o tra sessioni dell'applicazione.The cookies that you can create in WPF are the same cookies that other types of Web applications use; cookies are arbitrary pieces of data that are stored by an application on a client machine either during or across application sessions. I dati dei cookie assumono in genere la forma di una coppia nome/valore nel formato seguente.Cookie data typically takes the form of a name/value pair in the following format.

Nome = ValoreName = Value

Quando i dati vengono passati a SetCookie, insieme al Uri della posizione per cui deve essere impostato il cookie, viene creato un cookie in memoria ed è disponibile solo per la durata della sessione dell'applicazione corrente.When the data is passed to SetCookie, along with the Uri of the location for which the cookie should be set, a cookie is created in-memory, and it is only available for the duration of the current application session. Questo tipo di cookie viene definito cookie di sessione.This type of cookie is referred to as a session cookie.

Per archiviare un cookie tra una sessione e l'altra dell'applicazione, occorre aggiungervi una data di scadenza nel formato seguente.To store a cookie across application sessions, an expiration date must be added to the cookie, using the following format.

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

Un cookie con una data di scadenza viene archiviato nella cartella dei file temporanei Internet dell'installazione di Windows corrente fino alla scadenza del cookie.A cookie with an expiration date is stored in the current Windows installation's Temporary Internet Files folder until the cookie expires. Un cookie di questo tipo è noto come cookie permanente perché viene reso persistente tra le sessioni dell'applicazione.Such a cookie is known as a persistent cookie because it persists across application sessions.

È possibile recuperare sia i cookie di sessione che quelli permanenti chiamando il metodo GetCookie, passando la Uri della posizione in cui è stato impostato il cookie con il metodo SetCookie.You retrieve both session and persistent cookies by calling the GetCookie method, passing the Uri of the location where the cookie was set with the SetCookie method.

Di seguito sono riportati alcuni dei modi in cui i cookie sono supportati in WPF:The following are some of the ways that cookies are supported in WPF:

  • Le applicazioni e le XBAP indipendenti WPF possono creare e gestire i cookie.WPF standalone applications and XBAPs can both create and manage cookies.

  • È possibile accedere ai cookie creati da un'applicazione XBAP dal browser.Cookies that are created by an XBAP can be accessed from the browser.

  • Le applicazioni XBAP dello stesso dominio possono creare e condividere i cookie.XBAPs from the same domain can create and share cookies.

  • Le applicazioni XBAPs e le pagine HTML dello stesso dominio possono creare e condividere cookie.XBAPs and HTML pages from the same domain can create and share cookies.

  • I cookie vengono inviati quando le applicazioni XBAPs e le pagine XAMLXAML separate eseguono richieste Web.Cookies are dispatched when XBAPs and loose XAMLXAML pages make Web requests.

  • Sia le applicazioni XBAP di primo livello che le applicazioni XBAP ospitate in IFRAME possono accedere ai cookie.Both top-level XBAPs and XBAPs hosted in IFRAMES can access cookies.

  • Il supporto dei cookie in WPF è lo stesso per tutti i browser supportati.Cookie support in WPF is the same for all supported browsers.

  • In Internet Explorer, i criteri di P3P relativi ai cookie vengono rispettati da WPF, in particolare per quanto riguarda le applicazioni XBAP di terze parti e di terze parti.In Internet Explorer, P3P policy that pertains to cookies is honored by WPF, particularly with respect to first-party and third-party XBAPs.

Navigazione strutturataStructured Navigation

Se è necessario passare dati da un Page a un altro, è possibile passare i dati come argomenti a un costruttore senza parametri del Page.If you need to pass data from one Page to another, you can pass the data as arguments to a non-parameterless constructor of the Page. Si noti che se si usa questa tecnica, è necessario tenere attivo il Page; in caso contrario, la volta successiva che si passa alla Page, WPF crea un'istanza del Page usando il costruttore senza parametri.Note that if you use this technique, you must keep the Page alive; if not, the next time you navigate to the Page, WPF reinstantiates the Page by using the parameterless constructor.

In alternativa, il Page può implementare proprietà impostate con i dati che devono essere passati.Alternatively, your Page can implement properties that are set with the data that needs to be passed. Tuttavia, quando un Page deve passare i dati al Page che ci si è spostati, le cose diventano più complesse.Things become tricky, however, when a Page needs to pass data back to the Page that navigated to it. Il problema è che la navigazione non supporta in modo nativo i meccanismi per garantire che una Page venga restituita a dopo che è stata spostata da.The problem is that navigation doesn't natively support mechanisms for guaranteeing that a Page will be returned to after it is navigated from. In pratica, la navigazione non supporta la semantica di tipo chiamata/ritorno.Essentially, navigation doesn't support call/return semantics. Per risolvere questo problema, in WPF è disponibile la classe PageFunction<T> che è possibile utilizzare per garantire che un Page venga restituito in modo prevedibile e strutturato.To solve this problem, WPF provides the PageFunction<T> class that you can use to ensure that a Page is returned to in a predictable and structured fashion. Per altre informazioni, vedere Cenni preliminari sulla navigazione strutturata.For more information, see Structured Navigation Overview.

Classe NavigationWindowThe NavigationWindow Class

Fino a questo punto sono stati analizzati i servizi di navigazione usati più di frequente per compilare applicazioni con contenuto navigabile.To this point, you've seen the gamut of navigation services that you are most likely to use to build applications with navigable content. Questi servizi sono stati discussi nel contesto di XBAPs, anche se non sono limitati alle applicazioni XBAP.These services were discussed in the context of XBAPs, although they are not limited to XBAPs. I sistemi operativi moderni e le applicazioni Windows sfruttano i vantaggi offerti dall'esperienza del browser degli utenti moderni per incorporare la navigazione in stile browser nelle applicazioni autonome.Modern operating systems and Windows applications take advantage of the browser experience of modern users to incorporate browser-style navigation into standalone applications. Ecco alcuni esempi comuni:Common examples include:

  • Thesaurus di Word: navigazione in diversi vocaboli.Word Thesaurus: Navigate word choices.

  • Esplora file: navigazione su file e cartelle.File Explorer: Navigate files and folders.

  • Procedure guidate: suddivisione di un'attività complessa in più pagine tra le quali è possibile spostarsi.Wizards: Breaking down a complex task into multiple pages that can be navigated between. Un esempio è la procedura guidata componenti di Windows che consente di gestire l'aggiunta e la rimozione delle funzionalità di Windows.An example is the Windows Components Wizard that handles adding and removing Windows features.

Per incorporare la navigazione di tipo browser nelle applicazioni autonome, è possibile usare la classe NavigationWindow.To incorporate browser-style navigation into your standalone applications, you can use the NavigationWindow class. NavigationWindow deriva da Window e lo estende con lo stesso supporto per la navigazione fornita da XBAPs.NavigationWindow derives from Window and extends it with the same support for navigation that XBAPs provide. È possibile utilizzare NavigationWindow come la finestra principale dell'applicazione autonoma o come finestra secondaria, ad esempio una finestra di dialogo.You can use NavigationWindow as either the main window of your standalone application or as a secondary window such as a dialog box.

Per implementare un NavigationWindow, come per la maggior parte delle classi di primo livello in WPF (Window, Pagee così via), si usa una combinazione di markup e code-behind.To implement a NavigationWindow, as with most top-level classes in WPF (Window, Page, and so on), you use a combination of markup and code-behind. come illustrato nell'esempio riportato di seguito.This is shown in the following example.

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

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

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

Questo codice crea un NavigationWindow che passa automaticamente a una Page (HomePage. Xaml) quando viene aperto il NavigationWindow.This code creates a NavigationWindow that automatically navigates to a Page (HomePage.xaml) when the NavigationWindow is opened. Se il NavigationWindow è la finestra principale dell'applicazione, è possibile usare l'attributo StartupUri per avviarlo.If the NavigationWindow is the main application window, you can use the StartupUri attribute to launch it. come illustrato nel markup seguente.This is shown in the following markup.

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

Nella figura seguente viene illustrato il NavigationWindow come la finestra principale di un'applicazione autonoma.The following figure shows the NavigationWindow as the main window of a standalone application.

Finestra principaleA main window

Nella figura è possibile notare che il NavigationWindow ha un titolo, anche se non è stato impostato nel codice di implementazione NavigationWindow dell'esempio precedente.From the figure, you can see that the NavigationWindow has a title, even though it wasn't set in the NavigationWindow implementation code from the preceding example. Il titolo viene invece impostato utilizzando la proprietà WindowTitle, illustrato nel codice seguente.Instead, the title is set using the WindowTitle property, which is shown in the following code.

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

L'impostazione delle proprietà WindowWidth e WindowHeight influiscono anche sul NavigationWindow.Setting the WindowWidth and WindowHeight properties also affects the NavigationWindow.

In genere, si implementano NavigationWindow personalizzati quando è necessario personalizzarne il comportamento o l'aspetto.Usually, you implement your own NavigationWindow when you need to customize either its behavior or its appearance. Se questo non è necessario, è possibile usare un'alternativa più rapida.If you do neither, you can use a shortcut. Se si specifica l'URI di un Page come StartupUri in un'applicazione autonoma, Application crea automaticamente una NavigationWindow per ospitare la Page.If you specify the pack URI of a Page as the StartupUri in a standalone application, Application automatically creates a NavigationWindow to host the Page. Il markup seguente illustra la procedura necessaria allo scopo.The following markup shows how to enable this.

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

Per aprire una finestra dell'applicazione secondaria, ad esempio una finestra di dialogo NavigationWindow, è possibile usare il codice riportato nell'esempio seguente.If you want a secondary application window such as a dialog box to be a NavigationWindow, you can use the code in the following example to open it.

// Open a navigation window as a dialog box
NavigationWindowDialogBox dlg = new NavigationWindowDialogBox();
dlg.Source = new Uri("HomePage.xaml", UriKind.Relative);
dlg.Owner = this;
dlg.ShowDialog();
' Open a navigation window as a dialog box
Dim dlg As New NavigationWindowDialogBox()
dlg.Source = New Uri("HomePage.xaml", UriKind.Relative)
dlg.Owner = Me
dlg.ShowDialog()

La figura seguente ne illustra il risultato.The following figure shows the result.

Una finestra di dialogoA dialog box

Come si può vedere, NavigationWindow Visualizza i pulsanti indietro e indietro in stile Internet Explorer che consentono agli utenti di spostarsi nel journal.As you can see, NavigationWindow displays Internet Explorer-style Back and Forward buttons that allow users to navigate the journal. L'esperienza utente è la stessa, come illustrato nella figura seguente.These buttons provide the same user experience, as shown in the following figure.

Pulsanti indietro e indietro in un oggetto NavigationWindowBack and Forward buttons in a NavigationWindow

Se le pagine forniscono il proprio supporto per la navigazione nel Journal e l' interfaccia utente, è possibile nascondere i pulsanti indietro e indietro visualizzati da NavigationWindow impostando il valore della proprietà ShowsNavigationUI su false.If your pages provide their own journal navigation support and UI, you can hide the Back and Forward buttons displayed by NavigationWindow by setting the value of the ShowsNavigationUI property to false.

In alternativa, è possibile utilizzare il supporto della personalizzazione in WPF per sostituire la Interfaccia utenteUI del NavigationWindow stesso.Alternatively, you can use customization support in WPF to replace the Interfaccia utenteUI of the NavigationWindow itself.

Classe FrameThe Frame Class

Sia il browser che il NavigationWindow sono finestre che ospitano contenuto navigabile.Both the browser and NavigationWindow are windows that host navigable content. In alcuni casi il contenuto delle applicazioni non deve essere necessariamente ospitato da un'intera finestra.In some cases, applications have content that does not need to be hosted by an entire window. Al contrario, tale contenuto può essere ospitato all'interno di altro contenuto.Instead, such content be hosted inside other content. È possibile inserire contenuto navigabile in altro contenuto utilizzando la classe Frame.You can insert navigable content into other content by using the Frame class. Frame fornisce lo stesso supporto delle NavigationWindow e delle XBAP.Frame provides the same support as NavigationWindow and XBAPs.

Nell'esempio seguente viene illustrato come aggiungere un Frame a un Page in modo dichiarativo utilizzando l'elemento Frame.The following example shows how to add a Frame to a Page declaratively by using the Frame element.

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

Questo markup imposta l'attributo Source dell'elemento Frame con un URI di pacchetto per il Page cui inizialmente il Frame deve spostarsi.This markup sets the Source attribute of the Frame element with a pack URI for the Page that the Frame should initially navigate to. Nella figura seguente è illustrata un'applicazione XBAP con un Page con un Frame che è stato spostato tra più pagine.The following figure shows an XBAP with a Page that has a Frame that has navigated between several pages.

Frame che è stato spostato tra più pagineA frame that has navigated between multiple pages

Non è necessario usare solo Frame all'interno del contenuto di un Page.You don't only have to use Frame inside the content of a Page. È inoltre frequente ospitare un Frame all'interno del contenuto di un Window.It is also common to host a Frame inside the content of a Window.

Per impostazione predefinita, Frame utilizza solo il proprio journal in assenza di un altro Journal.By default, Frame only uses its own journal in the absence of another journal. Se un Frame fa parte del contenuto ospitato all'interno di un NavigationWindow o di un'applicazione XBAP, Frame utilizza il Journal che appartiene all'NavigationWindow o all'applicazione XBAP.If a Frame is part of content that is hosted inside either a NavigationWindow or an XBAP, Frame uses the journal that belongs to the NavigationWindow or XBAP. In alcuni casi, tuttavia, potrebbe essere necessario che un Frame sia responsabile del proprio journal.Sometimes, though, a Frame might need to be responsible for its own journal. Un motivo per farlo è consentire la navigazione nel journal all'interno delle pagine ospitate da un Frame.One reason to do so is to allow journal navigation within the pages that are hosted by a Frame. come illustrato nella figura seguente.This is illustrated by the following figure.

Diagramma frame e paginaFrame and Page diagram

In questo caso, è possibile configurare il Frame per utilizzare il proprio journal impostando la proprietà JournalOwnership della Frame su OwnsJournal.In this case, you can configure the Frame to use its own journal by setting the JournalOwnership property of the Frame to OwnsJournal. come illustrato nel markup seguente.This is shown in the following markup.

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

Nella figura seguente viene illustrato l'effetto della navigazione all'interno di un Frame che utilizza il proprio journal.The following figure illustrates the effect of navigating within a Frame that uses its own journal.

Un frame che usa il proprio journalA frame that uses its own journal

Si noti che le voci del journal sono visualizzate dal Interfaccia utenteUI di navigazione nel Frame, anziché da Internet Explorer.Notice that the journal entries are shown by the navigation Interfaccia utenteUI in the Frame, rather than by Internet Explorer.

Nota

Se un Frame fa parte del contenuto ospitato in una Window, Frame utilizza il proprio journal e, di conseguenza, Visualizza il proprio Interfaccia utenteUIdi navigazione.If a Frame is part of content that is hosted in a Window, Frame uses its own journal and, consequently, displays its own navigation Interfaccia utenteUI.

Se l'esperienza utente richiede un Frame per fornire il proprio journal senza visualizzare il Interfaccia utenteUIdi navigazione, è possibile nascondere il Interfaccia utenteUI di navigazione impostando il NavigationUIVisibility su Hidden.If your user experience requires a Frame to provide its own journal without showing the navigation Interfaccia utenteUI, you can hide the navigation Interfaccia utenteUI by setting the NavigationUIVisibility to Hidden. come illustrato nel markup seguente.This is shown in the following markup.

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

Frame e NavigationWindow sono classi note come host di navigazione.Frame and NavigationWindow are classes that are known as navigation hosts. Un host di navigazione è una classe che consente di passare al contenuto e visualizzarlo.A navigation host is a class that can navigate to and display content. A tale scopo, ogni host di navigazione usa i propri NavigationService e Journal.To accomplish this, each navigation host uses its own NavigationService and journal. La figura seguente illustra la costruzione di base di un host di navigazione.The basic construction of a navigation host is shown in the following figure.

Diagrammi dello strumento di navigazioneNavigator diagrams

Questo consente essenzialmente NavigationWindow e Frame fornire lo stesso supporto per la navigazione fornito da un'applicazione XBAP quando è ospitato nel browser.Essentially, this allows NavigationWindow and Frame to provide the same navigation support that an XBAP provides when hosted in the browser.

Oltre a usare NavigationService e un journal, gli host di navigazione implementano gli stessi membri che NavigationService implementa.Besides using NavigationService and a journal, navigation hosts implement the same members that NavigationService implements. come illustrato nella figura seguente.This is illustrated by the following figure.

Journal in un frame e in un oggetto NavigationWindowA journal in a Frame and in a NavigationWindow

Ciò consente di programmare un supporto specifico per la navigazione.This allows you to program navigation support directly against them. Questo può essere considerato se è necessario fornire un Interfaccia utenteUI di navigazione personalizzato per una Frame ospitata in un Window.You may consider this if you need to provide a custom navigation Interfaccia utenteUI for a Frame that is hosted in a Window. Inoltre, entrambi i tipi implementano membri aggiuntivi correlati alla navigazione, tra cui BackStack (NavigationWindow.BackStack, Frame.BackStack) e ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), che consentono di enumerare le voci del journal nello stack indietro e nello stack di avanzamento, rispettivamente.Furthermore, both types implement additional, navigation-related members, including BackStack (NavigationWindow.BackStack, Frame.BackStack) and ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), which allow you to enumerate the journal entries in the back stack and forward stack, respectively.

Come detto in precedenza, all'interno di un'applicazione possono essere presenti più journal.As mentioned earlier, more than one journal can exist within an application. Nella figura seguente viene fornito un esempio in proposito.The following figure provides an example of when this can happen.

Più journal all'interno di un'applicazioneMultiple journals within one application

In questo argomento Page e Pack XBAPs sono state utilizzate per illustrare le varie funzionalità di navigazione di WPF.Throughout this topic, Page and pack XBAPs have been used to demonstrate the various navigation capabilities of WPF. Tuttavia, una Page compilata in un'applicazione non è l'unico tipo di contenuto a cui è possibile accedere e Pack XBAPs non è l'unico modo per identificare il contenuto.However, a Page that is compiled into an application is not the only type of content that can be navigated to, and pack XBAPs aren't the only way to identify content.

Come illustrato in questa sezione, è anche possibile passare a Loose XAMLXAML files, file HTML e oggetti.As this section demonstrates, you can also navigate to loose XAMLXAML files, HTML files, and objects.

Un file di XAMLXAML separato è un file con le caratteristiche seguenti:A loose XAMLXAML file is a file with the following characteristics:

  • Contiene solo XAMLXAML (ovvero senza codice).Contains only XAMLXAML (that is, no code).

  • Ha una dichiarazione dello spazio dei nomi appropriata.Has an appropriate namespace declaration.

  • Usa xaml come estensione di file.Has the .xaml file name extension.

Si consideri, ad esempio, il contenuto seguente archiviato come file di XAMLXAML separato, Person. XAML.For example, consider the following content that is stored as a loose XAMLXAML file, Person.xaml.

<!-- Person.xaml -->
<TextBlock xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
  <TextBlock FontWeight="Bold">Name:</TextBlock>
  <TextBlock>Nancy Davolio</TextBlock>
  <LineBreak />
  <TextBlock FontWeight="Bold">Favorite Color:</TextBlock>
  <TextBlock>Yellow</TextBlock>
</TextBlock>

Se si fa doppio clic sul file, il browser si apre e passa al contenuto del file, visualizzandolo,When you double-click the file, the browser opens and navigates to and displays the content. come illustrato nella figura seguente.This is shown in the following figure.

Visualizzazione del contenuto nel file Person. XAMLDisplay of the content in the Person.XAML file

È possibile visualizzare un file di XAMLXAML separato dall'esempio seguente:You can display a loose XAMLXAML file from the following:

  • Un sito Web nel computer locale, nell'Intranet o su Internet.A Web site on the local machine, the intranet, or the Internet.

  • Una condivisione file di Universal Naming Convention (UNC).A Universal Naming Convention (UNC) file share.

  • Disco locale.The local disk.

È possibile aggiungere un file di XAMLXAML separato ai Preferiti del browser o essere l'home page del browser.A loose XAMLXAML file can be added to the browser's favorites, or be the browser's home page.

Nota

Per ulteriori informazioni sulla pubblicazione e sull'avvio di pagine XAMLXAML separate, vedere distribuzione di un'applicazione WPF.For more information about publishing and launching loose XAMLXAML pages, see Deploying a WPF Application.

Una limitazione rispetto alla XAMLXAML Loose è che è possibile ospitare solo contenuto sicuro per l'esecuzione in attendibilità parziale.One limitation with respect to loose XAMLXAML is that you can only host content that is safe to run in partial trust. Window, ad esempio, non può essere l'elemento radice di un file di XAMLXAML separato.For example, Window cannot be the root element of a loose XAMLXAML file. Per altre informazioni, vedere Sicurezza con attendibilità parziale in WPF.For more information, see WPF Partial Trust Security.

Come ci si potrebbe aspettare, è anche possibile passare al codice HTML.As you might expect, you can also navigate to HTML. È sufficiente specificare un URI che usa lo schema http.You simply need to provide a URI that uses the http scheme. Ad esempio, il XAMLXAML seguente mostra un Frame che consente di passare a una pagina HTML.For example, the following XAMLXAML shows a Frame that navigates to an HTML page.

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

Per passare al codice HTML sono necessarie autorizzazioni speciali.Navigating to HTML requires special permissions. Ad esempio, non è possibile spostarsi da un'applicazione XBAP in esecuzione nella sandbox di sicurezza con attendibilità parziale dell'area Internet.For example, you can't navigate from an XBAP that is running in the Internet zone partial trust security sandbox. Per altre informazioni, vedere Sicurezza con attendibilità parziale in WPF.For more information, see WPF Partial Trust Security.

Il controllo WebBrowser supporta l'interoperabilità tra documenti HTML, navigazione e script/codice gestito.The WebBrowser control supports HTML document hosting, navigation and script/managed code interoperability. Per informazioni dettagliate sul controllo WebBrowser, vedere WebBrowser.For detailed information regarding the WebBrowser control, see WebBrowser.

Come Frame, per passare al codice HTML con WebBrowser sono necessarie autorizzazioni speciali.Like Frame, navigating to HTML using WebBrowser requires special permissions. Ad esempio, da un'applicazione parzialmente attendibile, è possibile spostarsi solo in HTML che si trova nel sito di origine.For example, from a partial-trust application, you can navigate only to HTML located at the site of origin. Per altre informazioni, vedere Sicurezza con attendibilità parziale in WPF.For more information, see WPF Partial Trust Security.

Se sono presenti dati archiviati come oggetti personalizzati, un modo per visualizzare tali dati consiste nel creare un Page con contenuto associato a tali oggetti (vedere Cenni preliminari sul data binding).If you have data that is stored as custom objects, one way to display that data is to create a Page with content that is bound to those objects (see Data Binding Overview). Se invece si preferisce evitare di creare un'intera pagina al solo scopo di visualizzare gli oggetti, è possibile spostarsi direttamente su di essi.If you don't need the overhead of creating an entire page just to display the objects, you can navigate directly to them instead.

Si consideri la classe Person implementata nel codice seguente.Consider the Person class that is implemented in the following code.

using System.Windows.Media;

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

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

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

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

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

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

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

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

Per passare a tale metodo, chiamare il metodo NavigationWindow.Navigate, come dimostrato dal codice seguente.To navigate to it, you call the NavigationWindow.Navigate method, as demonstrated by the following code.

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

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

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

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

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

La figura seguente ne illustra il risultato.The following figure shows the result.

Pagina che passa a una classeA page that navigates to a class

Da questa figura risulta evidente che non vengono visualizzati elementi utili.From this figure, you can see that nothing useful is displayed. Il valore visualizzato è infatti il valore restituito del metodo ToString per l'oggetto Person . per impostazione predefinita, questo è l'unico valore che WPF può utilizzare per rappresentare l'oggetto.In fact, the value that is displayed is the return value of the ToString method for the Person object; by default, this is the only value that WPF can use to represent your object. È possibile eseguire l'override del metodo ToString per restituire informazioni più significative, sebbene sarà ancora un valore stringa.You could override the ToString method to return more meaningful information, although it will still only be a string value. Una tecnica che può essere usata per sfruttare le funzionalità di presentazione di WPF consiste nell'usare un modello di dati.One technique you can use that takes advantage of the presentation capabilities of WPF is to use a data template. È possibile implementare un modello di dati che WPF può associare a un oggetto di un determinato tipo.You can implement a data template that WPF can associate with an object of a particular type. Nel codice seguente viene illustrato un modello di dati per l'oggetto Person.The following code shows a data template for the Person object.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SDKSample" 
    x:Class="SDKSample.App"
    StartupUri="HomePage.xaml">

  <Application.Resources>

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

</Application>

In questo caso, il modello di dati è associato al tipo di Person usando l'estensione di markup x:Type nell'attributo DataType.Here, the data template is associated with the Person type by using the x:Type markup extension in the DataType attribute. Il modello di dati associa quindi TextBlock elementi (vedere TextBlock) alle proprietà della classe Person.The data template then binds TextBlock elements (see TextBlock) to the properties of the Person class. Nella figura seguente viene illustrato l'aspetto aggiornato dell'oggetto Person.The following figure shows the updated appearance of the Person object.

Spostamento a una classe che dispone di un modello di datiNavigating to a class that has a data template

Un vantaggio di questa tecnica è dato dalla coerenza: il modello di dati può infatti essere usato di nuovo per visualizzare gli oggetti in modo coerente nell'intero ambito dell'applicazione.An advantage of this technique is the consistency you gain by being able to reuse the data template to display your objects consistently anywhere in your application.

Per altre informazioni sui modelli di dati, vedere Cenni preliminarisui modelli di dati.For more information on data templates, see Data Templating Overview.

Sicurezza -Security

Il supporto per la navigazione WPF consente di passare a XBAPs in Internet e consente alle applicazioni di ospitare contenuto di terze parti.WPF navigation support allows XBAPs to be navigated to across the Internet, and it allows applications to host third-party content. Per proteggere le applicazioni e gli utenti dal comportamento dannoso, WPF fornisce un'ampia gamma di funzionalità di sicurezza descritte in sicurezza e sicurezza con attendibilità parziale in WPF.To protect both applications and users from harmful behavior, WPF provides a variety of security features that are discussed in Security and WPF Partial Trust Security.

Vedere ancheSee also