Partilhar via

Visão geral de navegação

  • Artigo

Windows Presentation Foundation (WPF) oferece suporte a navegação em estilo de navegador que pode ser usada em dois tipos de aplicativos: aplicativos autônomos e aplicativos de navegador XAML (XBAPs). Para conteúdo do pacote para navegação, WPF Fornece o Page classe. Você pode navegar de um Page para outro declarativamente, usando um Hyperlink, ou programaticamente, usando o NavigationService. WPF usa o diário para lembrar páginas que foram navegou de e para navegar para eles.

Page, Hyperlink, NavigationService, e o journal formam o núcleo do suporte a navegação oferecido por WPF. Esta visão geral explora esses recursos detalhadamente antes de abranger suporte a navegação avançada que inclui a navegação para arquivos Extensible Application Markup Language (XAML) fracamente acoplados, arquivos HTML, e objetos.

ObservaçãoObservação:

Neste tópico, o termo "navegador" refere-se somente a navegadores que pode hospedar WPF aplicativos que atualmente inclui Internet Explorer 7, Microsoft Internet Explorer 6e o Firefox 2.0 +. Onde recursos WPF específicos são suportados apenas por um navegador em particular, a versão do navegador é especificada.

Este tópico contém as seguintes seções.

  • Navegação em aplicativos WPF
  • A classe NavigationWindow
  • A classe Frame
  • Hosts de navegação
  • Navegar para conteúdo que outros páginas XAML
  • Segurança
  • Tópicos relacionados

Este tópico fornece uma visão geral dos recursos de navegação principais no WPF. Esses recursos estão disponíveis tanto para os aplicativos independentes quanto XBAPs, apesar de este tópico apresentá-los dentro do contexto de um XBAP.

ObservaçãoObservação:

Este tópico não discute como criar e implantar XBAPs. Para obter mais informações sobre XBAPs, consulte: Visão geral sobre Windows Presentation Foundation XAML Browser Applications.

Esta seção explica e demonstra os seguintes aspectos de navegação:

  • Implementando uma página

  • Configurando uma página inicial

  • Configurando altura, largura e título da janela do host

  • Navegação de hiperlink

  • Navegação de fragmento

  • Serviço de navegação

  • Navegação através de programação com o serviço de navegação

  • Tempo de vida de Navegação

  • Memorização de navegação com o Journal

  • Tempo de vida de página e o Journal

  • Retendo estado de conteúdo com histórico de navegação

  • Cookies

  • Navegação Estruturada

Implementando uma página

Em WPF, você pode navegar para vários tipos de conteúdo que incluem objetos .NET Framework, objetos personalizados, valores de enumeração, controles de usuário, arquivos XAML e arquivos HTML. No entanto, você descobrirá que a forma mais comum e conveniente de empacotar conteúdo é usar Page. Além disso, Page implementa recursos específicos de navegação para aprimorar sua aparência e simplificar o desenvolvimento.

Usando Page, você pode implementar uma página navegável de conteúdo XAML declarativamente usando marcação semelhante ao seguinte.

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

Uma Page que é implementada em marcação XAML tem Page como seu elemento raiz e requer a declaração de namespace WPF XML. O elemento Page possui o conteúdo ao qual você deseja navegar e exibir. Você adicionar conteúdo definindo o elemento de propriedade Page.Content, conforme mostrado na seguinte marcação.

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

Page.Content só pode conter um elemento filho; no exemplo anterior, o conteúdo é uma única sequência de caracteres, "Hello, Page!" Na prática, você geralmente usará um controle de layout como o elemento filho (consulte O sistema de layout) para conter e redigir o conteúdo.

Os elementos filhos de um elemento Page são considerados o conteúdo de uma Page e, consequentemente, você não precisa usar a declaração explícita Page.Content. A marcação a seguir é o equivalente declarativo para o exemplo anterior.

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

Nesse caso, Page.Content é definido automaticamente com os elementos filhos do elemento Page. Para obter mais informações, consulte Modelo de conteúdo WPF.

Uma Page somente com marcação é útil para exibir conteúdo. No entanto, uma Page também pode exibir os controles que permitem aos usuários interagir com a página, e ela pode responder à interação do usuário manipulando eventos e chamando a lógica do aplicativo. Uma Page interativa é implementada usando uma combinação de marcação e arquivos de lógica, conforme mostrado no exemplo o seguir.

Para permitir que um arquivo de marcação e arquivos de lógica funcionem juntos, a seguinte configuração é necessária:

  • Na marcação, o elemento Page precisa incluir o atributo x:Class. Quando o aplicativo é construído, a existência do x:Class no arquivo de marcação causa o Mecanismo de compilação Microsoft (MSBuild) a criar uma classe partial que deriva de Page e possui o nome que é especificado pelo atributo x:Class. Isto requer a adição de uma declaração de namespace XML no esquema XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). A classe partial gerada implementa InitializeComponent, que é chamado para registrar os eventos e definir as propriedades que são implementadas na marcação.

  • Nos arquivo de lógica, a classe precisa ser uma classe partial com o mesmo nome que o especificado pelo atributo x:Class na marcação, e precisa derivar de Page. Isto permite ao arquivo de lógica estar associado à classe partial que é gerada para o arquivo de marcação quando o aplicativo é construído (veja Building a WPF Application (WPF)).

  • No code-behind, o Page a classe deve implementar um construtor que chama o InitializeComponent método. InitializeComponent é implementada pela marcação da gerado o arquivo partial classe de registro de eventos e conjunto as propriedades definidas na marcação.

ObservaçãoObservação:

Quando você adiciona um novo Page usando seu projeto Microsoft Visual Studio, o Page é implementada usando marcação e code-behind, e inclui a configuração necessária para criar a associação entre a marcação e código - behind arquivos conforme descrito aqui.

