O Visual Basic .NET representa a nova geração de uma das mais populares linguagens de programação: o Visual Basic. O VB.NET não é somente mais uma versão do VB 6.0 com novas características, pois foi completamente reescrito.Trata-se de uma nova linguagem. Enquanto o VB 6.0 é uma linguagem para desenvolvimento de aplicações Windows, o VB.NET foi projetado para a plataforma .NET, e permite ao desenvolvedor criar os seguintes tipos de aplicações: Windows, WEB (ASP.NET), Dispositivos Móveis (Pocket PC, PhoneEdition e SmartPhone), Console, bibliotecas de classes (Class Library), Componentes, Serviços Windows e XML Web Services.

Para conseguir dar todo esse poder ao VB.NET, a Microsoft fez algumas mudanças radicais no Visual Basic: novo ambiente de execução (runtime), novo ambiente de desenvolvimento e novo compilador.

O objetivo desse treinamento é ensinar a você como migrar sua aplicação VB 6.0 para VB.NET. Nesta primeira parte, farei uma introdução sobre algumas mudanças e novidades do VB.NET e, para finalizar, construirei uma simples aplicação em VB 6.0 para mostrar como utilizar o Code Advisor e o Upgrade Wizard.

Introdução

As mudanças no ambiente de desenvolvimento, na sintaxe da linguagem e no ambiente de execução indicam que o VB.NET ainda não é totalmente compatível com o VB 6.0. Projetos de versões anteriores precisam ser atualizados para que possam ser compilados e executados no VB.NET.

A IDE (Integrated Development Environment) foi reestruturada para dar suporte a todas as linguagens do Visual Studio: Visual Basic, Visual C# e Visual C++. A própria linguagem tem sido modernizada com remoção de algumas palavras-chave, tal como GoSub; adição de novas palavras-chave, tais como Inherits e MustInherit; e mudança no significado de outras palavras, como Return e Integer.

No ambiente de execução, o comportamento dos componentes compilados é diferente: projetos em VB.NET são compilados para “assemblies”, que podem ser um arquivo .exe ou .dll, em vez de em aplicações Windows 32. As variáveis e objetos criados pela aplicação ficam sob responsabilidade do CLR, que é também responsável por removê-los da memória, o que significa que eles têm o ciclo de vida não determinístico.

Após o lançamento do VB 6.0, as necessidades dos desenvolvedores começaram a mudar. Mais e mais programadores começaram a desenvolver para Web, e as capacidades embutidas no VB 6.0 para desenvolvimento Web não atendiam às suas necessidades. As páginas DHTML e os documentos ActiveX são tecnologias que rodam no cliente e, conseqüentemente, exigem que tanto os componentes como o runtime do VB estejam instalados na máquina cliente. Embora a WebClasses fosse uma tecnologia no lado servidor, ela armazenava estado no servidor e não era escalável. Os programadores queriam tecnologias que deixassem os clientes cada vez mais enxutos, sem downloads do runtime do Visual Basic, etc. Eles queriam um código que fosse executado com segurança e escalabilidade no servidor. Além disso, queriam novas características para linguagem: herança, interfaces, sobrecarga de métodos, código pronto para acessar facilmente a plataforma Windows e solução para os problemas de versão de DLL (o chamado Inferno da DLL, ou “DLL Hell”).

Ao procurar a solução para esses problemas, a Microsoft identificou também a oportunidade de criar um framework unificado para o desenvolvimento de aplicações na plataforma windows. Por que um framework unificado? Imagine que, para criar uma aplicação Windows no VB 6.0, no Visual C++ e em uma aplicação VBA (Visual Basic for Applications), o programador precisaria aprender as diferentes formas de trabalhar em cada linguagem. Assim, a Microsoft pensou em fazer um só produto para todas essas linguagens, tornando a vida do desenvolvedor muito mais simples e produtiva. Esse foi um dos motivos que levou a Microsoft a desenvolver um framework comum a todas as linguagens .NET.

