Información general sobre navegaciónNavigation Overview

Windows Presentation Foundation (WPF) admite la navegación de estilo explorador que se puede usar en dos tipos de aplicaciones: aplicaciones independientes y Aplicaciones del explorador XAML (XBAPs)XAML browser applications (XBAPs).Windows Presentation Foundation (WPF) supports browser-style navigation that can be used in two types of applications: standalone applications and Aplicaciones del explorador XAML (XBAPs)XAML browser applications (XBAPs). Para empaquetar el contenido para la navegación, WPFWPF proporciona la clase Page.To package content for navigation, WPFWPF provides the Page class. Puede desplazarse de un Page a otro mediante declaración, mediante un Hyperlink o mediante programación, mediante el uso de la NavigationService.You can navigate from one Page to another declaratively, by using a Hyperlink, or programmatically, by using the NavigationService. WPFWPF usa el diario para recordar las páginas desde las que se navegó o para volver a ellas.uses the journal to remember pages that have been navigated from and to navigate back to them.

Page, Hyperlink, NavigationService y el diario forman el núcleo de la compatibilidad de navegación que proporciona WPFWPF.Page, Hyperlink, NavigationService, and the journal form the core of the navigation support offered by WPFWPF. En esta información general se exploran estas características en detalle antes de cubrir la compatibilidad con la navegación avanzada, que incluye la navegación a archivos de Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) sueltos, archivos HTML y objetos.This overview explores these features in detail before covering advanced navigation support that includes navigation to loose Lenguaje XAML (Extensible Application Markup Language)Extensible Application Markup Language (XAML) files, HTML files, and objects.

Nota

En este tema, el término "explorador" solo se refiere a los exploradores que pueden hospedar aplicaciones WPFWPF, que actualmente incluye Microsoft Internet Explorer y Firefox.In this topic, the term "browser" refers only to browsers that can host WPFWPF applications, which currently includes Microsoft Internet Explorer and Firefox. Cuando solo un explorador concreto admite características de WPFWPF específicas, se hace referencia a la versión del explorador.Where specific WPFWPF features are supported only by a particular browser, the browser version is referred to.

En este tema se proporciona información general sobre las funcionalidades de navegación clave de WPFWPF.This topic provides an overview of the key navigation capabilities in WPFWPF. Estas funcionalidades están disponibles tanto para las aplicaciones independientes como para los XBAPsXBAPs, aunque en este tema se presentan en el contexto de un XBAPXBAP.These capabilities are available to both standalone applications and XBAPsXBAPs, although this topic presents them within the context of an XBAPXBAP.

Nota

En este tema no se explica cómo compilar e implementar XBAPsXBAPs.This topic doesn't discuss how to build and deploy XBAPsXBAPs. Para obtener más información sobre XBAPsXBAPs, consulte información general sobre las aplicaciones de explorador XAML de WPF.For more information on XBAPsXBAPs, see WPF XAML Browser Applications Overview.

En esta sección se describen y se muestran los siguientes aspectos de navegación:This section explains and demonstrates the following aspects of navigation:

Implementación de una páginaImplementing a Page

En WPFWPF, puede navegar a varios tipos de contenido que incluyen objetos .NET Framework, objetos personalizados, valores de enumeración, controles de usuario, archivos XAMLXAML y archivos HTML.In WPFWPF, you can navigate to several content types that include .NET Framework objects, custom objects, enumeration values, user controls, XAMLXAML files, and HTML files. Sin embargo, descubrirá que la manera más común y cómoda de empaquetar el contenido es mediante Page.However, you'll find that the most common and convenient way to package content is by using Page. Además, Page implementa características específicas de la navegación para mejorar su apariencia y simplificar el desarrollo.Furthermore, Page implements navigation-specific features to enhance their appearance and simplify development.

Con Page, puede implementar mediante declaración una página navegable de contenido de XAMLXAML mediante un marcado como el siguiente.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 que se implementa en XAMLXAML marcado tiene Page como su elemento raíz y requiere la declaración de espacio de nombres WPFWPF XMLXML.A Page that is implemented in XAMLXAML markup has Page as its root element and requires the WPFWPFXMLXML namespace declaration. El elemento Page contiene el contenido al que desea desplazarse y mostrarse.The Page element contains the content that you want to navigate to and display. El contenido se agrega estableciendo el elemento de propiedad Page.Content, como se muestra en el marcado siguiente.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 solo puede contener un elemento secundario; en el ejemplo anterior, el contenido es una sola cadena, "Hello, Page!".Page.Content can only contain one child element; in the preceding example, the content is a single string, "Hello, Page!" En la práctica, normalmente usará un control de diseño como el elemento secundario (vea diseño) para contener y componer el contenido.In practice, you will usually use a layout control as the child element (see Layout) to contain and compose your content.

Los elementos secundarios de un elemento Page se consideran el contenido de un Page y, por consiguiente, no es necesario utilizar la declaración de Page.Content explícita.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. La marcación siguiente es el equivalente declarativo del ejemplo anterior.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>

En este caso, Page.Content se establece automáticamente con los elementos secundarios del elemento Page.In this case, Page.Content is automatically set with the child elements of the Page element. Para obtener más información, consulte Modelo de contenido de WPF.For more information, see WPF Content Model.

Un Page de solo marcado es útil para mostrar el contenido.A markup-only Page is useful for displaying content. Sin embargo, un Page también puede mostrar controles que permiten a los usuarios interactuar con la página, y pueden responder a la interacción del usuario controlando los eventos y llamando a la lógica de la aplicación.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 interactivo se implementa mediante una combinación de marcado y código subyacente, como se muestra en el ejemplo siguiente.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

Para permitir que un archivo de marcación y un archivo de código subyacente funcionen juntos, se necesita la configuración siguiente:To allow a markup file and code-behind file to work together, the following configuration is required:

  • En el marcado, el elemento Page debe incluir el atributo x:Class.In markup, the Page element must include the x:Class attribute. Cuando se compila la aplicación, la existencia de x:Class en el archivo de marcado hace que el motor de compilación de Microsoft (MSBuild) cree una partial clase que deriva de Page y tiene el nombre especificado por el atributo 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. Esto requiere la adición de una declaración de espacio de nombres XMLXML para el esquema de XAMLXAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").This requires the addition of an XMLXML namespace declaration for the XAMLXAML schema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). La clase partial generada implementa InitializeComponent, a la que se llama para registrar los eventos y establecer las propiedades que se implementan en el marcado.The generated partial class implements InitializeComponent, which is called to register the events and set the properties that are implemented in markup.

  • En el código subyacente, la clase debe ser una partial clase con el mismo nombre especificado por el atributo x:Class en el marcado y debe derivar de 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. Esto permite asociar el archivo de código subyacente a la clase partial que se genera para el archivo de marcado cuando se compila la aplicación (consulte compilar una aplicación 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).

  • En el código subyacente, la clase Page debe implementar un constructor que llame al método InitializeComponent.In code-behind, the Page class must implement a constructor that calls the InitializeComponent method. la clase partial generada por el archivo de marcado implementa InitializeComponent para registrar eventos y establecer las propiedades que se definen en el marcado.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Nota

Cuando se agrega un nuevo Page al proyecto mediante Microsoft Visual StudioMicrosoft Visual Studio, el Page se implementa mediante el marcado y el código subyacente, e incluye la configuración necesaria para crear la asociación entre el marcado y los archivos de código subyacente, como se describe aquí.When you add a new Page to your project using Microsoft Visual StudioMicrosoft 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.

