Desenvolvimento - ASP. NET

Migrando de ASP para ASP.NET

Este artigo tem como finalidade mostrar aos desenvolvedores ASP como são realizados os mais frequentes processos, fazendo uma comparação entre ASP e depois em ASP.NET, iniciando com um overview sobre a plataforma .NET.

por Israel Aéce


Com a vinda do ASP.NET e o Visual Studio .NET, quem utiliza o ASP para o desenvolvimento de aplicações Web sentiu e sente dificuldades para tal migração, principalmente com o novo conceito de Code Behind que tem por finalidade de separar o código que é executado no servidor do HTML que é exibido no cliente.

Muitas vezes chegam até a pensar se é viável ou não a migração. E a resposta é sim. O ASP.NET nos traz uma nova forma de desenvolvimento para a Web, possibilitando construirmos aplicativos profissionais com uma grande facilidade, principalmente quando utilizamos o Visual Studio .NET como ferramenta de desenvolvimento.

Este artigo tem como finalidade mostrar aos desenvolvedores ASP como são realizados os mais frequentes processos, fazendo uma comparação entre ASP e depois em ASP.NET, iniciando com um overview sobre a plataforma .NET.

.NET Framework

O Microsoft .NET Framework é um conjunto de objetos para a construção de aplicativos, sejam eles Web, Windows ou Mobile. Atualmente ele se encontra em sua versão 1.1, e qual podemos utilizar o Visual Studio .NET 2003 para desenvolvemos sob ela.

CLR - Common Language Runtime