Depois que você tiver uma Page, você pode navegar para ela. Para especificar a primeira Page para a qual um aplicativo navega, você precisará configurar a Page inicial.

Configurando uma página inicial

XBAPs exige que uma quantidade determinada da infraestrutura do aplicativo seja hospedada em um navegador. No WPF, a classe Application é parte de uma definição de aplicativo que estabelece a infraestrutura de aplicativo necessária (consulte Visão Geral do Gerenciamento de Aplicativo).

An application definition is usually implemented using both markup and code-behind, with the markup file configured as an MSBuild ApplicationDefinition item. The following is an application definition for an XBAP.

An XBAP pode utilizar sua definição de aplicativo para especificar um início Page, que é o Page que é carregado automaticamente quando o XBAP é iniciado. Fazer isso configurando a StartupUri propriedade com o uniform resource identifier (URI) para o desejado Page.

ObservaçãoObservação:

Na maioria dos casos, o Page é compilado em ou implantado com um aplicativo. Nesses casos, a URI que identifica uma Page é um URI pack, que é uma URI que está de acordo com o esquema pack. Compactar URIs são discutidas mais na URIs de Pacotes no Windows Presentation Foundation. Você também pode navegar para o conteúdo usando o esquema de http, que é discutido abaixo.

Você pode definir StartupUri declarativamente na marcação, como mostrado no exemplo o seguir.

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

Neste exemplo, a StartupUri atributo é definido com um empacotar relativo URI que identifica home page.xaml. Quando o XBAP é iniciado, home page.xaml é navegada e exibidos automaticamente. Isso é demonstrado pela figura a seguir, que mostra um XBAP que foi iniciado de um servidor Web.

Página XBAP

ObservaçãoObservação:

Para obter mais informações sobre o desenvolvimento e a implantação do XBAPs, consulte Visão geral sobre Windows Presentation Foundation XAML Browser Applications e Implantar um aplicativo WPF (WPF).

Configurando altura, largura e título da janela do host

Uma coisa que você talvez tenha observado da figura anterior é que o título do navegador e do painel de abas é a URI para o XBAP. Além de ser longo, o título não é atraente nem informativo. Por esse motivo, Page oferece uma maneira para que você altere o título, definindo a propriedade WindowTitle. Além disso, você pode configurar a largura e altura da janela do navegador definindo WindowWidth e WindowHeight, respectivamente.

Você pode definir WindowTitle, WindowWidth e WindowHeight declarativamente na marcação, como mostrado no exemplo o seguir.

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

O resultado é mostrado na figura a seguir.

Título, altura e largura da janela

Um XBAP típico compreende várias páginas. A maneira mais simples para navegar de uma página para outra é usar um Hyperlink. Você pode adicionar um Hyperlink declarativamente a um Page usando o elemento Hyperlink, que é mostrado na seguinte a marcação.

<Page
  xmlns="https://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>

Um elemento Hyperlink requer o seguinte:

  • A URI pack de Page à qual navegar, conforme especificado pelo atributo NavigateUri.

  • Conteúdo que um usuário pode clicar para iniciar a navegação, como texto e imagens (para o conteúdo que o elemento Hyperlink pode ter, consulte Hyperlink).

A figura a seguir mostra um XBAP com um Page que tem um Hyperlink.

Página com hiperlink

Como você esperaria, clicar no Hyperlink faz com que o XBAP navegue até a Page que é identificada pelo atributo NavigateUri. Além disso, o XBAP adiciona uma entrada para a Page anterior à lista Páginas recentes no Internet Explorer 7. Isso é mostrado na figura a seguir.

Botões Voltar e Avançar

Assim como suporte de navegação de uma Page para outra, Hyperlink também suporta navegação de fragmento.

Navegação de fragmento é a navegação para um fragmento de conteúdo na Page atual ou outra Page. Em WPF, um fragmento de conteúdo é o conteúdo contido por um elemento nomeado. Um elemento nomeado é um elemento que tem o atributo Name definido. A marcação a seguir mostra um elemento TextBlock nomeado que contém um fragmento de conteúdo.

<Page
    xmlns="https://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 que um Hyperlink navegue até um fragmento de conteúdo, o atributo NavigateUri deve incluir o seguinte:

  • O URI da Page com o fragmento de conteúdo ao qual navegar.

  • Um caractere "#".

  • O nome do elemento na Page que contém o fragmento de conteúdo.

Uma URI de fragmento possui o seguinte formato.

PageURI#ElementName

A seguir mostra-se um exemplo de um Hyperlink que é configurado para navegar a um fragmento de conteúdo.

<Page
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  WindowTitle="Page That Navigates To Fragment" >


...


<Hyperlink NavigateUri="PageWithFragments.xaml#Fragment1">
  Navigate To pack Fragment
</Hyperlink>


...


</Page>

Para obter um exemplo completo de navegação de fragmento, consulte Exemplo de navegação de fragmento.

ObservaçãoObservação:

Isso seção Descreve a implementação padrão de navegação de fragmento no WPF. WPF também permite que você implementar seu próprio esquema de navegação de fragmento que, em parte, requer tratamento de NavigationService.FragmentNavigation evento.
Observação importanteObservação importante:

Y ocê c uma navegar para fragmentos em ampliada XAML páginas (apenas de marcação XAML arquivos com Page sistema autônomo o elemento raiz) somente se sistema autônomo páginas podem ser visitadas por meio de HTTP.

No entanto, um flexível XAML página pode navegar para seus próprios fragmentos.

Serviço de navegação