Una vez que tenga un Page, puede desplazarse hasta él.Once you have a Page, you can navigate to it. Para especificar el primer Page al que navega una aplicación, debe configurar el Page de inicio.To specify the first Page that an application navigates to, you need to configure the start Page.

Configuración de una página de inicioConfiguring a Start Page

XBAPsXBAPs requieren que se hospede una determinada cantidad de infraestructuras de aplicaciones en un explorador.require a certain amount of application infrastructure to be hosted in a browser. En WPFWPF, la clase Application forma parte de una definición de aplicación que establece la infraestructura de aplicación necesaria (consulte información general sobre la administración de aplicaciones).In WPFWPF, the Application class is part of an application definition that establishes the required application infrastructure (see Application Management Overview).

Normalmente, una definición de aplicación se implementa mediante el marcado y el código subyacente, con el archivo de marcado configurado como un elemento de ApplicationDefinition de MSBuild.An application definition is usually implemented using both markup and code-behind, with the markup file configured as an MSBuildApplicationDefinition item. La siguiente es una definición de aplicación para un XBAPXBAP.The following is an application definition for an XBAPXBAP.

<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 XBAPXBAP puede utilizar su definición de aplicación para especificar una Page de inicio, que es el Page que se carga automáticamente cuando se inicia el XBAPXBAP.An XBAPXBAP can use its application definition to specify a start Page, which is the Page that is automatically loaded when the XBAPXBAP is launched. Para ello, establezca la propiedad StartupUri con el identificador uniforme de recursos (URI) para el Page deseado.You do this by setting the StartupUri property with the uniform resource identifier (URI) for the desired Page.

Nota

En la mayoría de los casos, los Page se compilan o se implementan con una aplicación.In most cases, the Page is either compiled into or deployed with an application. En estos casos, el URI que identifica una Page es un Pack URI, que es un URI que se ajusta al esquema del paquete .In these cases, the URI that identifies a Page is a pack URI, which is a URI that conforms to the pack scheme. Los URI de los paquetes se describen con más detalle en pack uri en WPF.Pack URIs are discussed further in Pack URIs in WPF. También puede navegar al contenido con el esquema HTTP, que se describe a continuación.You can also navigate to content using the http scheme, which is discussed below.

Puede establecer StartupUri mediante declaración en el marcado, tal como se muestra en el ejemplo siguiente.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" />

En este ejemplo, el atributo StartupUri se establece con un Pack URI relativo que identifica HomePage. Xaml.In this example, the StartupUri attribute is set with a relative pack URI that identifies HomePage.xaml. Cuando se inicia el XBAPXBAP, se navega a HomePage. XAML y se muestra automáticamente.When the XBAPXBAP is launched, HomePage.xaml is automatically navigated to and displayed. Esto se muestra en la siguiente ilustración, que muestra una XBAPXBAP que se inició desde un servidor Web.This is demonstrated by the following figure, which shows an XBAPXBAP that was launched from a Web server.

Página de XBAPXBAP page

Nota

Para obtener más información sobre el desarrollo y la implementación de XBAPsXBAPs, vea información general sobre las aplicaciones de explorador XAML de WPF e implementar una aplicación de WPF.For more information regarding the development and deployment of XBAPsXBAPs, see WPF XAML Browser Applications Overview and Deploying a WPF Application.

Configuración del título, el ancho y el alto de la ventana hostConfiguring the Host Window's Title, Width, and Height

Una cosa que puede haber observado en la ilustración anterior es que el título del explorador y del panel de pestañas es el URI del XBAPXBAP.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 XBAPXBAP. Además de largo, el título no es atractivo ni informativo.Besides being long, the title is neither attractive nor informative. Por esta razón, Page ofrece una forma de cambiar el título estableciendo la propiedad WindowTitle.For this reason, Page offers a way for you to change the title by setting the WindowTitle property. Además, puede configurar el ancho y el alto de la ventana del explorador estableciendo WindowWidth y WindowHeight, respectivamente.Furthermore, you can configure the width and height of the browser window by setting WindowWidth and WindowHeight, respectively.

WindowTitle, WindowWidth y WindowHeight se pueden establecer mediante declaración en el marcado, tal y como se muestra en el ejemplo siguiente.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>

El resultado se muestra en la ilustración siguiente.The result is shown in the following figure.

Título, alto y ancho de la ventanaWindow title, height, width

Una XBAPXBAP típica consta de varias páginas.A typical XBAPXBAP comprises several pages. La manera más sencilla de desplazarse de una página a otra consiste en usar una Hyperlink.The simplest way to navigate from one page to another is to use a Hyperlink. Puede agregar mediante declaración una Hyperlink a una Page mediante el elemento Hyperlink, que se muestra en el marcado siguiente.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>

Un elemento Hyperlink requiere lo siguiente:A Hyperlink element requires the following:

  • Pack URI del Page al que se va a desplazar, tal y como especifica el atributo NavigateUri.The pack URI of the Page to navigate to, as specified by the NavigateUri attribute.

  • Contenido en el que un usuario puede hacer clic para iniciar la navegación, como texto e imágenes (para el contenido que puede contener el elemento Hyperlink, vea 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).

En la ilustración siguiente se muestra un XBAPXBAP con un Page que tiene una Hyperlink.The following figure shows an XBAPXBAP with a Page that has a Hyperlink.

Página con hipervínculoPage with Hyperlink

Como cabría esperar, al hacer clic en el Hyperlink hace que el XBAPXBAP navegue hasta el Page identificado por el atributo NavigateUri.As you would expect, clicking the Hyperlink causes the XBAPXBAP to navigate to the Page that is identified by the NavigateUri attribute. Además, el XBAPXBAP agrega una entrada para el Page anterior a la lista de páginas recientes en Internet Explorer.Additionally, the XBAPXBAP adds an entry for the previous Page to the Recent Pages list in Internet Explorer. Esto se muestra en la siguiente ilustración.This is shown in the following figure.

Botones atrás y adelanteBack and Forward buttons

Además de permitir la navegación de un Page a otro, Hyperlink también admite la navegación por fragmentos.As well as supporting navigation from one Page to another, Hyperlink also supports fragment navigation.

Navegación por fragmentosFragment Navigation

La navegación por fragmentos es la navegación a un fragmento de contenido en el Page actual u otro Page.Fragment navigation is the navigation to a content fragment in either the current Page or another Page. En WPFWPF, un fragmento de contenido es el contenido incluido en un elemento con nombre.In WPFWPF, a content fragment is the content that is contained by a named element. Un elemento con nombre es un elemento que tiene su conjunto de atributos Name.A named element is an element that has its Name attribute set. En el marcado siguiente se muestra un elemento de TextBlock con nombre que contiene un fragmento de contenido.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>

Para una Hyperlink para navegar a un fragmento de contenido, el atributo NavigateUri debe incluir lo siguiente:For a Hyperlink to navigate to a content fragment, the NavigateUri attribute must include the following:

  • URI del Page con el fragmento de contenido al que se va a navegar.The URI of the Page with the content fragment to navigate to.

  • Un carácter "#".A "#" character.

  • Nombre del elemento en el Page que contiene el fragmento de contenido.The name of the element on the Page that contains the content fragment.

Un identificador URI de fragmento tiene el formato siguiente.A fragment URI has the following format.

PageURI # ElementNamePageURI # ElementName

A continuación se muestra un ejemplo de una Hyperlink que está configurada para navegar a un fragmento de contenido.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

En esta sección se describe la implementación de navegación por fragmentos predeterminada en WPFWPF.This section describes the default fragment navigation implementation in WPFWPF. WPFWPF también le permite implementar su propio esquema de navegación por fragmentos, que, en parte, requiere el control del evento NavigationService.FragmentNavigation.also allows you to implement your own fragment navigation scheme which, in part, requires handling the NavigationService.FragmentNavigation event.

