Migrando de ASP para ASP.NET


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.

Anúncios

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s