Enquanto Hyperlink permite que um usuário inicie a navegação para uma determinada Page, o trabalho de localizar e baixar a página é executado pela classe NavigationService. Essencialmente, NavigationService fornece a capacidade de processar uma solicitação de navegação representando código do cliente, tal como o Hyperlink. Além disso, NavigationService implementa o suporte em mais alto nível para controlar e influenciar uma solicitação de navegação.

Quando um Hyperlink é clicado, WPF chama NavigationService.Navigate para localizar e baixar a Page na URI pack especificada. A Page baixada é convertido em uma árvore de objetos cujo objeto raiz é uma instância da Page baixada. Uma referência ao objeto da Page raiz é armazenada na propriedade NavigationService.Content. A URI pack para o conteúdo ao qual navegou-se é armazenada na propriedade NavigationService.Source, enquanto a NavigationService.CurrentSource armazena a URI pack para a última página visitada.

ObservaçãoObservação:

É possível que um WPF aplicativo para ter mais de um ativo no momento NavigationService. Para obter mais informações, consulte Hosts de Navegação posteriormente contido neste tópico.

Você não precisará saber sobre NavigationService se a navegação for implementada declarativamente na marcação usando Hyperlink, porque Hyperlink usa o NavigationService em seu nome. Isso significa que, desde sistema autônomo pai direto ou indireto de um Hyperlink é um host de navegação (consulte Hosts de navegação), Hyperlink poderá localizar e usar o serviço de navegação do host de navegação para processar uma solicitação de navegação.

No entanto, há situações nas quais você precisa usar NavigationService diretamente, incluindo as seguintes:

  • Quando você precisa criar uma instância de Page usando um construtor não padrão.

  • Quando você precisa definir as propriedades na Page antes de navegar até ela.

  • Quando a Page para a qual precisa-se navegar só pode ser determinada em tempo de execução.

Nessas situações, você precisará escrever código para iniciar navegação por programação chamando o método Navigate do objeto NavigationService. Isso exige que se obtenha uma referência a um NavigationService.

Obter uma referência para o NavigationService

Por razões que são abordadas na seção Hosts de Navegação, um aplicativo WPF pode ter mais de um NavigationService. This means that your code needs a way to find a NavigationService, which is usually the NavigationService that navigated to the current Page. You can get a reference to a NavigationService by calling the static NavigationService.GetNavigationService method. Para obter o NavigationService que navegou para uma determinada Page, você passa uma referência à Page como o argumento do método GetNavigationService. O código a seguir mostra como obter o NavigationService para a Page atual.

using System.Windows.Navigation; // NavigationServce


...


// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = NavigationService.GetNavigationService(this);

Como um atalho para localizar o NavigationService para uma Page, Page implementa a propriedade NavigationService. Isto é mostrado no exemplo a seguir.

using System.Windows.Navigation; // NavigationServce


...


// Get a reference to the NavigationService that navigated to this Page
NavigationService ns = this.NavigationService;
ObservaçãoObservação:

A Page só pode obter uma referência ao seu NavigationService Quando Page aumenta a Loaded evento.

Navegação através de programação para um objeto Page

O exemplo a seguir mostra como usar o NavigationService para navegar por meio de programação para uma Page. Navegação através de programação é necessária porque a Page à qual se está navegando pode apenas ser instanciada usando um construtor simples, não padrão. A Page com o construtor não padrão é mostrada na seguinte marcação e código.

<Page
    x:Class="SDKSample.PageWithNonDefaultConstructor"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    Title="PageWithNonDefaultConstructor">

  <!-- Content goes here -->

</Page>

using System.Windows.Controls; // Page

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

            this.Content = message;
        }
    }
}

A Page que navega para a Page com o construtor não padrão é mostrada na seguinte marcação e código.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

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);
        }
    }
}

Quando o Hyperlink sobre isso Page é clicado, navegação é iniciada pela instanciação de Page para navegar até usando o construtor não-padrão e chamando o NavigationService.Navigate método. Navigate aceita uma referência ao objeto que o NavigationService navegará até, em vez de um empacotar URI.

Se você precisar criar uma URI pack programaticamente (quando você pode apenas determinar a URI pack em tempo de execução, por exemplo), você pode usar o método NavigationService.Navigate. Isto é mostrado no exemplo a seguir.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSUriNavigationPage">
  <Hyperlink Click="hyperlink_Click">Navigate to Page by Pack URI</Hyperlink>
</Page>

using System; // Uri, UriKind
using System.Windows; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

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);
        }
    }
}

Atualizar a página atual

Uma Page não é baixada se ela tiver a mesma URI pack que a URI pack que está armazenada na propriedade NavigationService.Source. Para forçar WPF a baixar a página atual novamente, você pode chamar o método NavigationService.Refresh, conforme mostrado no exemplo o seguir.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.NSRefreshNavigationPage">
 <Hyperlink Click="hyperlink_Click">Refresh this page</Hyperlink>
</Page>

using System.Windows; // RoutedEventArgs
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService

namespace SDKSample
{
    public partial class NSRefreshNavigationPage : Page
    {


...


        void hyperlink_Click(object sender, RoutedEventArgs e)
        {
            // Force WPF to download this page again
            this.NavigationService.Refresh();
        }
    }
}

Tempo de vida de Navegação