Importante

Puede desplazarse hasta fragmentos en páginas de XAMLXAML sueltos (solo archivos de XAMLXAML de marcado con Page como elemento raíz) si las páginas se pueden examinar a través de 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.

Sin embargo, una página XAMLXAML floja puede desplazarse a sus propios fragmentos.However, a loose XAMLXAML page can navigate to its own fragments.

Aunque Hyperlink permite a un usuario iniciar la navegación a un Page determinado, la clase NavigationService realiza el trabajo de buscar y descargar la página.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. Esencialmente, NavigationService proporciona la capacidad de procesar una solicitud de navegación en nombre del código de cliente, como el Hyperlink.Essentially, NavigationService provides the ability to process a navigation request on behalf of client code, such as the Hyperlink. Además, NavigationService implementa compatibilidad de nivel superior para realizar el seguimiento e influir en una solicitud de navegación.Additionally, NavigationService implements higher-level support for tracking and influencing a navigation request.

Cuando se hace clic en un Hyperlink, WPFWPF llama NavigationService.Navigate para buscar y descargar la Page en el URI del paquete especificado.When a Hyperlink is clicked, WPFWPF calls NavigationService.Navigate to locate and download the Page at the specified pack URI. El Page descargado se convierte en un árbol de objetos cuyo objeto raíz es una instancia del Page descargado.The downloaded Page is converted to a tree of objects whose root object is an instance of the downloaded Page. Una referencia al objeto Page raíz se almacena en la propiedad NavigationService.Content.A reference to the root Page object is stored in the NavigationService.Content property. El URI del paquete para el contenido al que se navegó se almacena en la propiedad NavigationService.Source, mientras que la NavigationService.CurrentSource almacena el Pack URI de la última página a la que se navegó.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

Es posible que una aplicación WPFWPF tenga más de una NavigationService activa actualmente.It is possible for a WPFWPF application to have more than one currently active NavigationService. Para obtener más información, vea hosts de navegación más adelante en este tema.For more information, see Navigation Hosts later in this topic.

Navegación programática con el servicio de navegaciónProgrammatic Navigation with the Navigation Service

No es necesario saber NavigationService si la navegación se implementa mediante declaración en el marcado mediante Hyperlink, porque Hyperlink usa el NavigationService en su nombre.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. Esto significa que, siempre que el elemento primario directo o indirecto de un Hyperlink sea un host de navegación (consulte hosts de navegación), Hyperlink podrá encontrar y usar el servicio de navegación del host de navegación para procesar una solicitud de navegación.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.

Sin embargo, hay situaciones en las que es necesario usar NavigationService directamente, entre las que se incluyen las siguientes:However, there are situations when you need to use NavigationService directly, including the following:

  • Cuando necesite crear una instancia de un Page mediante un constructor sin parámetros.When you need to instantiate a Page using a non-parameterless constructor.

  • Cuando necesite establecer propiedades en el Page antes de navegar a él.When you need to set properties on the Page before you navigate to it.

  • Cuando el Page al que debe navegarse solo se puede determinar en tiempo de ejecución.When the Page that needs to be navigated to can only be determined at run time.

En estas situaciones, debe escribir código para iniciar la navegación mediante programación llamando al método Navigate del objeto NavigationService.In these situations, you need to write code to programmatically initiate navigation by calling the Navigate method of the NavigationService object. Esto requiere obtener una referencia a un NavigationService.That requires getting a reference to a NavigationService.

Obtención de una referencia a NavigationServiceGetting a Reference to the NavigationService

Por motivos que se describen en la sección hosts de navegación , una aplicación WPFWPF puede tener más de un NavigationService.For reasons that are covered in the Navigation Hosts section, a WPFWPF application can have more than one NavigationService. Esto significa que el código necesita una manera de buscar un NavigationService, que suele ser el NavigationService que navega hasta el Page actual.This means that your code needs a way to find a NavigationService, which is usually the NavigationService that navigated to the current Page. Puede obtener una referencia a un NavigationService llamando al método NavigationService.GetNavigationService static.You can get a reference to a NavigationService by calling the staticNavigationService.GetNavigationService method. Para obtener el NavigationService que navegó a un Page determinado, se pasa una referencia a la Page como el argumento del método 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. En el código siguiente se muestra cómo obtener el NavigationService para la Page actual.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)

Como método abreviado para buscar el NavigationService para un Page, Page implementa la propiedad NavigationService.As a shortcut for finding the NavigationService for a Page, Page implements the NavigationService property. Esta implementación se muestra en el ejemplo siguiente.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 solo puede obtener una referencia a su NavigationService cuando Page provoca el evento de Loaded.A Page can only get a reference to its NavigationService when Page raises the Loaded event.

Navegación programática a un objeto de páginaProgrammatic Navigation to a Page Object

En el ejemplo siguiente se muestra cómo utilizar el NavigationService para desplazarse a un Page mediante programación.The following example shows how to use the NavigationService to programmatically navigate to a Page. La navegación mediante programación es necesaria porque solo se puede crear una instancia de la Page a la que se está navegando mediante un solo constructor sin parámetros.Programmatic navigation is required because the Page that is being navigated to can only be instantiated using a single, non-parameterless constructor. El Page con el constructor sin parámetros se muestra en el marcado y el código siguientes.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

El Page que navega al Page con el constructor sin parámetros se muestra en el marcado y el código siguientes.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

Cuando se hace clic en el Hyperlink de este Page, la navegación se inicia creando una instancia de la Page para navegar hasta usar el constructor sin parámetros y llamar al método 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 acepta una referencia al objeto al que se va a desplazar el NavigationService, en lugar de un Pack URI.Navigate accepts a reference to the object that the NavigationService will navigate to, rather than a pack URI.

Navegación programática con Pack URIProgrammatic Navigation with a Pack URI

Si necesita crear un Pack URI mediante programación (cuando solo puede determinar el URI del paquete en tiempo de ejecución, por ejemplo), puede usar el método 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. Esta implementación se muestra en el ejemplo siguiente.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

Actualización de la página actualRefreshing the Current Page

No se descarga un Page si tiene el mismo Pack URI que el URI del paquete que se almacena en la propiedad 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. Para forzar que WPFWPF Descargue la página actual de nuevo, puede llamar al método NavigationService.Refresh, tal y como se muestra en el ejemplo siguiente.To force WPFWPF 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

Hay muchas maneras de iniciar la navegación, tal como ha podido ver.There are many ways to initiate navigation, as you've seen. Cuando se inicia la navegación y mientras la navegación está en curso, puede realizar un seguimiento e influir en la navegación mediante los siguientes eventos implementados por 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:

  • NavigatingOperadorNavigating. Se produce cuando se solicita una nueva navegación.Occurs when a new navigation is requested. Puede utilizarse para cancelar la navegación.Can be used to cancel the navigation.

  • NavigationProgressOperadorNavigationProgress. Se produce periódicamente durante una descarga y ofrece información sobre el progreso de la exploración.Occurs periodically during a download to provide navigation progress information.

  • NavigatedOperadorNavigated. Se produce cuando se ha encontrado la página y se ha descargado.Occurs when the page has been located and downloaded.

  • NavigationStoppedOperadorNavigationStopped. Se produce cuando se detiene la navegación (llamando a StopLoading) o cuando se solicita una nueva navegación mientras está en curso una navegación actual.Occurs when the navigation is stopped (by calling StopLoading), or when a new navigation is requested while a current navigation is in progress.

  • NavigationFailedOperadorNavigationFailed. Se produce cuando se genera un error mientras se navega por el contenido solicitado.Occurs when an error is raised while navigating to the requested content.

  • LoadCompletedOperadorLoadCompleted. Se produce cuando el contenido al que se navegó se carga y se analiza, y empieza a representarse.Occurs when content that was navigated to is loaded and parsed, and has begun rendering.

  • FragmentNavigationOperadorFragmentNavigation. Se produce cuando se inicia la navegación a un fragmento de contenido, cosa que tiene lugar:Occurs when navigation to a content fragment begins, which happens:

    • Inmediatamente, si el fragmento deseado está en el contenido actual.Immediately, if the desired fragment is in the current content.

    • Una vez se ha cargado el contenido de origen, si el fragmento deseado está en otro contenido.After the source content has been loaded, if the desired fragment is in different content.

Los eventos de navegación se generan en el orden que se muestra en la ilustración siguiente.The navigation events are raised in the order that is illustrated by the following figure.

Diagrama de flujo de navegación de páginasPage navigation flow chart

En general, un Page no se preocupa de estos eventos.In general, a Page isn't concerned about these events. Es más probable que una aplicación esté relacionada con ellos y, por ese motivo, estos eventos también se generan mediante la clase 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:

Cada vez que NavigationService genera un evento, la clase Application genera el evento correspondiente.Every time NavigationService raises an event, the Application class raises the corresponding event. Frame y NavigationWindow ofrecen los mismos eventos para detectar la navegación dentro de sus respectivos ámbitos.Frame and NavigationWindow offer the same events to detect navigation within their respective scopes.

En algunos casos, un Page podría estar interesado en estos eventos.In some cases, a Page might be interested in these events. Por ejemplo, un Page podría controlar el evento NavigationService.Navigating para determinar si cancelar o no la navegación fuera de sí mismo.For example, a Page might handle the NavigationService.Navigating event to determine whether or not to cancel navigation away from itself. Esta implementación se muestra en el ejemplo siguiente.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

Si registra un controlador con un evento de navegación desde un Page, como en el ejemplo anterior, también debe anular el registro del controlador de eventos.If you register a handler with a navigation event from a Page, as the preceding example does, you must also unregister the event handler. Si no lo hace, puede haber efectos secundarios con respecto a la forma en que WPFWPF navegación recuerda Page navegación mediante el diario.If you don't, there may be side effects with respect to how WPFWPF navigation remembers Page navigation using the journal.

Registro de la navegación con el diarioRemembering Navigation with the Journal

WPFWPF usa dos pilas para recordar las páginas desde las que ha navegado: una pila de retroceso y una pila de avance.uses two stacks to remember the pages that you have navigated from: a back stack and a forward stack. Al desplazarse desde el Page actual a un nuevo Page o reenviar a un Page existente, el Page actual se agrega a la pila de retroceso.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. Cuando se desplaza desde el Page actual hasta el Page anterior, se agrega la Page actual a la pila de avance.When you navigate from the current Page back to the previous Page, the current Page is added to the forward stack. La pila de retroceso, la pila de avance y la funcionalidad para administrarlas se conocen en conjunto como el diario.The back stack, the forward stack, and the functionality to manage them, are collectively referred to as the journal. Cada elemento de la pila de retroceso y la pila de reenvío es una instancia de la JournalEntry clase y se conoce como una entrada de diario.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.

Conceptualmente, el diario funciona de la misma manera que los botones atrás y adelante de Internet Explorer.Conceptually, the journal operates the same way that the Back and Forward buttons in Internet Explorer do. Esto se muestra en la siguiente ilustración.These are shown in the following figure.

Botones atrás y adelanteBack and Forward buttons

En el caso de XBAPsXBAPs hospedado por Internet Explorer, WPFWPF integra el diario en la IUUI de navegación de Internet Explorer.For XBAPsXBAPs that are hosted by Internet Explorer, WPFWPF integrates the journal into the navigation IUUI of Internet Explorer. Esto permite a los usuarios navegar por las páginas de un XBAPXBAP mediante los botones de página atrás, adelantey reciente de Internet Explorer.This allows users to navigate pages in an XBAPXBAP by using the Back, Forward, and Recent Pages buttons in Internet Explorer.

Importante

En Internet Explorer, cuando un usuario navega y vuelve a un XBAPXBAP, solo se conservan en el diario las entradas del diario de las páginas que no se mantuvieron activas.In Internet Explorer, when a user navigates away from and back to an XBAPXBAP, only the journal entries for pages that were not kept alive are retained in the journal. Para obtener información sobre cómo mantener las páginas activas, vea duración de la página y el diario más adelante en este tema.For discussion on keeping pages alive, see Page Lifetime and the Journal later in this topic.

De forma predeterminada, el texto de cada Page que aparece en la lista de páginas recientes de Internet Explorer es el 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. En muchos casos, esto no es especialmente significativo para el usuario.In many cases, this is not particularly meaningful to the user. Afortunadamente, puede cambiar el texto mediante una de las siguientes opciones:Fortunately, you can change the text using one the following options:

  1. El valor del atributo JournalEntry.Name adjunto.The attached JournalEntry.Name attribute value.

  2. Valor del atributo Page.Title.The Page.Title attribute value.

  3. El valor del atributo Page.WindowTitle y el URI de la Page actual.The Page.WindowTitle attribute value and the URI for the current Page.

  4. URI del Page actual.The URI for the current Page. (Predeterminado)(Default)

El orden en que se enumeran las opciones coincide con el orden de prioridad para buscar el texto.The order in which the options are listed matches the order of precedence for finding the text. Por ejemplo, si se establece JournalEntry.Name, se omiten los demás valores.For example, if JournalEntry.Name is set, the other values are ignored.

En el ejemplo siguiente se utiliza el atributo Page.Title para cambiar el texto que aparece para una entrada del diario.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

Aunque un usuario puede navegar por el diario mediante las páginas atrás, adelantey recientes de Internet Explorer, también puede navegar por el diario utilizando los mecanismos declarativos y de programación proporcionados por WPFWPF.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 WPFWPF. Una razón para ello es proporcionar interfaces de IU de navegación personalizadas en las páginas.One reason to do this is to provide custom navigation UIs in your pages.

Puede agregar mediante declaración la compatibilidad de navegación del diario mediante los comandos de navegación expuestos por NavigationCommands.You can declaratively add journal navigation support by using the navigation commands exposed by NavigationCommands. En el ejemplo siguiente se muestra cómo usar el comando de navegación 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>

Puede navegar por el diario mediante programación con uno de los siguientes miembros de la clase NavigationService:You can programmatically navigate the journal by using one of the following members of the NavigationService class:

El diario también se puede manipular mediante programación, como se describe en retener el estado del contenido con el historial de navegación , más adelante en este tema.The journal can also be manipulated programmatically, as discussed in Retaining Content State with Navigation History later in this topic.

Duración de la página y el diarioPage Lifetime and the Journal

Considere una XBAPXBAP con varias páginas que contienen contenido enriquecido, como gráficos, animaciones y elementos multimedia.Consider an XBAPXBAP with several pages that contain rich content, including graphics, animations, and media. La superficie de memoria de este tipo de páginas podría ser bastante grande, especialmente si se usan elementos multimedia de audio y vídeo.The memory footprint for pages like these could be quite large, particularly if video and audio media are used. Dado que el diario "recuerda" las páginas a las que se ha navegado, este tipo de XBAPXBAP podría consumir rápidamente una cantidad de memoria grande y notable.Given that the journal "remembers" pages that have been navigated to, such an XBAPXBAP could quickly consume a large and noticeable amount of memory.

Por esta razón, el comportamiento predeterminado del diario es almacenar Page metadatos en cada entrada del diario en lugar de una referencia a un objeto 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. Cuando se navega a una entrada del diario, sus metadatos de Page se usan para crear una nueva instancia del Page especificado.When a journal entry is navigated to, its Page metadata is used to create a new instance of the specified Page. Como consecuencia, cada Page a la que se navega tiene la duración que se muestra en la ilustración siguiente.As a consequence, each Page that is navigated has the lifetime that is illustrated by the following figure.

Duración de la páginaPage lifetime

Aunque el uso del comportamiento de diario predeterminado puede ahorrar en el consumo de memoria, el rendimiento de la representación por página podría reducirse; la creación de instancias de un Page puede llevar mucho tiempo, especialmente si tiene una gran cantidad de contenido.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. Si necesita conservar una instancia de Page en el diario, puede dibujar dos técnicas para hacerlo.If you need to retain a Page instance in the journal, you can draw on two techniques for doing so. En primer lugar, puede navegar mediante programación a un objeto Page llamando al método NavigationService.Navigate.First, you can programmatically navigate to a Page object by calling the NavigationService.Navigate method.

En segundo lugar, puede especificar que WPFWPF conservar una instancia de un Page en el diario estableciendo la propiedad KeepAlive en true (el valor predeterminado es false).Second, you can specify that WPFWPF retain an instance of a Page in the journal by setting the KeepAlive property to true (the default is false). Como se muestra en el ejemplo siguiente, puede establecer KeepAlive mediante declaración en el marcado.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>

La duración de un Page que se mantiene activo es ligeramente diferente de la que no lo es.The lifetime of a Page that is kept alive is subtly different from one that is not. La primera vez que se navega a un Page que se mantiene activo, se crea una instancia como una Page que no se mantiene activa.The first time a Page that is kept alive is navigated to, it is instantiated just like a Page that is not kept alive. Sin embargo, dado que una instancia del Page se conserva en el diario, nunca se vuelve a crear una instancia de, siempre y cuando permanezca en el diario.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. Por consiguiente, si un Page tiene lógica de inicialización que debe llamarse cada vez que se navega a la Page, debe moverla del constructor a un controlador para el evento 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. Como se muestra en la ilustración siguiente, los eventos Loaded y Unloaded se siguen generando cada vez que se navega a un Page y desde, respectivamente.As shown in the following figure, the Loaded and Unloaded events are still raised each time a Page is navigated to and from, respectively.

Cuando se producen los eventos Loaded y UnloadedWhen the Loaded and Unloaded events are raised

Cuando un Page no se mantiene activo, no debe realizar ninguna de las siguientes acciones:When a Page is not kept alive, you should not do either of the following:

  • Almacenar una referencia a la base de datos ni ninguna parte de esta.Store a reference to it, or any part of it.

  • Registrar controladores de eventos con eventos que no haya implementado.Register event handlers with events that are not implemented by it.

Al realizar cualquiera de estas acciones se crearán referencias que obligan a que el Page se conserve en la memoria, incluso después de que se haya quitado del diario.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.

En general, debería preferir el comportamiento predeterminado Page de no mantener un Page activo.In general, you should prefer the default Page behavior of not keeping a Page alive. Sin embargo, esto conlleva implicaciones de estado que se describen en la sección siguiente.However, this has state implications that are discussed in the next section.

Conservación del estado del contenido con el historial de navegaciónRetaining Content State with Navigation History

Si un Page no se mantiene activo y tiene controles que recopilan datos del usuario, ¿qué ocurre con los datos si un usuario sale de la Page y vuelve a ella?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? Desde la perspectiva de una experiencia de usuario, el usuario debería ver los datos que especificó anteriormente.From a user experience perspective, the user should expect to see the data they entered previously. Desafortunadamente, dado que se crea una nueva instancia de la Page con cada navegación, se vuelve a crear una instancia de los controles que recopilaron los datos y se pierden los datos.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.

Afortunadamente, el diario proporciona compatibilidad para recordar datos a través de Page navegaciones, incluidos los datos de control.Fortunately, the journal provides support for remembering data across Page navigations, including control data. En concreto, la entrada de diario para cada Page actúa como un contenedor temporal para el estado de Page asociado.Specifically, the journal entry for each Page acts as a temporary container for the associated Page state. En los pasos siguientes se describe cómo se usa esta compatibilidad cuando se navega desde un Page:The following steps outline how this support is used when a Page is navigated from:

  1. Se agrega una entrada para el Page actual al diario.An entry for the current Page is added to the journal.

  2. El estado de la Page se almacena con la entrada de diario de esa página, que se agrega a la pila de retroceso.The state of the Page is stored with the journal entry for that page, which is added to the back stack.

  3. Se navega a la nueva Page.The new Page is navigated to.

Cuando se vuelve a navegar a la página Page, con el diario, se llevan a cabo los siguientes pasos:When the page Page is navigated back to, using the journal, the following steps take place:

  1. Se crea una instancia del Page (la entrada del diario superior en la pila de retroceso).The Page (the top journal entry on the back stack) is instantiated.

  2. El Page se actualiza con el estado que se almacenó con la entrada de diario para el Page.The Page is refreshed with the state that was stored with the journal entry for the Page.

  3. Se vuelve a navegar a la Page.The Page is navigated back to.

WPFWPF usa automáticamente esta compatibilidad cuando se utilizan los siguientes controles en un Page:automatically uses this support when the following controls are used on a Page:

Si una Page utiliza estos controles, los datos que se escriben en ellos se recuerdan en Page navegaciones, como se muestra en el ListBox de colores favorito de la ilustración siguiente.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.

Página con controles que recuerdan el estadoPage with controls that remember state

Cuando un Page tiene controles distintos de los de la lista anterior, o cuando el estado se almacena en objetos personalizados, debe escribir código para hacer que el diario recuerde el estado en las navegaciones Page.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.

Si necesita recordar pequeños fragmentos de estado en Page navegaciones, puede usar las propiedades de dependencia (consulte DependencyProperty) configuradas con la marca de metadatos 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.

Si el estado que debe recordar el Page entre las navegaciones consta de varios fragmentos de datos, puede que le resulte menos intenso el código para encapsular su estado en una sola clase e implementar la interfaz de 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.

Si necesita navegar por varios Estados de una sola Page, sin navegar por el Page mismo, puede usar IProvideCustomContentState y 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.

CookiesCookies

Otra forma en que WPFWPF aplicaciones pueden almacenar datos es con las cookies, que se crean, actualizan y eliminan mediante los métodos SetCookie y GetCookie.Another way that WPFWPF applications can store data is with cookies, which are created, updated, and deleted by using the SetCookie and GetCookie methods. Las cookies que se pueden crear en WPFWPF son las mismas cookies que usan otros tipos de aplicaciones Web. las cookies son fragmentos arbitrarios de datos que se almacenan en una aplicación en un equipo cliente durante o a través de sesiones de aplicación.The cookies that you can create in WPFWPF 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. Los datos de las cookies normalmente adoptan la forma de un par de nombre-valor en el formato siguiente.Cookie data typically takes the form of a name/value pair in the following format.

Name = ValueName = Value

Cuando los datos se pasan a SetCookie, junto con el Uri de la ubicación para la que se debe establecer la cookie, se crea una cookie en memoria y solo está disponible mientras dure la sesión de aplicación actual.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. Este tipo de cookie se conoce como cookie de sesión.This type of cookie is referred to as a session cookie.

Para almacenar una cookie mediante sesiones de la aplicación, debe agregarse una fecha de expiración para la cookie, con el formato siguiente.To store a cookie across application sessions, an expiration date must be added to the cookie, using the following format.

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

Una cookie con una fecha de expiración se almacena en la carpeta de archivos temporales de Internet de la instalación actual de Windows hasta que expire la cookie.A cookie with an expiration date is stored in the current Windows installation's Temporary Internet Files folder until the cookie expires. Este tipo de cookie se conoce como cookie persistente porque se conserva entre las sesiones de la aplicación.Such a cookie is known as a persistent cookie because it persists across application sessions.

Puede recuperar las cookies de sesión y persistentes llamando al método GetCookie, pasando el Uri de la ubicación en la que se estableció la cookie con el método 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.

A continuación se muestran algunas de las formas en las que se admiten las cookies en WPFWPF:The following are some of the ways that cookies are supported in WPFWPF:

  • WPFWPF aplicaciones y XBAPsXBAPs independientes pueden crear y administrar cookies.standalone applications and XBAPsXBAPs can both create and manage cookies.

  • Se puede tener acceso a las cookies creadas por un XBAPXBAP desde el explorador.Cookies that are created by an XBAPXBAP can be accessed from the browser.

  • XBAPsXBAPs del mismo dominio puede crear y compartir cookies.from the same domain can create and share cookies.

  • XBAPsXBAPs y las páginas HTML del mismo dominio pueden crear y compartir cookies.and HTML pages from the same domain can create and share cookies.

  • Las cookies se envían cuando XBAPsXBAPs y las páginas XAMLXAML sueltas realizan solicitudes Web.Cookies are dispatched when XBAPsXBAPs and loose XAMLXAML pages make Web requests.

  • Tanto XBAPsXBAPs de nivel superior como XBAPsXBAPs hospedado en IFRAMEs pueden tener acceso a las cookies.Both top-level XBAPsXBAPs and XBAPsXBAPs hosted in IFRAMES can access cookies.

  • La compatibilidad con cookies en WPFWPF es la misma para todos los exploradores compatibles.Cookie support in WPFWPF is the same for all supported browsers.

  • En Internet Explorer, la Directiva de P3P que pertenece a las cookies se respeta en WPFWPF, especialmente con respecto a la XBAPsXBAPs de terceros y de otros fabricantes.In Internet Explorer, P3P policy that pertains to cookies is honored by WPFWPF, particularly with respect to first-party and third-party XBAPsXBAPs.

Navegación estructuradaStructured Navigation

Si necesita pasar datos de un Page a otro, puede pasar los datos como argumentos a un constructor sin parámetros de la 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. Tenga en cuenta que si utiliza esta técnica, debe mantener el Page activo; Si no es así, la próxima vez que navegue al Page, WPFWPF vuelve a crear una instancia del Page mediante el constructor sin parámetros.Note that if you use this technique, you must keep the Page alive; if not, the next time you navigate to the Page, WPFWPF reinstantiates the Page by using the parameterless constructor.

Como alternativa, el Page puede implementar propiedades que se establecen con los datos que es necesario pasar.Alternatively, your Page can implement properties that are set with the data that needs to be passed. Sin embargo, las cosas son complicadas, cuando una Page tiene que devolver los datos al Page que ha navegado hasta él.Things become tricky, however, when a Page needs to pass data back to the Page that navigated to it. El problema es que la navegación no admite de forma nativa mecanismos para garantizar que un Page se devolverá después de que se navegue desde.The problem is that navigation doesn't natively support mechanisms for guaranteeing that a Page will be returned to after it is navigated from. Esencialmente, la navegación no admite la semántica de llamada/devolución.Essentially, navigation doesn't support call/return semantics. Para solucionar este problema, WPFWPF proporciona la clase PageFunction<T> que puede usar para asegurarse de que se devuelve un Page de manera predecible y estructurada.To solve this problem, WPFWPF provides the PageFunction<T> class that you can use to ensure that a Page is returned to in a predictable and structured fashion. Para obtener más información, vea información general sobre la navegación estructurada.For more information, see Structured Navigation Overview.

Clase NavigationWindowThe NavigationWindow Class

En este punto, ha visto la gama de servicios de navegación que probablemente usará para compilar aplicaciones con contenido navegable.To this point, you've seen the gamut of navigation services that you are most likely to use to build applications with navigable content. Estos servicios se trataron en el contexto de XBAPsXBAPs, aunque no se limitan a XBAPsXBAPs.These services were discussed in the context of XBAPsXBAPs, although they are not limited to XBAPsXBAPs. Los sistemas operativos modernos y las aplicaciones de Windows aprovechan la experiencia del explorador de los usuarios modernos para incorporar la navegación de estilo Explorador en aplicaciones independientes.Modern operating systems and Windows applications take advantage of the browser experience of modern users to incorporate browser-style navigation into standalone applications. Estos son algunos ejemplos comunes:Common examples include:

  • Diccionario de sinónimos de Word: navegación por las opciones de Word.Word Thesaurus: Navigate word choices.

  • Explorador de archivos: navegación por archivos y carpetas.File Explorer: Navigate files and folders.

  • Asistentes: desglose de una tarea compleja en varias páginas entre las que se puede navegar.Wizards: Breaking down a complex task into multiple pages that can be navigated between. Un ejemplo es el Asistente para componentes de Windows que controla la adición y eliminación de características de Windows.An example is the Windows Components Wizard that handles adding and removing Windows features.

Para incorporar la navegación de estilo explorador a las aplicaciones independientes, puede usar la clase NavigationWindow.To incorporate browser-style navigation into your standalone applications, you can use the NavigationWindow class. NavigationWindow deriva de Window y lo extiende con la misma compatibilidad para la navegación que XBAPsXBAPs proporcionar.NavigationWindow derives from Window and extends it with the same support for navigation that XBAPsXBAPs provide. Puede usar NavigationWindow como la ventana principal de la aplicación independiente o como una ventana secundaria, como un cuadro de diálogo.You can use NavigationWindow as either the main window of your standalone application or as a secondary window such as a dialog box.

Para implementar un NavigationWindow, al igual que con la mayoría de las clases de nivel superior en WPFWPF (Window, Page, etc.), se usa una combinación de marcado y código subyacente.To implement a NavigationWindow, as with most top-level classes in WPFWPF (Window, Page, and so on), you use a combination of markup and code-behind. Esta implementación se muestra en el ejemplo siguiente.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

Este código crea un NavigationWindow que navega automáticamente a un Page (HomePage. xaml) cuando se abre la NavigationWindow.This code creates a NavigationWindow that automatically navigates to a Page (HomePage.xaml) when the NavigationWindow is opened. Si el NavigationWindow es la ventana principal de la aplicación, puede usar el atributo StartupUri para iniciarlo.If the NavigationWindow is the main application window, you can use the StartupUri attribute to launch it. Esto se muestra en la marcación siguiente.This is shown in the following markup.

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

En la ilustración siguiente se muestra el NavigationWindow como la ventana principal de una aplicación independiente.The following figure shows the NavigationWindow as the main window of a standalone application.

Una ventana principalA main window

En la ilustración, puede ver que el NavigationWindow tiene un título, aunque no se haya establecido en el código de implementación de NavigationWindow del ejemplo anterior.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. En su lugar, el título se establece mediante la propiedad WindowTitle, que se muestra en el código siguiente.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>

La configuración de las propiedades WindowWidth y WindowHeight también afecta a la NavigationWindow.Setting the WindowWidth and WindowHeight properties also affects the NavigationWindow.

