ASP.NET Extreme: Navegação de página (tradução)

Rob Howard

Quando eu era criança, todos os anos passava algumas semanas saindo com minha família. Quando jovem, eu era fascinado pelos trens elétricos holandeses, algo que nunca tinha visto em minha cidade natal, Dallas, Texas. Meus primos me convidaram para um passeio em seu barco para observar um trem que passava. Sentado na água perto dos trilhos, você pode ouvir o trem se aproximando, como um apito suave através dos trilhos, até tocar um clímax lento quando o trem passa. Não pude deixar de me lembrar disso ao pensar no ASP.NET 2.0. O ASP.NET 2.0 está muito próximo e a maioria de nós está aguardando ansiosamente seu lançamento em breve, até mesmo ouvindo o "woo" de que o lançamento continua a ficar cada vez mais alto. Então a maneira como escrevemos software mudará mais uma vez.

O objetivo do ASP.NET 2.0 da Microsoft é fornecer aos desenvolvedores 50% de desempenho. No entanto, as melhorias reais de desempenho parecem exceder as expectativas. Novos recursos de personalização, associação e gerenciamento de funções aliviam os desenvolvedores, enquanto outros recursos, como vinculação de dados, também são simplificados. Por exemplo, a sintaxe familiar e ainda suportada:

<%# DataBinder.Eval (Container.DataItem, "FirstName") %>

No ASP.NET 2.0 pode ser simplificado para:

<%# Eval("FirstName") %>

Não há apenas muitos novos recursos impressionantes, mas também muitos controles de servidor significativos. O modelo de programação ASP.NET se tornará ainda mais poderoso no ASP.NET 2.0 devido à integração da associação com controles de servidor como o controle <ASP:login> e novos controles de servidor de fonte de dados e controle de dados.

O número de bibliotecas de classes System.Web quase dobrou no ASP.NET 2.0 - tanta cobertura que requer até uma coluna de revista. Para realmente compreender a extensão dessas mudanças, você precisará de um novo livro sobre ASP.NET 2.0. Pretendo escrever algumas colunas aqui para destacar alguns dos novos recursos mais importantes do ASP.NET 2.0. Este mês vou me concentrar na navegação e no fluxo da página, começando com um recurso muito procurado – a capacidade de enviar para outras páginas.

Entrega entre páginas

A maior reclamação que ouço dos desenvolvedores que estão migrando para o ASP.NET é que o modelo de postback de páginas do ASP.NET pode ter um único <form> e só pode postar HTTP de volta para si mesmas, de modo que todo o processamento e toda a lógica serão executados. esta página.

Muitos desenvolvedores, especialmente aqueles que estão familiarizados com ASP e gostam de controlar o elemento <form>, saberão que em ASP você pode instruir o <form> onde e como enviar seus dados de conteúdo (HTTP Post ou HTTP Get), e o mesma página A quantidade de <form>. Mas comparado ao ASP, o ASP.NET permite que uma página tenha apenas um <form runat=server> e só pode ser postada de volta para si mesma. Isso pode ser muito frustrante. Aqui está um exemplo do que é enviado para outras páginas no ASP.NET 2.0:

<%@ Page MasterPageFile="~/Site.master" Language="C#"
CodeFile = "Fonte.aspx.cs"
Herda = "Fonte" %>

<ASP:Content ID="MainContent"
ContentPlaceHolderID="Principal" Runat="servidor">
Digite seu nome:
<ASP:TextBox ID="NameBox" Runat="servidor"></ASP:TextBox>
<ASP:Button ID="Button1" Runat="servidor" Text="Enviar" />
</ASP:Conteúdo>

As páginas mestras são usadas para controlar o layout da página, com um bloco <ASP:content> e alguns controles de servidor para aceitar entradas do usuário.

Se você planeja passar conteúdo para outra página, você pode usar um código de servidor semelhante ao seguinte:

Response.Redirect("Target.aspx?Name= " +
HttpUtility.UrlEncode(NameBox.Text));

O problema dessa tecnologia é que quando o usuário clica no botão para enviar, o servidor aceita a solicitação e envia uma resposta para redirecionar o navegador para Target.aspx. Um problema tão simples deu muito trabalho!