Para que todas as linguagens acessem um framework comum, elas devem ter os mesmos tipos de dados. Esse suporte a tipos de dados iguais evita sérios problemas, tais como os que tínhamos no VB para acessar as APIs do Windows. Como todas as linguagens suportam os mesmos tipos de dados, é bem simples a interoperabilidade entre elas: herança, segurança, depuração e processo de compilação integrado.

Algumas novidades do VB.NET

O VB.NET traz novidades consideráveis, cujas características tornam a linguagem mais poderosa e acabarão com a história de que o Visual Basic é uma linguagem de programação de brinquedo. Dentre elas, destacam-se:

  • Herança – Há algum tempo os desenvolvedores vêm pedindo à Microsoft que adicione um verdadeiro mecanismo de herança ao Visual Basic. Eles querem aproveitar todo o benefício da reutilização de código e implementar projetos completamente orientados a objetos. O VB.NET suporta herança através da nova palavra-chave Inherits. Agora você pode herdar classes da sua própria aplicação, de outras aplicações e de componentes do framework .NET escritos em outras linguagens. Você ainda pode herdar layout, controle e código de outros formulários: Herança Visual.
  • Tratamento estruturado de exceção (Exception) – Além de suportar o já conhecido On Error GoTo, o Visual Basic.NET fornece um tratamento de erro estruturado através do Try...Catch...End Try. Essa forma de tratamento permite embutir o código dentro de um bloco de tratamento de erros. Uma boa prática de uso dessa forma de tratamento de erro é criar um manipulador de erro global para sua aplicação através da inclusão de um bloco Try...Catch no método Sub Main.
  • Atalhos para operadores aritméticos – Todos os operadores em Visual Basic .NET oferecem agora atalhos que permitem que você use o operador e atribua o resultado ao mesmo tempo: &= , +=, -=, *= etc.
  • Sobrecarga de métodos (overloading) – Com a sobrecarga, você pode declarar múltiplos métodos com o mesmo nome, em que cada um deles aceite um diferente número de parâmetros ou aceite parâmetros de tipos diferentes. Por exemplo, suponha que você tenha um método que exclui um cliente do banco de dados. Você poderia querer criar duas versões do método ExcluirCliente, uma para excluir um cliente através do seu código e outra para excluir o cliente através do seu nome.
  • Modelo de threads – As DLLs ActiveX do VB 6.0 e controles podem ser single thread ou apartment thread (padrão). Apartment thread significa que somente uma thread pode acessar uma instância do seu componente ActiveX num determinado momento. De fato, é sempre a mesma thread que acessa seu componente, sendo assim, outras threads não acessarão seus dados, inclusive os dados globais. Os componentes do VB.NET, por outro lado, são multithread por padrão, o que significa que duas ou mais threads podem executar simultaneamente o código dentro do componente. Cada thread tem acesso a seus dados compartilhados, tais como variáveis globais e de classe. As threads podem mudar qualquer dado compartilhado. Os componentes multithread do VB.NET são interessantes se você quiser tirar vantagem do pool de objetos do MTS, que requer componentes multithread.
  • Acesso ao Framework .NET – O Framework .NET é composto de duas partes: o CLR (Common Language Runtime) e a biblioteca de classes (class library). O CLR é a base do framework. Ele fornece os serviços básicos dos quais todas as aplicações .NET dependem: carga e execução da aplicação, gerenciamento de memória, gerenciamento de threads e segurança do código. A biblioteca de classes (class library) fornece blocos de código para criar uma variedade de aplicações .NET. Possui uma coleção de mais de 4.000 classes e com mais de 30.000 métodos para criar formulários Windows, gráficos, manipular XML, desenvolvimento para web, leitura/escrita de arquivos, transações, objetos distribuídos e acesso a banco de dados. Dentre as classes, temos as de tipos de valor, também conhecidos como tipos de sistema, tais como Byte, Integer, Long e String. Além dessas, existem as classes com estruturas complexas, tais como Collection e HashTable, bem como as interfaces ICollection e IDictionary.
  • Gerenciamento de memória – O VB.NET depende do CLR para gerenciar a memória. Isto significa que o CLR cuida de reservar memória para strings, arrays, structures e objetos. Da mesma forma, o CLR decide quando liberar as memórias utilizadas pelos objetos ou variáveis. Isto não é muito diferente do que ocorreu no VB 6.0, que também foi responsável pelo gerenciamento de memória. A principal diferença entre o VB 6.0 e o VB.NET em termos de gerenciamento de memória se dá quando um objeto ou variável é liberado.