O Common Language Runtime (CLR) é o ambiente que gerencia a execução de código. Tradicionalmente ao criar um aplicativo, (em Visual Basic por exemplo), o mesmo é compilado em linguagem que o computador possa entender (0 e 1) e então o executa. Note que em diferentes tipos de computadores (PC"s e Machintoshes), você deverá recompilar o aplicativo para o mesmo se adaptar ao computador que vai utilizá-lo. Com a .NET Framework, isso funciona de forma diferente.

Em .NET Framework você utiliza uma linguagem de programação (sendo Visual Basic .NET ou Visual C# .NET) para escrever o código e a .NET Framework em conjunto com a CLR para compilar este código escrito. Mas ao invés deste código ser compilado para a linguagem nativa do computador, o mesmo é compilado para uma linguagem intermediária, chamada de MSIL (Microsoft Intermediate Language), que é uma forma abreviada de representar este código que você escreveu.

Tendo este código intermediário, ao executar o aplicativo o Common Language Runtime assume e compila o código, agora em linguagem nativa do computador por um compilador Just-In-Time (JIT), otimizando o melhor possível para aquele processador. Veremos abaixo as duas formas, com e sem o .NET Framework:


Figura 1 - Aplicativo sendo executado da forma tradicional.
Figura 2 - Com o .NET Framework.

Metadados

Quando compilamos nossos aplicativos ASP.NET, eles também são compilados para MSIL, criando assim o que chamamos de metadados que são informações descritivas sobre o aplicativo, dizendo o que o aplicativo pode fazer, a que pertence, etc.

A CLR utiliza esses metadados para descobrir de que forma executar esse aplicativo. Esse código que é executado pela CLR, é o que chamamos de código gerenciado. Isso faz com que o desenvolvedor não precise construir manulmente para gerenciar os recursos. Mas isso não é tudo que a CLR faz. Além disso, nos fornece a integração entre diferentes linguagens, tratamento de erros, entre outras características importantes para o desenvolvimento de nossas aplicações (Windows, Web ou Mobile).

Diferenças do ASP.NET em relação ao ASP

Entre os muitos benefícios fornecidos pelo ASP.NET tais como cache, compilação de código, segurança podemos destacar a facilidade no desenvolvimento, pois como vimos anteriormente, o código fica encapsulado dentro de um arquivo *.DLL, qual é preciso apenas utilizar o XCOPY para a distribuição, não havendo a necessidade do registro da mesma com o uso do REGSVR32.EXE, não tendo mais o "DLL Hell" (Inferno das DLL"s).

No ASP tinhamos o código que era executado dentro das tags <% ... %> que atualmente não é mais compilado e seu uso não aconselhado, pois evita a mescla de código de servidor juntamente com o código HTML, o chamado spaghetti code.

Uma das grandes inovações é o CodeBehind. Com ele é possível separarmos o código do servidor do código HTML. O CodeBehind pode ser escrito em Visual Basic .NET ou Visual C# .NET e ao compilar o aplicativo esse código é encapsulado dentro da DLL, sendo necessário apenas o envio do arquivo ASPX para o servidor de produção. Ao criar um novo WebForm no Visual Studio .NET, são criados dois arquivos: o arquivo Arquivo.aspx (arquivo que contém o código HTML) e o Arquivo.aspx.vb ou Arquivo.aspx.cs (arquivo que contém o código que é executado no servidor). Quando o aplicativo é escrito em Visual Basic .NET, a extensão do arquivo é *.aspx.vb e sendo escrito em Visual C# .NET, a extensão será *.aspx.cs.

Abaixo veremos a estrutura do CodeBehind:

Figura 3 - Estrutura do CodeBehind dos arquivos ASPX.
O Fluxo

Poderão notar na primeira vez que executar o aplicativo, haverá um leve retardo. Isso ocorre devido a compilação do código que é realizado. Já na segunda vez esse processo não é efetuado, aumentando ainda mais a performance do aplicativo. Ao receber a solicitação de uma página, a mesma é compilada (caso seja a primeira vez), trata os eventos da Página e de seus controles, executa o código referente à esses eventos e finalmente gera o código HTML e envia ao browser. Abaixo a imagem ilustra o processo.

Figura 4 - Processo de execução de uma página ASPX.

As Linguagens de Programação

Vale lembrar que ASP assim como o ASP.NET não é uma linguagem de programação e sim uma tecnologia para desenvolvimento de aplicativos Web-Based. com isso, temos algumas linguagens em quais podemos escrever aplicativos ASP.NET, tais como: Visual Basic .NET, Visual C# .NET, C++ ou JScript.NET, que independentemente de qualquer linguagem que escrevemos, o código será sempre compilado para MSIL. Essas linguagens estão em conformidade com a CLS - Common Language Specification, que garante a conversação de aplicativos de diferentes linguagens. E todas as linguagens devendo ser 100% Orientada a Objetos.

Em ASP utilizavamos VBScript ou JavaScript para escrevemos os aplicativos, sendo os mesmos interpretados quando eram executados.

Hoje temos linguagens fortemente tipadas para isso, ou seja, por padrão devemos sempre especificar qual o tipo da variável qual estamos trabalhando, nos obrigando a declarar todas as váriveis.

Comparando ASP vs. ASP.NET (Códigos)

Abaixo será mostrado uma série de exemplos feitos em ASP e depois em ASP.NET para mostrar a diferença entre as duas tecnologias. Com esses exemplos ficará claro a facilidade de desenvolvimento de aplicativos feitos em ASP.NET.

Preenchendo DropDownList

:: ASP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Dim conn
Dim rs
Set rs = Server.CreateObject("ADODB.Recordset")
conn.Open
rs.Open "SELECT * FROM Categories",conn
If Not rs.EOF Then
Response.Write ("<select name = "cboareas">")
Response.Write ("<option value = "">Selecione...</option>")
While Not rs.EOF
Response.Write ("<option value = " & rs("CategoryID"))
Response.Write (">" & rs("CategoryName") & "</option>")
rs.Movenext
Wend
Response.Write ("</select>")
End If
rs.Close
conn.Close
Set rs = Nothing
Set conn = Nothing

:: ASP.NET
1
2
3
4
5
6
7
8
9
Dim conn As SqlConnection = New SqlConnection("CONNECTION_STRING")
Dim cmd As SqlCommand = New SqlCommand("SELECT * FROM Categories", conn)
Me.DropDownList1.DataTextField = "CategoryName"
Me.DropDownList1.DataValueField = "CategoryID"
conn.Open()
Me.DropDownList1.DataSource = cmd.ExecuteReader
Me.DropDownList1.DataBind()
conn.Close()


Exibindo Grid"s de dados

:: ASP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Dim conn
Dim rs
Set rs = Server.CreateObject("ADODB.Recordset")
conn.Open
rs.Open "SELECT * FROM Categories",conn
If Not rs.EOF Then
Response.Write ("<table width = "100%" align = "center">")
While Not rs.EOF
Response.Write ("<tr>")
Response.Write ("<td>" & rs("CategoryID") & "</tr>")
Response.Write ("<td>" & rs("CategoryName") & "</tr>")
Response.Write ("</tr>")
rs.Movenext
Wend
Response.Write ("</table>")
End If
rs.Close
conn.Close
Set rs = Nothing
Set conn = Nothing

:: ASP.NET
1
2
3
4
5
6
7
Dim conn As SqlConnection = New SqlConnection("CONNECTION_STRING")
Dim cmd As SqlCommand = New SqlCommand("SELECT * FROM Categories", conn)
conn.Open()
Me.DataGrid1.DataSource = cmd.ExecuteReader
Me.DataGrid1.DataBind()
conn.Close()


Formulários - Post

:: ASP
1
Response.Write(Request.Form("TextBox1"))

:: ASP.NET
1
2
3
4
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Response.Write(Me.TextBox1.Text)
End Sub

OBS.: Como o desenvolvimento de aplicações ASP.NET esta muito semelhante à aplicações Windows, agora basta darmos um duplo clique no botão e ali codificar, não havendo mais a necessidade da criação de uma nova página para processar o formulário.

Acesso à Banco de Dados

:: ASP
1
2
3
4
5
6
7
8
Dim conn
Set conn = Server.CreateObject("ADODB.Connection")
conn.ConnectionString = "CONNECTION_STRING"
conn.Open()
"...
conn.Close()
Set conn = Nothing

:: ASP.NET
1
2
3
4
Dim conn As SqlConnection = New SqlConnection("CONNECTION_STRING")
conn.Open()
"...
conn.Close()


Preenchendo um Formulario

:: ASP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Dim conn
Dim rs
Set rs = Server.CreateObject("ADODB.Recordset")
conn.Open
rs.Open "SELECT TOP 1 * FROM Categories",conn
If Not rs.EOF Then
Response.Write ("<input type = "text" name = "txtNome" value = "" & rs("CategoryName") & "">")
End If
rs.Close
conn.Close
Set rs = Nothing
Set conn = Nothing

:: ASP.NET
1
2
3
4
5
6
7
8
9
10
Dim conn As SqlConnection = New SqlConnection("CONNECTION_STRING")
Dim cmd As SqlCommand = New SqlCommand("SELECT Top 1 * FROM Categories", conn)
conn.Open()
Dim dr As SqlDataReader = cmd.ExecuteReader
If dr.Read() Then
Me.txtNome.Text = dr("CategoryName")
End If
conn.Close()


Lendo o conteudo de Arquivos TXT

:: ASP
1
2
3
4
5
6
7
Dim txt
Set txt = FSO.OpenTextFile(Server.MapPath("Arquivo.txt"))
Do While txt.AtendOfStream <> True
Response.Write(txt.ReadLine)
Loop
txt.Close

:: ASP.NET
1
2
3
Dim reader As New StreamReader(Server.MapPath("Arquivo.txt"))
Dim conteudo As String = reader.ReadToEnd
Response.Write(conteudo)

Observações Importantes: Como nos exemplos acima utilizamos como Base de Dados o SQL Server 2000, deve se importar o Namespace System.Data.SqlClient. Ja para utilizar as classes para manipulação de arquivos, deve se importar o Namespace System.IO (Somente para os exemplos escritos em ASP.NET). Abaixo a sintaxe para a Importação:

1
2
Imports System.Data.SqlClient
Imports System.IO


CONCLUSÃO: Como vimos o ASP.NET nos fornece uma facilidade muito grande. Utilizando ainda o Visual Studio .NET como ferramenta de desenvolvimento, as coisas ficam ainda mais fáceis, visto que temos Wizards, Intellisense, entre outras ferramentas que proporcionam um desenvolvimento rápido de aplicações.

Artigo desenvolvido utilizando:

* Visual Studio .NET 2003
* .NET Framework 1.1
* SQL Server 2000
* Windows XP Professional
Israel Aéce

Israel Aéce - Especialista em tecnologias de desenvolvimento Microsoft, atua como desenvolvedor de aplicações para o mercado financeiro utilizando a plataforma .NET. Como instrutor Microsoft, leciona sobre o desenvolvimento de aplicações .NET. É palestrante em diversos eventos Microsoft no Brasil e autor de diversos artigos que podem ser lidos a partir de seu site http://www.israelaece.com/. Possui as seguintes credenciais: MVP (Connected System Developer), MCP, MCAD, MCTS (Web, Windows, Distributed, ASP.NET 3.5, ADO.NET 3.5, Windows Forms 3.5 e WCF), MCPD (Web, Windows, Enterprise, ASP.NET 3.5 e Windows 3.5) e MCT.