O trabalho pode ser simplificado? No ASP.NET 2.0 a resposta é sim. A seguir, demonstre o código aprimorado:

<%@ Page MasterPageFile="~/Site.master" Language="C#"
CodeFile = "Fonte.aspx.cs"
Herda = "Fonte" %>

<ASP:Content ID="MainContent"
ContentPlaceHolderID="Principal" Runat="servidor">
Digite seu nome:
<ASP:TextBox ID="NameBox" Runat="servidor"></ASP:TextBox>
<ASP:Button ID="Button1" Runat="servidor" Text="Enviar"
PostBackUrl="~/Target.aspx" />
</ASP:Conteúdo>

Observe o atributo PostBackUrl em <ASP:Button>. Esse atributo informa ao botão para não executar o postback padrão, mas para enviar dados diretamente para Target.aspx.

Você pode estar se perguntando como isso funciona, especialmente se estiver familiarizado com o ASP.NET ViewState. objeto. Mas isso está além do escopo deste artigo, quando o recurso de entrega entre páginas for usado, um novo campo oculto será adicionado à página:

<input type="hidden" name="__PREVIOUSPAGE" id="__PREVIOUSPAGE"
valor="p1-dFHlCpgH2alr1vkr3G21UIR7jOuzn074led6lbGf1KQ47_F25GwG0" />

É um pouco como o estado de visualização gerado pela árvore de controle, mas é um fragmento do estado de visualização que valida a página para entrega entre páginas. Você sabe, quando uma página é postada em outra página, a página receptora precisa ser capaz de acessar a instância da página de postagem. Neste caso, significa que Target.ASP pode acessar os detalhes de Source.aspx. Na verdade, uma abordagem mais eficiente é acessar a API de Source.aspx para Target.aspx por meio de um gerenciador fortemente tipado. Para acessar a página de entrega (página anterior), o ASP.NET2.0 fornece um atributo de página para entrega entre páginas: PreviousPage.

PreviousPage retorna a instância da página de entrega e também há uma propriedade usada para verificar se é entrega entre páginas: IsCrossPagePostBack. Essa propriedade é semelhante à IsPostBack existente, mas retorna true somente se ocorrer uma postagem entre páginas.

A propriedade PreviousPage pode se comportar de maneira diferente. O padrão simplesmente retorna uma instância da página anterior como um tipo de página. No entanto, usando uma nova diretiva, você pode fazer com que a propriedade PreviousPage retorne uma instância fortemente tipada para acessar os membros públicos da página. Por exemplo, adicione o seguinte código a Target.aspx:

<%@ PreviousPageType VirtualPath="~/Source.aspx" %>

Agora você pode usar a propriedade PreviousPage em Target.aspx para acessar os dados de Source.aspx. Porém, para acessar um controle de servidor, como o NameBox em Source.aspx, você também precisa escrever o seguinte código:

TextBox nameBox = PreviousPage.FindControl("NameBox") as TextBox

; acessar a árvore de controle. Por que? Os controles do servidor são padronizados para variáveis ​​de membro protegidas. Para ter acesso realmente simples aos elementos da página anterior, você precisa expor a propriedade ou método em Source.aspx como público, e então o seguinte código funcionará: TextBox nameBox. = PreviousPage.NameBox;

A entrega entre páginas é um ótimo recurso do ASP.NET. Existem alguns artigos que discutem detalhadamente os detalhes técnicos da entrega entre páginas. out Dino Esposito's Cutting na edição de setembro da coluna MSDN Magazine Edge (veja minha tradução: ASP.NET Form (Tradução)). Você provavelmente também descobrirá que, se tiver proficiência em ASP.NET, continuará usando o modelo de postback de página padrão na maior parte do tempo. (Tradutor: A implicação é que se você for um especialista, desprezará esse recurso)

O controle do assistente

pode facilmente construir uma função de navegação complexa para o aplicativo por meio da entrega entre páginas. No entanto, esse recurso não facilita a construção de interfaces de usuário no estilo assistente. As interfaces de usuário no estilo assistente, sejam lineares ou não lineares, geralmente são projetadas para realizar tarefas. Ele fornece aos usuários finais uma maneira fácil de concluir uma série complexa de etapas, cada uma delas dividida em partes.