Por exemplo, no VB 6.0, a memória alocada por uma variável ou objeto é liberada assim que você atribuir Nothing ou que a variável sair do escopo. Isso não acontece no VB.NET. Quando você atribui Nothing ou a variável sai do escopo, o VB.NET diz ao CLR que a variável não está sendo usada. O CLR marca a variável ou objeto como excluído e o submete ao Garbage Collector (GC). O GC libera a variável ou objeto da memória a qualquer momento. No VB 6.0, sabemos o exato momento em que o objeto será criado e destruído, ou seja, o ciclo de vida do objeto é determinístico. Por outro lado, o ciclo de vida do objeto no VB.NET é não-determinístico, já que você não sabe quando o objeto deixará de existir.

A principal diferença entre os dois ambientes é que o Visual Basic 6.0 é um ambiente fechado, em que nenhum dos tipos intrínsecos do Visual Basic (por exemplo, Collection, App, Screen) podem ser compartilhados com ambientes de outras linguagens, tal como C++. Essas são algumas das novidades que podemos encontrar no VB.NET, porém falar sobre todas as novidades é assunto suficiente para escrever um livro.

Antes de migrar

Antes de migrar, é importante que você saiba o que pode ou não ser migrado. No VB.NET, não são suportados (ou seja, não existe migração automática) os seguintes códigos: DDE (Dynamic Data Exchange), ligação com dados DAO ou RDO, aplicações DHTML, documentos ActiveX, páginas de propriedades, controles de usuário (User Controls) e WebClasses. Nesses casos, será necessário alterar manualmente o código em VB.NET para conseguir a mesma equivalência funcional.

Algumas aplicações exigirão um volume considerável de trabalho manual. Dentre elas, temos: Add-Ins, jogos e aplicações muito gráficas, Drag and Drop, menus Popup, objetos globais (App, Printer, Screen, Clippboard), OLE Container, ClipControls, Arrays de controles, Pointer functions, GoSub e GoTo. A Tabela 1 mostra o grau de dificuldade na migração de cada tipo de aplicação.

Forms Dificuldade

Dificuldade

Códigos: Módulos, Classes e bibliotecas
Data binding com DAO
Controles ActiveX e referências COM
Aplicações 2 e 3 camadas
Aplicações ASP com objetos de negócio em Visual Basic
Add-in
Jogos ou aplicações baseadas em características específicas do Visual Basic 6
Aplicações ActiveX DHTML e documentos ActiveX
Acesso a dados com DAO e RDO
Aplicações que acessam ambiente externo ao Visual Basic
Tabela 1. Aplicações que apresentam maior dificuldade na migração

Outro ponto importante é a ordem de migração. No caso de aplicações simples, a migração pode ser feita diretamente sem problemas; já nas aplicações mais complexas você pode optar por Top-Down ou Bottom-Up. Top-Down é feita a migração da camada cliente e a parte de negócio escrita em VB 6.0 ainda é mantida. O cliente escrito em VB.NET acessará os objetos de negócio escritos no VB 6.0. Bottom-Up é feita a migração da parte de negócio para VB.NET e modifica o cliente escrito em VB 6.0 para acessar os novos objetos. O Bottom-Up possui maior grau de dificuldade.

É importante identificar os pontos de atenção (sem migração automática, requer algum trabalho manual, possível mudança no comportamento e informativo) antes da migração. Mas não se preocupe, esses pontos serão identificados ou pelo Code Advisor ou pelo Upgrade Wizard. Veja a seguir algumas práticas de programação recomendadas para evitá-los:

  • Usar early-binding, usar verificação de tipos “Date”;
  • Não usar propriedades padrão (default);
  • Evitar utilização de nulos;
  • Usar constantes no lugar de valores;
  • Remover código legado (GoSub, GoTo);
  • Usar arrays com índice começando por 0.

É mais fácil e barato resolver os problemas no VB 6.0 e, sendo assim, tente resolver tudo o que for possível enquanto ainda estiver no programa.

Code Advisor

O Visual Basic 6.0 Code Advisor é um suplemento usado para revisar o código-fonte e assegurar que ele atenda a padrões pré-determinados de codificação (padrões esses baseados nas boas práticas desenvolvidas pela Microsoft na construção de aplicações robustas e de fácil manutenção). Para alertar sobre os pontos de atenção encontrados, o Code Advisor (baseando-se num conjunto de regras) adiciona comentários seguidos da palavra “FixIt” ao seu código VB 6.0. Você pode optar por aplicar todas as regras disponíveis ou filtrar apenas aquelas que mais lhe interessem.

Nem todos os problemas serão identificados pelo Code Advisor, já que ele foi projetado para localizar os problemas mais comuns e agilizar o processo de atualização.

Após a execução do Code Advisor, será criado um relatório (FixIt Report) com um resumo de todos os problemas encontrados, inclusive as situações onde não é possível incluir comentários “FixIt”, como, por exemplo, referências a páginas não encontradas. É importante observar que o Code Advisor não estará instalado no Visual Studio 6.0 por padrão. Você poderá obtê-lo na página de downloads da Microsoft (http://msdn.microsoft.com/vbasic/downloads/codeadvisor/default.aspx).

Usando o analisador de código – Code Advisor

Neste primeiro exemplo, construirei uma simples calculadora. O código implementado nas funções da calculadora não segue boas práticas de programação. O objetivo do exemplo é mostrar o importante papel do Code Advisor e deixar claro o quanto ele poderá ajudá-lo na migração. Como o Code Advisor adiciona comentários ao seu código, por questões de segurança você não deve se esquecer de fazer uma cópia antes de executá-lo.

Crie um novo projeto no VB 6.0 (Menu File / New Project / Standard.exe) e salve-o com o nome Exemplo1. Por padrão, já será adicionado um formulário ao projeto. Configure os componentes do formulário de acordo com a Figura 1, e as propriedades de acordo com a Tabela 2. A Listagem 1 mostra o código que será executado quando for clicado o botão “Executar Operação”.

image003.jpg
Figura 1. Layout da primeira aplicação a ser convertida
Controle Propriedade
lblNum1 (Label) Caption= “Número 1: “
lblNum2 (Label) Caption= “Número 2: “
txtNum1 (TextBox) Text = “”
txtNum2 (TextBox) Text = “”
rdbSomar (OptionButton) Caption = “Somar”
rdbMultiplicar (OptionButton) Caption = “Multiplicar”
rdbSubtrair (OptionButton) Caption = “Subtrair”
rdbDividir (OptionButton) Caption = “Dividir”
BtnExecutar (CommandButton) Caption = “Executar Operação”
Tabela 2. Controles utilizados na aplicação e os valores de suasprincipais propriedades
Private Sub btnExecutar_Click()
 Dim resultado
 num1 = txtNum1
 num2 = txtNum2
 If rdbSomar Then
     resultado = CInt(num1) + CInt(num2)
 ElseIf rdbMultiplicar.Value Then
     resultado = num1 * num2
 ElseIf rdbDividir.Value Then
     resultado = num1 / num2
 Else
     resultado = num1 - num2
 End If
 MsgBox "Resultado: " & resultado
End Sub
Listagem 1. Comando executado no clique do botão btnExecutar

Utilização do Code Advisor

O Code Advisor possui várias opções de análise. Execute a análise com a opção padrão e teste as outras variações de funcionalidade da ferramenta. O Code Advisor pode ser executado sobre todo o projeto ou apenas sobre o arquivo ativo. Siga os passos abaixo:

  1. Revise o código-fonte do arquivo e certifique-se de que não haja comentários e que a aplicação esteja compilando corretamente. Isso é feito para que se possa notar claramente os comentários adicionados pelo analisador.
  2. Observe que, após a instalação do Code Advidor, foi criada uma nova barra de ferramentas no VB 6.0. A Figura 2 e a Figura 3 mostram as opções na barra de ferramentas e no menu Add-Ins, respectivamente.
Barra de ferramentas do Code Advisor criada após a instalação do Add-In
Figura 2. Barra de ferramentas do Code Advisor criada após a instalação do Add-In
Menu de opções do Code Advisor criado no item de menu Add-Ins
Figura 3. Menu de opções do Code Advisor criado no item de menu Add-Ins

Execute a opção Add FixIts a partir da barra de ferramentas ou do menu indicado na Figura 3. Uma barra de progresso é exibida durante a criação dos comentários e a geração do relatório. A Listagem 2 mostra o código com os comentários.

'FIXIT: Use Option Explicit to avoid implicitly creating variables of type Variant 

Private Sub btnExecutar_Click()
'FIXIT: Declare 'resultado' and 'num1' and 'num2' with an early-bound data type
	 Dim resultado, num1, num2
	 num1 = txtNum1
	 num2 = txtNum2
	 
	 If rdbSomar Then
	     resultado = CInt(num1) + CInt(num2)
	 ElseIf rdbMultiplicar.Value Then
	     resultado = num1 * num2
	 ElseIf rdbDividir.Value Then
	     resultado = num1 / num2
	 Else
	     resultado = num1 - num2
	 End If
 
 MsgBox "Resultado: " & resultado
End Sub   
Listagem 2. Código em VB 6.0 com comentários inseridos pelo Code Advisor
  1. Clique no botão Find Next FixIt para navegar até o primeiro comentário adicionado ao código. Continue clicando nesse botão para revisar o restante dos comentários adicionados. O primeiro comentário a ser encontrado dependerá da posição do cursor. A navegação é feita de baixo para cima, e o analisador já informa o que você deve fazer para corrigir o problema.
  2. Clique no botão View FixIt Report para visualizar o relatório HTML com um resumo dos elementos encontrados e das regras que foram aplicadas. O relatório é composto de quatro seções:
    • General - contém informações gerais sobre o relatório;
    • Issues – apresenta todos os problemas detectados pela ferramenta. Separa os problemas de arquitetura dos problemas menores;
    • Components – lista os componentes incluídos na aplicação;
    • Rules – lista as regras que foram aplicadas ao código-fonte para a geração do relatório.
  3. Feche o relatório e volte ao ambiente de desenvolvimento
  4. Pressione o botão Filter Fixit Rules para filtrar as regras a serem aplicadas. Com isso você terá uma janela com os conjuntos de regras, conforme mostra a Figura 4. O perfil padrão é o das regras do Visual Basic .NET 2002.
  5. Repita os passos 3 e 4 para o novo conjunto de regras selecionado. Observe algumas das regras selecionadas com o novo filtro. Por exemplo, observe a User Controls na lista de regras. Ela não aparece na lista do 2003 porque o Upgrade Wizard do 2003 é capaz de migrar User Controls, ao contrário do que ocorria na versão 2002. Faça uma análise com o conjunto de regras Best Practices.
Filtro de regras aplicadas pelo Code Advisor
Figura 4. Filtro de regras aplicadas pelo Code Advisor

Cabe ressaltar que é importante corrigir a maior quantidade possível de erros ainda no VB 6.0. Antes de usar o Upgrade Wizard, é preciso ajustar as mudanças informadas pelo Code Advisor e remover as práticas de programação não recomendadas, como, por exemplo, as propriedades padrão. Altere o código de acordo com a Listagem 3.

 Option Explicit
 Private Sub btnExecutar_Click()
    'Declaração explícita dos tipos das variáveis
     Dim resultado As Int, num1 As Int, num2 As Int
    'Converte valores para o tipo da variável que
    'receberá o valor e evita uso de propriedade
    'padrão
     num1 = CInt(txtNum1.Text)    
     num2 = CInt(txtNum2.Text) 
     
     If rdbSomar.Value Then
         resultado = num1 + num2
     ElseIf rdbMultiplicar.Value Then
         resultado = num1 * num2
     ElseIf rdbDividir.Value Then
         resultado = num1 / num2
     Else
         resultado = num1 - num2
     End If
     
     'Parênteses na chamada de Function ou Sub
     MsgBox ("Resultado: " & CStr(resultado))
 End Sub
Listagem 3. Código em VB 6.0 corrigido e com as boas práticas de programação

Usando o Upgrade Wizard para migrar o código VB 6.0 preparado

Uma vez feitas todas as alterações sugeridas pelo Code Advisor, vamos agora migrar nossa aplicação utilizando o Upgrade Wizard do Visual Studio.NET (instalado por padrão no VS.NET). Ele é executado automaticamente quando você tenta abrir um projeto do Visual Studio 6.0. Mas, antes de qualquer coisa, certifique-se que seu projeto esteja compilando e rodando sem erros no Visual Studio 6.0.

  1. Abra o Visual Studio .NET e selecione o menu File | Open | Project;
  2. Selecione o projeto do VS 6.0 na pasta onde você criou a aplicação;
  3. Selecione o arquivo Exemplo1.vbp e clique em Open. Será exibido o assistente de migração do Visual Studio .NET para o Visual Basic, mostrando a primeira tela (veja a Figura 5);
    Primeira tela do assistente de migração do VS.NET
    Figura 5. Primeira tela do assistente de migração do VS.NET
  4. Na tela 1 de 3, o VS.NET informa ao usuário que reconhece o projeto como sendo do VB 6.0. O Upgrade Wizard irá orientá-lo durante todo o processo de migração. Durante a atualização, o wizard também criará um novo projeto (que será equivalente ao projeto migrado), copiará novos arquivos de formulário, módulos e classes (convertendo-os para o novo formato) e, por fim, criará e anexará o relatório de migração ao projeto. Clique em Next para continuar;
  5. O wizard detecta automaticamente se o projeto é um executável ou uma DLL Microsoft ActiveX (veja a Figura 6). Clique em Next para continuar;
    Tela que informa qual tipo de projeto está sendo migrado
    Figura 6. Tela que informa qual tipo de projeto está sendo migrado
  6. Defina o local onde o projeto do VB.NET será criado. Por padrão, o novo projeto é criado em um subdiretório sob o caminho atual do projeto a ser migrado. Aparecerá uma mensagem que solicita a confirmação para a criação da nova pasta. Se a pasta já existir, o assistente informará que o conteúdo da pasta será apagado (veja a Figura 7). Clique em Next para continuar;
    Tela que mostra onde será criado o novo projeto VB.NET
    Figura 7. Tela que mostra onde será criado o novo projeto VB.NET
  7. O projeto está agora pronto para migração (veja a Figura 8). O tempo necessário para a atualização varia em função de diferentes fatores, tais como tamanho, características e configuração do equipamento. Clique em Next para iniciar a migração.
    Tela que informa que o assistente está pronto para migrar o projeto
    Figura 8. Tela que informa que o assistente está pronto para migrar o projeto

Uma vez concluída a migração, a janela do Solution Explorer exibirá os arquivos do novo projeto. Entre eles, você verá o _UpgradeReport.html, um relatório que mostra ao usuário os detalhes da migração e o informa dos erros ocorridos durante o processo.

Conclusões

Nesta primeira parte, apresentei uma introdução sobre os motivos que levaram a Microsoft a fazer mudanças tão radicais no Visual Basic e disponibilizei uma pequena lista com algumas das novidades do Visual Basic .NET. Em seguida, fiz algumas observações importantes, que deverão ser levadas em conta antes da migração. Construí uma simples calculadora no VB 6.0 para mostrar a importância do Code Advisor no processo de migração. Este exemplo mostrou como o analisador poderá ajudá-lo. Como você pode ver, é importante fazer o maior número possível de correções ainda no VB 6.0. Após corrigir os pontos de atenção no VB 6.0, abri o projeto no Visual Studio.NET para que este fosse migrado automaticamente pelo Upgrade Wizard.

Na segunda parte deste treinamento, mostrarei como migrar aplicações que utilizam DAO e controles ActiveX.