Há várias maneiras para iniciar a navegação, como você viu. Quando é iniciada a navegação, e enquanto a navegação está em andamento, você pode controlar e influenciar a navegação usando os seguintes eventos que são implementados pelo NavigationService:

  • Navigating. Ocorre quando uma nova navegação é solicitada. Pode ser usado para cancelar a navegação.

  • NavigationProgress. Ocorre periodicamente durante um baixar para fornecer informações de navegação em andamento.

  • Navigated. Ocorre quando a página tenha sido localizada e baixada.

  • NavigationStopped. Ocorre quando a navegação é interrompida (chamando StopLoading), ou quando uma nova navegação solicitada enquanto uma navegação corrente está em andamento.

  • NavigationFailed. Ocorre quando um erro é gerado durante a navegação até o conteúdo solicitado.

  • LoadCompleted. Ocorre quando conteúdo foi navegou é carregado e analisado e iniciado o renderização.

  • FragmentNavigation. Ocorre quando começa a navegação até um fragmento de conteúdo, que acontece:

    • Imediatamente, se o fragmento desejado estiver no conteúdo atual.

    • Depois do conteúdo fonte ser carregado, se o fragmento desejado estiver em outro conteúdo.

Os eventos de navegação são gerados na ordem que é ilustrada pela figura a seguir.

Fluxograma de navegação da página

Em geral, uma Page não se preocupa com esses eventos. É mais provável que um aplicativo esteja relacionado a eles e, por esse motivo, esses eventos são também gerados pela classe Application:

Cada vez NavigationService gera um evento, o Application classe dispara o evento correspondente. Frame e NavigationWindow oferecem os mesmos eventos para detectar a navegação em seus respectivos escopos.

Em alguns casos, uma Page pode estar interessada nesses eventos. Por exemplo, uma Page pode tratar o evento NavigationService.Navigating para determinar se deve ou não cancelar a navegação para fora dela. Isto é mostrado no exemplo a seguir.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CancelNavigationPage">
  <Button Click="button_Click">Navigate to Another Page</Button>
</Page>

using System; // Uri, UriKind
using System.Windows; // RoutedEventArgs, MessageBox, MessageBoxResult
using System.Windows.Controls; // Page
using System.Windows.Navigation; // NavigationService, NavigatingCancelEventArgs

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

Se você registrar um manipulador com um evento de navegação de uma Page, como o exemplo anterior faz, você deve também cancelar o registro de manipulador de eventos. Se você não o fizer, pode haver efeitos colaterais com relação a como WPF memoriza a navegação da Page usando o journal.

Memorização de navegação com o Journal

WPF usa duas pilhas lembrar as páginas que você navegou de: uma pilha traseira e uma pilha de encaminhar. Quando você navegar da Page atual para uma nova Page ou encaminhar-se para uma Page existente, a Page atual é adicionada à pilha de volta. Quando você navegar da Page atual de volta para à Page anterior, a Page atual é adicionada à pilha de avanço. A pilha de volta, a pilha de avanço e a funcionalidade para gerenciá-los, são coletivamente denominados o journal. Cada item na pilha de volta e a pilha de avanço é uma instância da classe JournalEntry e é referido como uma entrada do journal.

Conceitualmente, o diário opera da mesma maneira que o Fazer backup and encaminhar botões de Internet Explorer 7 Para fazer. Estes são exibidos na figura a seguir.

Botões Voltar e Avançar

Para XBAPs que são hospedados por Internet Explorer 7, WPF integra o journal na UI de navegação do Internet Explorer 7. Isso permite aos usuários navegar páginas em um XBAP usando o Fazer backup, encaminhar, and Páginas recentes botões de Internet Explorer 7. O diário não está integrado Microsoft Internet Explorer 6 da mesma forma é por Internet Explorer 7. Em vez disso, WPF processa uma UI de navegação substituta.

Observação importanteObservação importante:

Em Internet Explorer 7, quando um usuário navega longe e de volta para um XBAP, somente as entradas de diário para páginas que não foram mantidas ativas são mantidas no diário. Para discussão sobre como manter páginas ativas, consulte Tempo de vida de página e o Journal posteriormente contido neste tópico.

Por padrão, o texto para cada Page que aparece na lista Páginas Recentes de Internet Explorer 7 é a URI para a Page. Em muitos casos, isso não é particularmente significativo para o usuário. Felizmente, você pode alterar o texto usando uma das opções a seguir:

  1. O valor do atributo JournalEntry.Name anexado.

  2. O valor do atributo Page.Title.

  3. O valor do atributo Page.WindowTitle e a URI para a Page atual.

  4. A URI para a Page atual. (Padrão).

A ordem em que as opções estão listadas coincide com a ordem de precedência para localizar o texto. Por exemplo, se JournalEntry.Name estiver definido, os outros valores são ignorados.

O exemplo a seguir usa o atributo Page.Title para alterar o texto que aparece para uma entrada de journal.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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; // Page

namespace SDKSample
{
    public partial class PageWithTitle : Page
    {


...


    }
}

Embora um usuário possa navegar no journal usando Voltar, Avançar e Páginas Recentes no Internet Explorer 7, você também pode navegar no journal usando mecanismos tanto declarativos quanto através de programação fornecidos pelo WPF. Um motivo para fazer isso é fornecer navegação personalizada a UIs em suas páginas.

Você pode adicionar suporte de navegação do journal declarativamente usando os comandos de navegação expostos por NavigationCommands. O exemplo a seguir demonstra como usar o comando BrowseBack de navegação.

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


...


<Hyperlink Command="NavigationCommands.BrowseBack">Back</Hyperlink>


...


</Page>

Você pode navegar por meio de programação no journal usando um dos seguintes membros da classe NavigationService:

O journal também pode ser manipulado por meio de programação, conforme discutido em Retendo estado de conteúdo com histórico de navegação posteriormente contido neste tópico.

Tempo de vida de página e o Journal

Considere um XBAP com várias páginas que contêm conteúdo rico, incluindo elementos gráficos, animações e mídia. Os vestígio de memória para algum tempo pode ser muito grande, principalmente se mídia de vídeo e áudio é usada. Já que o journal "memoriza" páginas que às quais se tenham navegado, tal XBAP rapidamente pode consumir uma quantidade grande e perceptível de memória.

Por esse motivo, o comportamento padrão do journal é armazenar metadados de Page em cada entrada de journal, e não uma referência a um objeto Page. Quando navega-se a uma entrada de journal, seus metadados da Page são usados para criar uma nova instância da Page especificada. Como consequência, cada Page que é navegada tem a vida útil ilustrada pela figura a seguir.

Tempo de vida da página

Embora usar o comportamento padrão de journaling pode economizar consumo de memória, o desempenho de processamento por página poderá ser reduzido; reinstanciar uma Page pode ser custoso computacionalmente, especialmente se ela tiver muito conteúdo. Se você precisar manter uma instância da Page no journal, você pode usar duas técnicas para fazê-lo. Primeiro, você poderá, por meio de programação, navegar para um objeto Page chamando o método NavigationService.Navigate.

Em segundo lugar, você pode especificar que WPF mantém uma instância de uma Page no journal, definindo a propriedade KeepAlive como true (o padrão é false). Você pode definir KeepAlive declarativamente na marcação, como mostrado no exemplo o seguir.

<Page
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.KeepAlivePage"
    KeepAlive="True">

  An instance of this page is stored in the journal.

</Page>

O tempo de vida de uma Page que é mantida ativa é ligeiramente diferente de uma que não é. Na primeira vez que se navega a uma Page que é mantida ativa, ela é instanciada do mesmo modo como uma Page que não é mantida ativa. No entanto, já que uma instância da Page é mantida no journal, ela nunca mais é instanciada novamente, desde que ela permaneça no journal. Consequentemente, se uma Page tiver lógica de inicialização que precisa ser chamada sempre que se navega para a Page, você deve mover esta lógica do construtor para um manipulador para o evento Loaded. Como mostrado na figura a seguir, os eventos Loaded e Unloaded ainda são gerados sempre que se navega para e de uma Page, respectivamente.

Quando os eventos Loaded e Unloaded são gerados

Quando uma Page não é mantida ativa, você não deve fazer nenhum destes procedimentos:

  • Armazenar uma referência a ela, ou qualquer parte dela.

  • Registrar manipuladores de eventos com eventos que não são implementados por ela.

Fazer um deles criará referências que forçam a Page a ser retida na memória, mesmo após ela ter sido removida do journal.

Em geral, você deve preferir o comportamento padrão de Page de não manter uma Page ativa. No entanto, isso tem implicações do estado que são discutidas na próxima seção.

Retendo estado de conteúdo com histórico de navegação

Se uma Page não é mantida ativa, e ela tem controles que coletam dados de usuário, o que acontece com os dados se um usuário navega de e para a Page? A partir de uma perspectiva de experiência do usuário, o usuário deve esperar ver os dados inseridos anteriormente. Infelizmente, já que uma nova instância da Page é criada com cada navegação, os controles que coletaram os dados são reinstanciados e os dados serão perdidos.

Felizmente, o journal oferece suporte para memorizar dados entre navegações de Page, incluindo dados de controle. Especificamente, a entrada de journal para cada Page atua como um recipiente temporário para o estado da Page associado. As etapas a seguir descrevem como esse suporte é usado quando navega-se a partir de uma Page:

  1. Uma entrada para a Page atual é adicionada ao journal.

  2. O estado da Page é armazenado com a entrada de journal para essa página, que é adicionada à pilha de volta.

  3. Navega-se para a nova Page.

Quando navega-se de volta à página Page, usando o journal, ocorrem as seguintes etapas:

  1. A Page (a entrada no topo da pilha de volta do journal) é instanciada.

  2. A Page é atualizada com o estado que foi armazenado com a entrada de journal para a Page.

  3. Navega-se de volta para a Page.

WPF automaticamente usa esse suporte quando os controles a seguir são usados em uma Page:

Se uma Page usa esses controles, os dados inseridos neles são memorizados entre navegações de Page, conforme demonstrado pela ListBox Cor Favorita na figura a seguir.

Página com controles que lembram o estado

Quando uma Page possui controles diferentes daqueles da lista anterior, ou quando estado é armazenado em objetos personalizados, você precisa escrever código para fazer com que o journal memorize o estado entre navegações de Page.

Se você precisar memorizar pequenos pedaços de estado entre as navegações de Page, você pode usar propriedades de dependência (consulte DependencyProperty) que são configuradas com o sinalizador FrameworkPropertyMetadata.Journal de metadados. Para um exemplo, consulte Lembre-se um item Simples do estado em instâncias de página.

Se o estado que sua Page precisa memorizar entre navegações compreende várias partes de dados, talvez você julgue menos trabalhoso em termos de código encapsular seu estado em uma única classe e implementar a interface IProvideCustomContentState. Consulte Lembre-se um conjunto Simples de estado entre instâncias de página.

Caso você precise navegar por vários estados de um único Page, sem precisar navegar a partir do Page propriamente dito, você pode usar IProvideCustomContentState e NavigationService.AddBackEntry. Consulte Lembre-se Múltiplo conjuntos de estado por instância de página.

Cookies

Outra maneira que os aplicativos WPF podem armazenar dados é com cookies, que são criados, atualizados e excluídos usando os métodos SetCookie e GetCookie. Os cookies que você pode criar no WPF são os mesmos cookies que outros tipos de aplicativos da Web usam; os cookies são pedaços arbitrários de dados que são armazenados por um aplicativo em um computador cliente durante ou nas sessões do aplicativo. Os dados do cookie normalmente assumem a forma de um par nome/valor no formato a seguir.

Nome=Valor de

Quando os dados são passados para SetCookie, juntamente com a Uri do local para o qual o cookie deve ser definido, um cookie é criado na memória, e ele só está disponível para a duração da sessão atual do aplicativo. Esse tipo de cookie é conhecido como um cookie de sessão.

Para armazenar um cookie em sessões do aplicativo, uma data de validade deve ser adicionada ao cookie, usando o formato a seguir.

NOME=VALOR de; expires=DAY, DD-MMM-YYYY HH:MM:SS GMT

Um cookie com uma data de validade é armazenado na pasta atual Temporary Internet Files da instalação do Windows até que o cookie expire. Um cookie é conhecido como um cookie persistente porque ele persiste nas sessões do aplicativo.

Você recupera tanto cookies de sessão quanto persistentes chamando o método GetCookie, passando o Uri do local onde o cookie foi definido com o método SetCookie.

ObservaçãoObservação:

F um exemplo ou que demonstra como usar o SetCookie e GetCookie métodos para criar e recuperar os cookies de um WPF aplicativo, consulte Exemplo de cookies de aplicativo.

Eis algumas das maneiras como os cookies são suportados em WPF:

  • Aplicativos independentes WPF e XBAPs podem criar e gerenciar cookies.

  • Cookies que são criados por um XBAP podem ser acessados a partir do navegador.

  • XBAPs do mesmo domínio podem criar e compartilhar cookies.

  • XBAPs e páginas HTML do mesmo domínio podem criar e compartilhar cookies.

  • Cookies são distribuídos quando XBAPs páginas XAML fracamente acopladas fazem solicitações da Web.

  • Tanto XBAPs de alto nível quanto XBAPs hospedados em IFrames podem acessar cookies.

  • Suporte a cookie no WPF é o mesmo para todos os navegadores suportados (Internet Explorer 7,Microsoft Internet Explorer 6 e o Firefox 2.0 +).

  • Em Microsoft Internet Explorer 6 e Internet Explorer 7, a diretiva P3P relacionada aos cookies é aceita por WPF, especialmente com relação a XBAPs primários e de terceiros .

Se você precisar passar dados de uma Page para outra, você pode passar os dados como argumentos para um construtor não padrão de Page. Observe que se você usa essa técnica, você deve manter a Page ativa; senão, na próxima vez em que você navega para a Page, WPF reinstancia a Page usando o construtor padrão.

Como alternativa, sua Page pode implementar propriedades que são definidas com os dados que precisam ser passadas. As coisas ficam complicadas, no entanto, quando uma Page precisa passar dados de volta para a Page a partir da qual se navegou a ela. O problema é que navegação não oferece suporte a mecanismos para garantir que se retorne a uma Page depois que se navegou dela. Essencialmente, navegação não suporta semântica de chamada/retorno. Para resolver esse problema, WPF fornece uma classe PageFunction<T> que você pode usar para garantir que se retorne a uma Page de uma maneira previsível e estruturada. Para obter mais informações, consulte Visão Geral de Navegação Estruturada.

A classe NavigationWindow

Até este ponto, você viu a gama de serviços de navegação que você provavelmente usará para criar aplicativos com conteúdo navegável. Esses serviços foram discutidos no contexto de XBAPs, embora não seja limitados a XBAPs. Os modernos sistemas operacionais e Windows aplicativos tirar proveito da experiência do navegador dos usuários modernos para incorporar navegação no estilo de navegador aplicativos autônomos. Exemplos comuns incluem:

  • Dicionário de sinônimos do palavra: navegar opções de palavra.

  • Arquivo Explorer: Navegar em arquivos e pastas.

  • Assistentes: Dividindo uma tarefa complexa em várias páginas pode ser navegado entre. Um exemplo é o Assistente de Componentes do Windows que manipula adição e remoção de recursos Windows.

Para incorporar navegação no estilo de navegador em seus aplicativos autônomos, você pode usar o NavigationWindow classe. NavigationWindow deriva da Window e a estende com o mesmo suporte de navegação que XBAPs fornece. Você pode usar NavigationWindow sistema autônomo a janela principal do aplicativo autônomo ou sistema autônomo uma janela secundária sistema autônomo uma caixa de diálogo.

Para implementar uma NavigationWindow, tal como com a maioria de classes de alto nível WPF (Window, Page, e assim por diante), você usa uma combinação de marcação e arquivos de lógica. Isto é mostrado no exemplo a seguir.

<NavigationWindow
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MainWindow" 
    Source="HomePage.xaml"/>

using System.Windows.Navigation; // NavigationWindow

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

Esse código cria uma NavigationWindow que automaticamente navega para uma Page (HomePage.xaml) quando a NavigationWindow é aberta. Se a NavigationWindow for a janela principal do aplicativo, você pode usar o atributo StartupUri para iniciá-la. Isso é mostrado na seguinte marcação.

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

A figura a seguir mostra a NavigationWindow como a janela principal de um aplicativo independente.

Uma janela principal

Da figura, você pode ver que a NavigationWindow tem um título, apesar de não ter sido definido no código de implementação da NavigationWindow do exemplo anterior. Em vez disso, o título é definido usando a propriedade WindowTitle, que é mostrada no código a seguir.

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


...


</Page>

Configurar as propriedades WindowWidth e WindowHeight também afeta a NavigationWindow.

Geralmente, você implementa sua própria NavigationWindow quando você precisa personalizar seu comportamento ou aparência. Se você não precisa de nada disso, você pode usar um atalho. Se você especificar a URI pack de uma Page como a StartupUri em um aplicativo independente, Application criará automaticamente uma NavigationWindow para hospedar a Page. A marcação a seguir mostra como permitir isso.

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

Se você deseja que uma janela secundária do aplicativo, tal como uma caixa de diálogo, seja uma NavigationWindow, você pode usar o código no exemplo a seguir para abri-la.

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

A figura a seguir mostra o resultado.

Uma caixa de diálogo