No ASP.NET 1.x, os assistentes geralmente eram implementados usando alguns truques: colocar vários controles de servidor <ASP:panel> na mesma página e alternar a visibilidade com base na localização do usuário. Escrever um assistente em ASP.NET não é uma tarefa fácil. Muitos designers abandonam o assistente e o gerenciamento do processo de etapas também é confuso.

Os novos recursos de entrega entre páginas do ASP.NET podem ser usados ​​para resolver o problema do assistente, mas também são um desafio quando a navegação não linear é necessária. Por exemplo, etapa 1, etapa 2, pule as etapas 3 a 5, etapa 6, etapa 3, etapa 2, etapa 6, o controle do assistente do ASP.NET 2.0 resolve a maioria desses problemas. Além disso, todos os elementos de entrada do assistente de entrega entre páginas são continuamente acessíveis por meio do modelo de postback de página.

A funcionalidade do controle do assistente é muito próxima da forma de ocultar painéis no ASP.NET 1.1. No entanto, o controle do assistente expõe uma série de <ASP:WizardStep>, que pode conter qualquer número de controles filho. No entanto, cada <ASP:WizardStep> precisa ter seu próprio ID exclusivo, consulte a Figura 1. A página de controle do assistente gerencia toda a navegação, suporta navegação linear e não linear e tem suporte completo em tempo de design. A Figura 2 demonstra o controle do assistente. O lado esquerdo é a navegação não linear baseada em link e o lado inferior direito é a navegação linear por botão. No menu de tarefas que é aberto, você pode ver não apenas uma tarefa comum, mas uma lista de etapas que permitem alternar entre as etapas em tempo de design.

Figura 2 Assistente no Visual Studio

Todos os elementos visíveis do controle do assistente são configuráveis. Links não lineares podem ser substituídos por botões ou excluir entradas, e os elementos de navegação linear anteriores, seguintes e concluídos também podem ser transformados em botões de imagem ou links. Na verdade, todos os aspectos do controle podem ser configurados através de modelos.

Uma das dificuldades em escrever controles de assistente no ASP.NET 1.1 era gerenciar onde o usuário deveria estar. O controle do assistente simplifica essa tarefa expondo a propriedade ActiveStep. A propriedade ActiveStep pode consultar e determinar qual etapa está ativa no momento. O fluxo natural do assistente continuará conforme declarado pela implementação, e o fluxo pode ser alterado a qualquer momento através do método MoveTo. Através do MoveTo, qualquer etapa pode ser definida como ActiveStep. Para auxiliar a navegação e o processo, vários eventos também são fornecidos, veja a Figura 3.

O novo controle do assistente é muito útil ao coletar informações do usuário. Você não deseja escrever todas as estruturas básicas no ASP.NET 1.1. O controle do assistente é tão útil que a equipe ast.net o usa como classe base para o controle CreateUserWizard, que é usado para criar usuários como parte da função Membership.

As seções

Postagem entre páginas e o controle <ASP:Wizard> oferecem aos desenvolvedores ASP.NET diversas novas opções para controlar o fluxo de navegação em seus aplicativos. A entrega entre páginas é útil em situações em que você precisa usar Response.Redirect ou Server.Transfer. Os controles do assistente são ótimos para criar coleções de dados complexas que exigem coleta de dados lineares e não lineares.

-------------------------------------------------- ------
Figura 1 Etapas do assistente

<ASP:Wizard runat="server" >
<Etapas do assistente>
<ASP:WizardStep ID="Etapa1">
Bem-vindo!
</ASP:WizardStep>
<ASP:WizardStep ID="Etapa2">
Qual é o seu nome: [TextBox1]
[Botão1]
</ASP:WizardStep>
<ASP:WizardStep ID="Etapa3">
Obrigado, [TextBox1.Text]!
</ASP:WizardStep>
</WizardSteps>
</ASP:Wizard>

-------------------------------------------- --- ----------
Figura 3 Eventos de navegação