Normalmente, se implementa su propia NavigationWindow cuando necesita personalizar su comportamiento o su apariencia.Usually, you implement your own NavigationWindow when you need to customize either its behavior or its appearance. Si no realiza nada, puede usar un acceso directo.If you do neither, you can use a shortcut. Si especifica el Pack URI de una Page como StartupUri en una aplicación independiente, Application crea automáticamente un NavigationWindow para hospedar el 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. En la marcación siguiente se muestra cómo habilitar esta opción.The following markup shows how to enable this.

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

Si desea que una ventana de la aplicación secundaria, como un cuadro de diálogo, sea un NavigationWindow, puede usar el código del ejemplo siguiente para abrirla.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()

En la siguiente ilustración se muestra el resultado.The following figure shows the result.

Un cuadro de diálogoA dialog box

Como puede ver, NavigationWindow muestra los botones atrás y adelante de Internet Explorer que permiten a los usuarios navegar por el diario.As you can see, NavigationWindow displays Internet Explorer-style Back and Forward buttons that allow users to navigate the journal. Estos botones proporcionan la misma experiencia de usuario, como se muestra en la ilustración siguiente.These buttons provide the same user experience, as shown in the following figure.

Botones atrás y adelante en NavigationWindowBack and Forward buttons in a NavigationWindow

Si las páginas proporcionan su propia compatibilidad y interfaz de usuario de navegación de diario, puede ocultar los botones atrás y adelante que se muestran en NavigationWindow estableciendo el valor de la propiedad ShowsNavigationUI en 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.

Como alternativa, puede usar la compatibilidad con la personalización en WPFWPF para reemplazar el IUUI de la NavigationWindow misma.Alternatively, you can use customization support in WPFWPF to replace the IUUI of the NavigationWindow itself.

Clase FrameThe Frame Class

Tanto el explorador como el NavigationWindow son ventanas que hospedan contenido navegable.Both the browser and NavigationWindow are windows that host navigable content. En algunos casos, las aplicaciones tienen contenido que no hace falta que los hospede una ventana completa.In some cases, applications have content that does not need to be hosted by an entire window. En su lugar, dicho contenido se hospeda dentro de otro contenido.Instead, such content be hosted inside other content. Puede insertar contenido navegable en otro contenido mediante la clase Frame.You can insert navigable content into other content by using the Frame class. Frame proporciona la misma compatibilidad que NavigationWindow y XBAPsXBAPs.Frame provides the same support as NavigationWindow and XBAPsXBAPs.

En el ejemplo siguiente se muestra cómo agregar un Frame a un Page mediante declaración con el 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>

Este marcado establece el atributo Source del elemento Frame con un Pack URI para el Page al que el Frame debe navegar inicialmente.This markup sets the Source attribute of the Frame element with a pack URI for the Page that the Frame should initially navigate to. En la ilustración siguiente se muestra un XBAPXBAP con un Page que tiene un Frame que ha navegado entre varias páginas.The following figure shows an XBAPXBAP with a Page that has a Frame that has navigated between several pages.

Marco que ha navegado entre varias páginasA frame that has navigated between multiple pages

No solo tiene que usar Frame dentro del contenido de un Page.You don't only have to use Frame inside the content of a Page. También es común hospedar una Frame dentro del contenido de un Window.It is also common to host a Frame inside the content of a Window.

De forma predeterminada, Frame solo utiliza su propio diario en ausencia de otro diario.By default, Frame only uses its own journal in the absence of another journal. Si una Frame forma parte del contenido que se hospeda dentro de un NavigationWindow o de un XBAPXBAP, Frame utiliza el diario que pertenece al NavigationWindow o XBAPXBAP.If a Frame is part of content that is hosted inside either a NavigationWindow or an XBAPXBAP, Frame uses the journal that belongs to the NavigationWindow or XBAPXBAP. A veces, sin embargo, es posible que un Frame deba ser responsable de su propio diario.Sometimes, though, a Frame might need to be responsible for its own journal. Una razón para hacerlo es permitir la navegación por el diario dentro de las páginas que se hospedan en un Frame.One reason to do so is to allow journal navigation within the pages that are hosted by a Frame. Esto se muestra en la ilustración siguiente.This is illustrated by the following figure.

Diagrama de marco y de páginaFrame and Page diagram

En este caso, puede configurar el Frame para utilizar su propio diario estableciendo la propiedad JournalOwnership de la Frame en OwnsJournal.In this case, you can configure the Frame to use its own journal by setting the JournalOwnership property of the Frame to OwnsJournal. Esto se muestra en la marcación siguiente.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>

En la ilustración siguiente se muestra el efecto de desplazarse dentro de una Frame que utiliza su propio diario.The following figure illustrates the effect of navigating within a Frame that uses its own journal.

Marco que usa su propio diarioA frame that uses its own journal

Tenga en cuenta que las entradas del diario se muestran en la IUUI de navegación en el Frame, en lugar de en Internet Explorer.Notice that the journal entries are shown by the navigation IUUI in the Frame, rather than by Internet Explorer.

Nota

Si una Frame forma parte del contenido que se hospeda en un Window, Frame utiliza su propio diario y, por consiguiente, muestra su propia IUUI de navegación.If a Frame is part of content that is hosted in a Window, Frame uses its own journal and, consequently, displays its own navigation IUUI.

Si la experiencia del usuario requiere un Frame para proporcionar su propio diario sin mostrar el IUUI de navegación, puede ocultar la IUUI de navegación estableciendo la NavigationUIVisibility en Hidden.If your user experience requires a Frame to provide its own journal without showing the navigation IUUI, you can hide the navigation IUUI by setting the NavigationUIVisibility to Hidden. Esto se muestra en la marcación siguiente.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 y NavigationWindow son clases conocidas como hosts de navegación.Frame and NavigationWindow are classes that are known as navigation hosts. Un host de navegación es una clase que puede navegar y mostrar el contenido.A navigation host is a class that can navigate to and display content. Para ello, cada host de navegación utiliza su propio NavigationService y Journal.To accomplish this, each navigation host uses its own NavigationService and journal. La construcción de un host de navegación básica se muestra en la ilustración siguiente.The basic construction of a navigation host is shown in the following figure.

Diagramas de navegadorNavigator diagrams

En esencia, esto permite a NavigationWindow y Frame proporcionar la misma compatibilidad de navegación que proporciona una XBAPXBAP cuando se hospeda en el explorador.Essentially, this allows NavigationWindow and Frame to provide the same navigation support that an XBAPXBAP provides when hosted in the browser.

Además de usar NavigationService y un diario, los hosts de navegación implementan los mismos miembros que implementa NavigationService.Besides using NavigationService and a journal, navigation hosts implement the same members that NavigationService implements. Esto se muestra en la ilustración siguiente.This is illustrated by the following figure.

Un diario en un marco y en NavigationWindowA journal in a Frame and in a NavigationWindow

Esto le permite programar la compatibilidad con la navegación directamente con ellos.This allows you to program navigation support directly against them. Puede considerar esto si necesita proporcionar una IUUI de navegación personalizada para un Frame que se hospede en un Window.You may consider this if you need to provide a custom navigation IUUI for a Frame that is hosted in a Window. Además, ambos tipos implementan miembros adicionales relacionados con la navegación, como BackStack (NavigationWindow.BackStack, Frame.BackStack) y ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), que le permiten enumerar las entradas del diario en la pila de retroceso y la pila de reenvío, respectivamente.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.

Como se mencionó anteriormente, pueden haber varios diarios dentro de una aplicación.As mentioned earlier, more than one journal can exist within an application. En la siguiente ilustración se muestra un ejemplo de cuándo ocurre esto.The following figure provides an example of when this can happen.

Varios diarios dentro de una aplicaciónMultiple journals within one application

