Migrando Aplicações VB 6.0 para VB.NET - Parte I - Introdução e o Ciclo de Migração

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.

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:

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
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:

É 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”.

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.
Figura 2. Barra de ferramentas do Code Advisor criada após a instalação do Add-In
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.
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);
    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;
    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;
    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.
    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.

Artigos relacionados