O componente de estrutura de página ASP.NET Web Forms é um modelo escalonável de programação em tempo de execução de linguagem comum que pode ser usado para gerar páginas da Web dinamicamente. O componente ASP.NET Page Framework é uma evolução lógica do ASP (a sintaxe fornecida pelo ASP.NET é compatível com páginas existentes) e foi projetado especificamente para resolver uma série de deficiências críticas no modelo anterior. Em particular, fornece a capacidade de criar e usar controles de UI reutilizáveis que encapsulam funcionalidades comuns, reduzindo assim a quantidade de código que os desenvolvedores de páginas precisam escrever; permite que os desenvolvedores sejam claros e organizados. Ele constrói a lógica da página (não "código emaranhado"; ); as ferramentas de desenvolvimento usadas fornecem poderosos recursos de suporte ao design de páginas WYSIWYG (o que você vê é o que você obtém) (o código ASP tradicional existente é opaco). Este artigo apresenta alguns conhecimentos básicos dos recursos da página ASP.NET.
Escrevendo sua primeira página ASP.NET
As páginas ASP.NET são arquivos de texto com extensão .aspx. As páginas são compostas de código e tags que são compilados dinamicamente e executados no servidor para gerar conteúdo de exibição para o navegador (ou dispositivo) do cliente solicitante. Eles podem ser implantados na árvore de diretórios virtuais do IIS. Quando o cliente do navegador solicita um recurso .aspx, o tempo de execução do ASP.NET analisa o arquivo de destino e o compila em uma classe .NET Framework. Essa classe pode então ser usada para manipular dinamicamente a solicitação (observe que o arquivo .aspx é apenas. compilado na primeira vez que for acessado e a instância do tipo compilado poderá ser reutilizada para várias solicitações no futuro).
Não precisamos modificar o código do arquivo HTML. Precisamos apenas alterar sua extensão para .aspx para criar uma página ASP.NET. Por exemplo, o exemplo a seguir demonstra uma página HTML simples que coleta o nome e a categoria do usuário e envia o formulário de volta à página original quando o usuário clica em um botão:
<form action="intro1_vb.aspx" method= "post">
＜h3＞ Nome: ＜input id="Nome" type=text＞
Categoria: ＜selecione id="Categoria" tamanho=1＞
＜opção＞psicologia＜/opção＞
＜opção＞negócios＜/opção＞
＜opção＞popular_comp＜/opção＞
＜/selecionar＞
＜tipo de entrada=enviar valor="Pesquisa"＞
</h3＞
＜/form＞
Observação: nada acontece quando você clica no botão "Pesquisar". Isso ocorre porque o arquivo .aspx contém apenas HTML estático (sem conteúdo dinâmico). Portanto, o mesmo HTML é enviado de volta ao cliente, fazendo com que o conteúdo do campo do formulário (caixa de texto e lista suspensa) seja perdido.
Adicione código simples à página
A sintaxe fornecida pelo ASP.NET é compatível com a página ASP. Ele suporta blocos de renderização (renderização) de código <% %>, que podem ser misturados com conteúdo HTML em arquivos .aspx. Esses blocos de código serão executados estritamente quando a página for exibida.
O exemplo a seguir demonstra como usar blocos de renderização <% %> (aumentando o tamanho da fonte a cada vez) em HTML:
<form action="intro2_vb.aspx" method="post">
＜h3＞ Nome: ＜input id="Nome" type=text＞
Categoria: ＜selecione id="Categoria" tamanho=1＞
＜opção＞psicologia＜/opção＞
＜opção＞negócios＜/opção＞
＜opção＞popular_comp＜/opção＞
＜/selecionar＞
</h3＞
＜tipo de entrada=enviar valor="Pesquisa"＞
＜p＞
<% Dim I como inteiro
Para I = 0 a 7%＞
＜font size="＜%=I%＞"＞ Bem-vindo ao ASP.NET ＜/font＞ ＜br＞
＜%Próximo%＞
＜/form＞
Observe: O bloco de código ＜% %＞ no exemplo acima é diferente do ASP porque ele será realmente compilado - e não interpretado pelo mecanismo de script. Isso melhora o desempenho de execução em tempo de execução.
Os desenvolvedores de páginas ASP.NET podem usar blocos de código <% %> para modificar dinamicamente as informações de saída HTML. Por exemplo, o código a seguir demonstra como usar o bloco de código <% %> para interpretar os resultados enviados de volta pelo cliente:
<form action="intro3_vb.aspx">
＜h3＞ Nome: ＜input name="Nome" type=text value="＜%=HttpUtility.HtmlEncode(Request.QueryString("Nome"))%＞"＞
Categoria: ＜selecione nome="Categoria" tamanho=1＞
<%
Dim I como inteiro
Valores Dim (2) como string
Valores(0) = "psicologia"
Valores(1) = "negócio"
Valores(2) = "popular_comp"
Para I = 0 Para Valores.Comprimento - 1
%>
<% If (Request.QueryString("Categoria") = Valores(i)) %>
＜opção selecionada＞
<% Mais %＞
＜opção＞
＜%Fim se%＞
<%=Valores(i)%>
＜/opção＞
＜%Próximo %＞
＜/selecionar＞
</h3＞
＜tipo de entrada=nome de envio="Pesquisa" valor="Pesquisa"＞
＜p＞
<% If (Not Request.QueryString("Lookup") = Nada) %>
Olá ＜%=HttpUtility.HtmlEncode(Request.QueryString("Name")) %＞, você selecionou: ＜%=HttpUtility.HtmlEncode(Request.QueryString("Category")) %＞
＜%Fim se%＞
＜/form＞
Observação: embora os blocos de código ＜% %＞ forneçam uma maneira poderosa de personalizar as informações de saída de texto retornadas pelas páginas ASP.NET, eles não fornecem um modelo de programação HTML claro. O exemplo acima mostra que os desenvolvedores que usam apenas o bloco de código <% %> devem gerenciar o estado da página e interceptar os valores enviados por eles próprios.