En este tema, se han usado Page y Pack XBAPsXBAPs para mostrar las diversas funciones de navegación de WPFWPF.Throughout this topic, Page and pack XBAPsXBAPs have been used to demonstrate the various navigation capabilities of WPFWPF. Sin embargo, un Page que se compila en una aplicación no es el único tipo de contenido al que se puede navegar y empaquetar XBAPsXBAPs no es la única manera de identificar el contenido.However, a Page that is compiled into an application is not the only type of content that can be navigated to, and pack XBAPsXBAPs aren't the only way to identify content.

Como se muestra en esta sección, también puede desplazarse a archivos de XAMLXAML sueltos, archivos HTML y objetos.As this section demonstrates, you can also navigate to loose XAMLXAML files, HTML files, and objects.

Un archivo XAMLXAML dinámico es un archivo con las siguientes características:A loose XAMLXAML file is a file with the following characteristics:

  • Solo contiene XAMLXAML (es decir, sin código).Contains only XAMLXAML (that is, no code).

  • Tiene una declaración de espacio de nombres adecuada.Has an appropriate namespace declaration.

  • Tiene la extensión de nombre de archivo .xaml.Has the .xaml file name extension.

Por ejemplo, considere el siguiente contenido almacenado como un archivo XAMLXAML suelto, 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>

Al hacer doble clic en el archivo, el explorador se abre y se desplaza al contenido y lo muestra.When you double-click the file, the browser opens and navigates to and displays the content. Esto se muestra en la siguiente ilustración.This is shown in the following figure.

Presentación del contenido en el archivo person. XAMLDisplay of the content in the Person.XAML file

Puede mostrar un archivo de XAMLXAML suelto a partir de lo siguiente:You can display a loose XAMLXAML file from the following:

  • Un sitio web en la máquina local, la intranet o Internet.A Web site on the local machine, the intranet, or the Internet.

  • Un recurso compartido de archivos UNC (Convención de nomenclatura universal).A Universal Naming Convention (UNC) file share.

  • El disco local.The local disk.

Se puede Agregar un archivo de XAMLXAML dinámico a los favoritos del explorador o ser la Página principal del explorador.A loose XAMLXAML file can be added to the browser's favorites, or be the browser's home page.

Nota

Para obtener más información sobre la publicación y el inicio de páginas de XAMLXAML sueltos, vea implementar una aplicación de WPF.For more information about publishing and launching loose XAMLXAML pages, see Deploying a WPF Application.

Una limitación con respecto a los XAMLXAML sueltos es que solo se puede hospedar contenido seguro para ejecutarse en confianza parcial.One limitation with respect to loose XAMLXAML is that you can only host content that is safe to run in partial trust. Por ejemplo, Window no puede ser el elemento raíz de un archivo de XAMLXAML dinámico.For example, Window cannot be the root element of a loose XAMLXAML file. Para obtener más información, vea Seguridad de confianza parcial de WPF.For more information, see WPF Partial Trust Security.

Como cabría esperar, también puede navegar a HTML.As you might expect, you can also navigate to HTML. Solo tiene que proporcionar un URI que use el esquema http.You simply need to provide a URI that uses the http scheme. Por ejemplo, en el XAMLXAML siguiente se muestra un Frame que navega a una página HTML.For example, the following XAMLXAML shows a Frame that navigates to an HTML page.

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

La navegación a HTML requiere permisos especiales.Navigating to HTML requires special permissions. Por ejemplo, no se puede navegar desde una XBAPXBAP que se ejecuta en el espacio aislado de seguridad de confianza parcial de zona de Internet.For example, you can't navigate from an XBAPXBAP that is running in the Internet zone partial trust security sandbox. Para obtener más información, vea Seguridad de confianza parcial de WPF.For more information, see WPF Partial Trust Security.

El control WebBrowser admite la interoperabilidad de hospedaje de documentos HTML, navegación y script/código administrado.The WebBrowser control supports HTML document hosting, navigation and script/managed code interoperability. Para obtener información detallada sobre el control de WebBrowser, vea WebBrowser.For detailed information regarding the WebBrowser control, see WebBrowser.

Como Frame, la navegación a HTML con WebBrowser requiere permisos especiales.Like Frame, navigating to HTML using WebBrowser requires special permissions. Por ejemplo, desde una aplicación de confianza parcial, solo puede navegar a HTML ubicado en el sitio de origen.For example, from a partial-trust application, you can navigate only to HTML located at the site of origin. Para obtener más información, vea Seguridad de confianza parcial de WPF.For more information, see WPF Partial Trust Security.

Si tiene datos que se almacenan como objetos personalizados, una manera de mostrar los datos consiste en crear un Page con contenido enlazado a esos objetos (consulte información general sobre el enlace de datos).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). Si no necesita la sobrecarga de la creación de una página completa para mostrar los objetos, puede navegar directamente a ellos en su lugar.If you don't need the overhead of creating an entire page just to display the objects, you can navigate directly to them instead.

Tenga en cuenta la Person clase que se implementa en el código siguiente.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

Para ir a ella, llame al método NavigationWindow.Navigate, tal y como se muestra en el código siguiente.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

En la siguiente ilustración se muestra el resultado.The following figure shows the result.

Página que navega a una claseA page that navigates to a class

En esta ilustración, puede ver que no se muestra nada útil.From this figure, you can see that nothing useful is displayed. De hecho, el valor que se muestra es el valor devuelto del método ToString para el objeto Person ; de forma predeterminada, este es el único valor que WPFWPF puede usar para representar el objeto.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 WPFWPF can use to represent your object. Puede invalidar el método ToString para devolver información más significativa, aunque seguirá siendo solo un valor de cadena.You could override the ToString method to return more meaningful information, although it will still only be a string value. Una técnica que se puede usar que aprovecha las funcionalidades de presentación de WPFWPF es usar una plantilla de datos.One technique you can use that takes advantage of the presentation capabilities of WPFWPF is to use a data template. Puede implementar una plantilla de datos que WPFWPF puede asociar a un objeto de un tipo determinado.You can implement a data template that WPFWPF can associate with an object of a particular type. En el código siguiente se muestra una plantilla de datos para el objeto 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>

En este caso, la plantilla de datos está asociada al tipo de Person mediante el x:Type extensión de marcado en el atributo DataType.Here, the data template is associated with the Person type by using the x:Type markup extension in the DataType attribute. A continuación, la plantilla de datos enlaza TextBlock elementos (vea TextBlock) a las propiedades de la clase Person.The data template then binds TextBlock elements (see TextBlock) to the properties of the Person class. En la siguiente ilustración se muestra la apariencia actualizada del objeto Person.The following figure shows the updated appearance of the Person object.

Desplazarse a una clase que tiene una plantilla de datosNavigating to a class that has a data template

Una ventaja de esta técnica es la coherencia que obtiene al poder volver a usar la plantilla de datos para mostrar los objetos de forma coherente en cualquier parte de la aplicación.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.

Para obtener más información sobre las plantillas de datos, vea información general sobre plantillas de datos.For more information on data templates, see Data Templating Overview.

SeguridadSecurity

WPFWPF la compatibilidad con la navegación permite navegar a XBAPsXBAPs a través de Internet y permite a las aplicaciones hospedar contenido de terceros.navigation support allows XBAPsXBAPs to be navigated to across the Internet, and it allows applications to host third-party content. Para proteger tanto las aplicaciones como los usuarios del comportamiento perjudicial, WPFWPF proporciona una variedad de características de seguridad que se describen en seguridad y seguridad de confianza parcial de WPF.To protect both applications and users from harmful behavior, WPFWPF provides a variety of security features that are discussed in Security and WPF Partial Trust Security.

Vea tambiénSee also