Desenvolvendo um blog com ASP.NET - Parte 2- Revista Easy Net Magazine 27

Existem muitas plataformas para desenvolver aplicações Web. Desde tecnologias que ocultam grande parte da complexidade do gerenciamento do estado da aplicação até aquelas que deixam este totalmente sob a responsabilidade do programador, é possível fazer praticamente qualquer coisa em um browser.

A justificativa para usar uma aplicação Web sendo executada em um browser em vez de uma aplicação desktop é que esta principalmente dispensa a instalação e configuração da parte do usuário e um maior controle do programador já que todos os usuários terão o mesmo código e o mesmo ambiente. Quanto à configuração, por estar localizada em um servidor, basta que esta no próprio servidor.

Dentro deste cenário surgiu há alguns anos atrás a plataforma Active Server Pages. Sua principal motivação foi dar ao desenvolvedor a possibilidade de manipular com facilidade a formatação das páginas no servidor da mesma forma que na época ele podia fazer com as aplicações desktop, arrastando controles visuais para um designer e fazendo a sua formatação. Aliado a isto tínhamos também a possibilidade de escrever pequenas partes de código para responder a eventos como cliques em botões ou links e preenchimentos em campos. Uma vez compilada e hospedada em um servidor, estas páginas eram acessadas pelos browsers normalmente como as demais aplicações, mas o servidor que recebia dados sobre o browser que estava fazendo a solicitação gerava o código HTML necessário para exibir esta página já adaptada a versão do browser para (tentar) otimizar este processo.

Esta tecnologia foi a base para o ASP.NET. Neste são usados controles de servidor para criar uma formatação básica para a página e código em uma linguagem gerenciada do .NET para manipular as regras de negócio.

Com o Visual Studio o desenvolvedor tem a opção de arrastar e soltar os controles visuais para a interface e fazer a formatação usando os editores de propriedades ou, se preferir, editar manualmente as tags HTML referentes aos controles e fazer a formatação usando suas propriedades, ou ainda, fazendo uso de classes em CSS. Esta forma de trabalhar com o ASP.NET ficou conhecida como ASP.NET Web Forms. Lembrando que um formulário é tudo o que está localizado dentro da tag <form> que é nativa do HTML. Não é possível usar controles ASP.NET fora desta TAG.

Um dos diferenciais do ASP.NET é a possibilidade de manipular a página usando linguagens de programação originalmente não orientadas para a Web para obter os dados da página e enviar para o servidor. Sem o ASP.NET é necessário conhecimento avançado de JavaScript, HTML e DOM (Nota do DevMan 1) para fazer esta tarefa.

Um dos problemas ao usar ASP.NET é que não tem muito controle com o código gerado no servidor para renderizar e enviar a página para o browser que fez a solicitação. Em muitos casos, se o desenvolvedor simplesmente arrastar componentes sem tomar cuidado e sem seguir padrões de desenvolvimento, o carregamento e comportamento destas páginas podem ficar comprometidos por tornar-se muito pesado devido ao excesso de código gerado.

É importante considerar que o código que vemos no Visual Studio referente às marcações HTML para os server side controls é diferente daquele que é enviado para o browser. Lembre-se de que browsers, mesmo os mais sofisticados, interpretam apenas HTML e JavaScript e o que dá para fazer com estes dois não é pouca coisa. Infelizmente, muitas vezes, pela geração do código ser automatizada e considerada um cenário padrão, muito código desnecessário é gerado.

Por causa de programadores descuidados e de falta de critério na hora de usar o ASP.NET, hoje existe um número considerável de desenvolvedores Web que abandonaram a sua utilização e estão voltando-se para o HTML puro novamente, o que garante maior controle da aplicação, embora, aumente consideravelmente o trabalho do desenvolvimento.

Paralelamente a isto tudo existem programadores com bom senso que se aprofundam nas tecnologias que estão adotando para fazer destas a melhor aplicação. O ASP.NET é bom e a prova disso é o número de usuários existente e de empresas que criam componentes personalizados para esta plataforma. Além disto, desde a versão 3.5 do Framework .NET é possível associar o desenvolvimento ASP.NET com design patterns como o MVC que exige a separação bem definida entre as camadas de dados (Model), exibição destes (View) e da forma como estas duas se comunicam (Controller).

Uma das boas práticas a ser seguida no desenvolvimento ASP.NET é usar server controls (TextBox, Label, ComboBox, etc.) apenas quando não for possível trabalhar com controles HTML puro. Assim, se você precisa exibir dados de forma dinâmica, que dependem de informações que estão localizadas em um banco de dados, por exemplo, é esperado e até conveniente que utilize os server controls. Já em casos de dados estáticos como textos explicativos, títulos, etc., o ideal é usar os controles HTML para acelerar a carga da sua página.