Como você pode ver, NavigationWindow exibe botões Voltar e Avançar no estilo de Internet Explorer 7 que permitem aos usuários navegar no journal. Esses botões fornecem a mesma experiência do usuário, conforme mostrado na figura a seguir.

Botões Voltar e Avançar em uma NavigationWindow

Se suas páginas fornecem seus próprios suporte de navegação do journal e interface do usuário, você pode ocultar os botões Voltar e Avançar exibidos por NavigationWindow definindo o valor da propriedade ShowsNavigationUI para false. Como alternativa, você pode usar o suporte a personalização em WPF para substituir a UI da própria NavigationWindow. Para obter um exemplo de como fazer isso, consulte Exemplo de interface de usuário NavigationWindow personalizado.

A classe Frame

O navegador e a NavigationWindow são janelas que hospedam conteúdo navegável. Em alguns casos, os aplicativos têm conteúdo que não precisa estar hospedado por uma janela inteira. Em vez disso, o conteúdo pode ser hospedado dentro de outro conteúdo. Você pode inserir conteúdo navegável em outros tipos de conteúdo usando o Frame classe. Frame Fornece o mesmo suporte sistema autônomo NavigationWindow e XBAPs.

O exemplo a seguir mostra como adicionar um Frame a uma Page declarativamente usando o elemento Frame.

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


...


<Frame Source="FramePage1.xaml" />


...


</Page>

Este marcação define o atributo Source do elemento Frame com uma URI pack para a Page para a qual o Frame inicialmente deve navegar. A figura a seguir mostra um XBAP com uma Page que tem um Frame que navegou entre várias páginas.

Um quadro que navegou entre várias páginas

Você não precisa usar Frame somente dentro do conteúdo de uma Page. Também é comum hospedar um Frame dentro do conteúdo de uma Window. Para um exemplo, consulte Navegação do quadro em um exemplo de janela.

Por padrão, Frame usa apenas seu próprio journal na ausência de outro journal. If a Frame faz parte do conteúdo que é hospedado dentro de um um NavigationWindow ou um XBAP, Frame usa o diário que pertence a NavigationWindow ou XBAP. Às vezes, porém, um Frame talvez precise ser responsável por seu próprio diário. Um motivo para isso é permitir a navegação do journal dentro de páginas que são hospedados por um Frame. Isso é ilustrado pela figura a seguir.

Diagrama de quadros e páginas

Nesse caso, você pode configurar o Frame para usar seu próprio journal, definindo a propriedade JournalOwnership de Frame para OwnsJournal. Isso é mostrado na seguinte marcação.

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


...


<Frame Source="FramePage1.xaml" JournalOwnership="OwnsJournal" />


...


</Page>

A figura a seguir ilustra o efeito de navegar em um Frame que usa seu próprio journal.

Um quadro que usa seu próprio diário

Observe que as entradas de journal são mostradas pela UI de navegação no Frame, em vez de pelo Internet Explorer 7.

ObservaçãoObservação:

Se um Frame faz parte do conteúdo que está hospedado em um Window, Frame usa seu próprio diário e, conseqüentemente, exibe sua própria navegação UI.

Se seu experiência do usuário requer que um Frame forneça seu próprio journal sem mostrar a navegação de UI, você pode ocultar a navegação de UI definindo a NavigationUIVisibility para Hidden. Isso é mostrado na seguinte marcação.

<Page 
  xmlns="https://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>

Hosts de navegação

Frame e NavigationWindow são classes que são conhecidas como hosts de navegação. Um host de navegação é uma classe que pode navegar para e exibir conteúdo. Para fazer isso, cada host de navegação usa seus próprios NavigationService e journal. A construção básica de um host de navegação é mostrada na figura a seguir.

Diagramas do navegador

Basicamente, isso permite que NavigationWindow e Frame forneçam o mesmo suporte de navegação que um XBAP fornece quando hospedado no navegador.

Além de usar NavigationService e um journal, hosts de navegação implementam os mesmos membros que NavigationService implementa. Isso é ilustrado pela figura a seguir.

Um diário em Frame e em NavigationWindow

Isso permite que você programe suporte a navegação diretamente para eles. Você pode considerar isso caso você precise fornecer uma navegação personalizada UI para um Frame que está hospedado em um Window. Além disso, os dois tipos de implementam os membros adicionais, relacionados a navegação, incluindo BackStack (NavigationWindow.BackStack, Frame.BackStack) e ForwardStack (NavigationWindow.ForwardStack, Frame.ForwardStack), que permitem que você enumerar as entradas de diário na pilha Voltar e pilha de encaminhar, respectivamente.

Como mencionado anteriormente, mais de um journal pode existir dentro de um aplicativo. A figura a seguir fornece um exemplo de quando isso pode acontecer.

Vários diários dentro de um aplicativo

Ao longo desse tópico, Page e XBAPs pack foram usados para demonstrar os vários recursos de navegação de WPF. No entanto, uma Page que é compilada em um aplicativo não é o único tipo de conteúdo para o qual se pode navegar, e XBAPs Pack não são a única maneira de identificar conteúdo.

Como esta seção demonstra, você também pode navegar para arquivos XAML fracamente acoplados, arquivos HTML e objetos.

Um arquivo XAML fracamente acoplado é um arquivo com as seguintes características:

  • Contém somente XAML (ou seja, nenhum código).

  • Tem uma declaração de namespace apropriada.

  • Tem o extensão de nome de arquivo .XAML.

Por exemplo, considere o seguinte conteúdo que é armazenado como um arquivo XAML fracamente acoplado, Person.XAML.

<!-- Person.xaml -->
<TextBlock xmlns="https://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>

Quando você clica duas vezes no arquivo, o navegador abre e navega para e exibe o conteúdo. Isso é mostrado na figura a seguir.

Exibição do conteúdo no arquivo Person.XAML

Você pode exibir um arquivo XAML fracamente acoplado da seguinte:

  • Um ste da Web na máquina local, intranet ou Internet.

  • Um compartilhamento de arquivo Convenção de nomenclatura universal (UNC).

  • O disco local.

Um arquivo XAML fracamente acoplado pode ser adicionado aos favoritos do navegador, ou ser home page do navegador.

ObservaçãoObservação:

F ou para obter mais informações sobre como publicar e iniciando ampliada XAML páginas, consulte Implantar um aplicativo WPF (WPF).

Uma limitação em relação aos XAML fracamente acoplados é que você pode somente hospedar conteúdo que é seguro para executar em confiança parcial. Por exemplo, Window não pode ser o elemento raiz de um arquivo XAML fracamente acoplado. Para obter mais informações, consulte Windows Presentation Foundation Partial Trust Security.

Como você pode esperar, você também pode navegar para HTML. Basta fornecer uma URI que usa o esquema HTTP. Por exemplo, o seguinte XAML mostra um Frame que navega para uma página HTML.

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

Navegar para HTML requer permissões especiais. Por exemplo, você não pode navegar por um XBAP que está executando na caixa de proteção de segurança de confiança parcial de zona de Internet. Para obter mais informações, consulte Windows Presentation Foundation Partial Trust Security.

A navegação para arquivos HTML, usando o controle WebBrowser

Ao mesmo tempo em que Frame oferece um misto XAML/HTML experiência de navegação Frame oferece suporte à interoperação entre hospedado HTML páginas e host WPF aplicativos. Specifitelefonary, não há nenhum mecanismo para ativar o script funções implementadas pelo HTML página telefonar código gerenciado métodos implementados pelo host WPF aplicativo. Da mesma forma, WPF aplicativos não têm uma maneira de chamar funções de script hospedado HTML páginas. Se você precisar desse recurso, você pode usar o WebBrowser em vez disso, controlar quais oferece suporte HTML documento de hospedagem, navegação e, naturalmente, interoperabilidade de código de script/gerenciado. Para obter informações detalhadas sobre o WebBrowser controle, consulte WebBrowser. Para obter um exemplo que demonstra a variedade de funções com suporte WebBrowser, consulte Exemplo do Controlarar Navegador da Web.

Como Frame, navegue até HTML usando o WebBrowser requer permissões de acesso especiais. Por exemplo, de um aplicativo parcialmente confiável, você pode navegar somente para HTML localizado no site de origem. Para obter mais informações, consulte Windows Presentation Foundation Partial Trust Security.

Se você tiver dados que são armazenados como objetos personalizados, uma maneira para exibir os dados é criar uma Page com conteúdo que é vinculado a esses objetos (consulte Revisão de Associação de Dados) . Se você não desejar a sobrecarga de criar uma página inteira apenas para exibir os objetos, você pode navegar diretamente para eles em vez disso.

Considere a classe Person que é implementada no código a seguir.

Para navegar até ela, você chama o método NavigationWindow.Navigate, conforme demonstrado pelo código a seguir.

A figura a seguir mostra o resultado.

Página que navega até uma classe

A partir dessa figura, você pode ver que nada útil é exibido. Na verdade, o valor que é exibido é o valor de retorno do método ToString do objeto Person; por padrão, esse é o único valor que WPF pode usar para representar seu objeto. Você pode substituir o método ToString para retornar informações mais significativas, apesar de ele ainda apenas ser um valor de sequência de caracteres. Uma técnica que você pode usar que tira vantagem dos recursos de apresentação WPF é usar um modelo de dados. Você pode implementar um modelo de dados que WPF pode associar a um objeto de um tipo específico. O código a seguir mostra um modelo de dados para o objeto Person.

Aqui, o modelo de dados é associado ao tipo Person usando a extensão de marcação x:Type no atributo DataType. O modelo de dados, em seguida, vincula elementos TextBlock (consulte TextBlock) às propriedades da classe Person. A figura a seguir mostra a aparência atualizada do objeto Person.

Navegando até uma classe que tem um modelo de dados

Uma vantagem dessa técnica é a consistência que você obtém sendo capaz de reutilizar o modelo de dados para exibir seus objetos de forma consistente em qualquer lugar do seu aplicativo.

For the complete sample, see Navegue para um exemplo de objeto Personalizar.

Para obter mais informações sobre modelos de dados, consulte Visão geral sobre Templating de dados.

Segurança

Suporte a navegação de WPF permite que XBAPs sejam navegados através da Internet, e ele permite que aplicativos hospedem conteúdo de terceiros. Para proteger os aplicativos e usuários contra comportamento prejudicial, WPF fornece uma variedade de recursos de segurança que são abordados em Windows Presentation Foundation Security e Windows Presentation Foundation Partial Trust Security.

Consulte também

Tarefas

Lembre-se um conjunto Simples de estado entre instâncias de página

Lembre-se Múltiplo conjuntos de estado por instância de página

Lembre-se um item Simples do estado em instâncias de página

Exemplo de Assistente

Exemplo de interface de usuário NavigationWindow personalizado

Navegação do quadro em um exemplo de janela

Exemplo de cookies de aplicativo

Conceitos

Visão Geral do Gerenciamento de Aplicativo

URIs de Pacotes no Windows Presentation Foundation

Visão geral sobre aplicativos Windows Presentation Foundation hospedados no Windows Media Center

Visão Geral de Navegação Estruturada

Implantar um aplicativo WPF (WPF)

Referência

SetCookie

GetCookie

Date

History

Motivo

Julho de 2008

Adicionado A navegação para arquivos HTML, usando o controle WebBrowser.

Alteração de recurso do SP1.