Outro ponto de vista importante é com relação à formatação. Esta precisa permitir sua fácil manutenção e modificação, algo que é difícil de fazer caso esteja vinculada diretamente com as propriedades do controle. Para simplificar, use folhas de estilo, que veremos mais a frente.

Por fim, existem validações e tarefas que podem ser feitas ainda no browser do seu usuário com o JavaScript. Algumas destas foram apresentadas na primeira parte do artigo e com o ASP.NET pode-se usar alguns server controls como os validators para gerar a validação do lado cliente automaticamente.

AJAX

Os controles do ASP.NET são todos baseados no servidor. Entretanto, para atualizar e construir páginas baseadas nestes controles, é necessário que haja um processo conhecido como server round trip, que é o envio da requisição para o servidor que vai renderizar a página e enviar a mesma novamente para o browser.

Este processo requer que toda a página do lado do servidor seja reconstruída, o que quase sempre é um processo lento dependendo do número de controles da página.

Para resolver este problema e tornar a experiência do usuário em aplicações Web mais atraente desenvolveu-se alguns anos atrás um conjunto de tecnologias denominado AJAX, tecnologia que em conjunto com o XMLHttpRequest dos browsers permite a atualização parcial do conteúdo de uma página Web.

Com esta tecnologia o servidor fornece dados que irão participar da renderização da página no browser do usuário. Os dados fazem parte do conteúdo que pode corresponder a controles como botões, caixas de listagem e texto que já foram carregados previamente e que agora, são apenas preenchidos com os dados vindos do servidor.

A biblioteca inicial para quem deseja iniciar o trabalho com o AJAX no Visual Studio e no ASP.NET é o AJAX Control Toolkit. Isso porque existem outras. Esta é indicada para o início da compreensão e vai ser usada no projeto de exemplo.

Para começar a usar esta biblioteca é necessário fazer o seu download no site do projeto (vide seção Links) e descompactar o conteúdo do arquivo em uma pasta.

Em seguida, você precisa criar uma aba na toolbox do Visual Studio para armazenar os controles da biblioteca, faça isso clicando com o botão direito do mouse sobre a toolbox e escolha a opção Add Tab (Figura 1) e digite o nome Ajax toolkit.

Figura 1. Adicionando uma nova aba - Passo 1

Com a aba criada, devemos agora adicionar os componentes clicando com o botão direito do mouse sobre a tab recém-criada e escolhendo a opção Choose Items.

O processo continua navegando pelo sistema de arquivos do seu computador para localizar a pasta onde foi descompactado o arquivo com os componentes. Isto é feito clicando no botão Browse da aba .NET Framework Components que vai exibir uma janela para pesquisar pastas e arquivos do Windows. Nesta devemos localizar o arquivo AjaxControlToolkit.dll, selecionar o mesmo e clicar em OK.

Com o arquivo da biblioteca selecionado o Visual Studio retorna para a janela já com os controles AJAX selecionados, como mostrado na Figura 2. Clicando em OK o processo é concluído.

Figura 2. Controles AJAX selecionados

Finalizado este processo o Visual Studio passará a exibir os controles desta biblioteca, como mostrado na Figura 3, que podem ser arrastados para seus Web Forms. Durante a elaboração do projeto de exemplo será demonstrada a utilização de um destes componentes.

Figura 3. Toolbox AJAX Toolkit

O funcionamento deste toolkit e dos seus controles consiste basicamente na geração do script necessário para gerenciar requisições e respostas do servidor pelo lado do cliente. Para que isto seja feito corretamente o primeiro elemento que deve estar presente na página é o ToolKitScriptManager, responsável pelo gerenciamento destas requisições. Este componente não visual é bem simples de trabalhar, precisando apenas ser arrastado. Só a sua presença já garante o correto funcionamento dos controles.

Com relação à performance do AJAX existem algumas restrições. Como foi considerado no tópico sobre o ASP.NET, o código dos componentes AJAX é gerado no servidor. Se houverem muitos componentes a tendência é que a carga inicial da página fique muito lenta.

Desta forma, é preciso usar os controles com critério. Este critério é difícil porque cada projeto tem suas características particulares. Uma boa dica é usar componentes desta biblioteca apenas onde o tempo de resposta for algo muito importante para o correto funcionamento, como por exemplo, controles de calendário ou de formatação dinâmica.

Query String

Na primeira parte do artigo fizemos a transferência de dados entre as páginas usando as variáveis de sessão (Sessions) do ASP.NET. Nesta parte veremos um pouco mais sobre como fazer esta transferência usando outro recurso chamado de QueryString. Consiste em colocar o nome da variável e o valor no campo de endereço do browser, logo após a URL da página, precedido pelo ponto de interrogação da seguinte forma: