VB.NET - Compilação Condicional

Você pode usar as diretivas de compilação para selecionar trechos particulares de código que serão executados enquanto outros trechos serão ignorados pelo compilador.

por José Carlos Macoratti

Quando você compila o seu projeto VB.NET esta realizando um processo de tradução do código que você escreveu (com a ajuda do VB) para uma linguagem que seu computador possa entender. No caso do VB.NET o código é traduzido para o MSIL - Microsoft Intermediate Language. O Compilador JIT - Just-in-Time é que realiza a compilação para o código de máquina. Até o momento a compilação gera código para ser executado na plataforma Windows , mas existem propostas de projetos para poder executar um código da plataforma .NET no Linux. Veja em : www.go-mono.com ou www.dotgnu.com.

Todo executável gerado na plataforma .NET são arquivos .EXE ou .DLL no formato PE que são também chamados de assemblies e contém o código MSIL , informações dos tipos em arquivos metadados e arquivos manifest.

Lembrando que todo programa compilado pelo VB.NET possui código gerenciado , ou seja, o compilador JIT pode verificar em tempo de execução se o código que esta em execução compromete a segurança do sistema.

Para espiar o conteúdo de um arquivo .EXE gerado pelo VB.NET você pode usar a ferramenta ILDASM.EXE.

Você pode também decompilar um executável gerado pelo VB.NET facilmente. (Não se apavore pois existe formas de contornar este comportamento...)

Estou dando estes detalhes mas o foco do nosso assunto hoje são os recursos que o compilador do Visual Basic oferece para ajudá-lo no desenvolvimento de suas aplicações permitindo uma certa flexibilidade na hora de gerar o seu código executável.

Estou falando mais especificamente das diretivas de compilação que podem ser usadas para efetuar uma compilação condicional permitindo que você gere versões com comportamento diferente para sua aplicação.

Você pode usar as diretivas de compilação para selecionar trechos particulares de código que serão executados enquanto outros trechos serão ignorados pelo compilador. Pode também alterar valores definidos de alguns elementos do seu programa. Pode gerar versões de demonstração.

Quando você usa as diretivas de compilação o VB verifica se ela esta definida e obedece as regras que você impôs pelo uso da diretiva , visto que as diretivas são avaliadas antes da compilação do seu código.

Você pode então , através das diretivas de compilação controlar, o código que será compilado.

As constantes pré-definidas que você pode usar como diretivas de compilação para executar a compilação condicional são:

Define uma constante em um pré-processamento

Uma string que representa a configuração atual da janela de configuração da Solução ativa no gerenciador de configuração(Configuration Manager)

Um valor boleano que pode ser definido na caixa de diálogo Propriedades do Projeto - Project Properties. O padrão da configuração debug para o projeto define DEBUG. Quando DEBUG é definida, os métodos da classe System.Diagnostics.DebugClass geram a saída para a janela de saída (output window). Quando ela não for definida nenhuma saída de debug é gerada

Uma string representando o tipo de saída para o projeto ou a configuração da opção da linha de comando /target. Os valores possíveis para TARGET são : "winexe" - para aplicações windows "exe" - para aplicações do tipo console "library" - para módulo de classe "module" - para modulo A opção /target pode ser definida no ambiente de desenvolvimento integrado do VS.NET.

Um valor boleano que pode ser definido na janela de diálogo Project Properties. Por padrão todas as configurações para um projeto definem TRACE. Quando TRACE esta definido os métodos da classe System.Diagnostics.Trace geram a saída para a output window. Caso contrário não haverá saída de trace.

Estrutura usada para verificar as constantes/elementos em um pré-processamento.

A sintaxe da constante de compilação é a seguinte :

#Const nome = expressão

onde : nome ; é o nome da variável de memória que será usada na pré-compilação

expressão : Um valor atribuído a variável e pode ser literal , numérico, operadores lógicos e aritméticos.

A sintaxe da estrutura #IF/ #ELSE / #ELSEIF # END IF é a seguinte:

#If Expressão Then
[bloco de código]
[#ElseIf Condição-n Then
[bloco de código]]
[#Else
[bloco de código]]
#End If

Onde :

- Expressão - é qualquer expressão contendo uma ou mais constantes de compilação.

- Bloco de código - Linhas de código VB ou diretivas de compilação
- Condição-n - Uma condição lógica que vaii ser avaliada pelo VB.

o funcionamento do #If / #ElseIf / #Else / # End If é similar a estrutura if/elseIf/Else/End If

Vamos mostrar como usar esta teoria.

Crie um novo projeto do tipo WIndows Application usando a linguagem VB.NET e chame o projeto de testeCompila; no formulário padrão inclua os controles : TextBox e Button conforme layout abaixo.

No evento Click do botão de comando insira o seguinte código :

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click "define um novo file stream Dim fs As FileStream fs = New FileStream(txtarquivo.Text, FileMode.CreateNew) "cria um streamwriter que usa o file stream Dim w As StreamWriter w = New StreamWriter(fs) "escreve dados no arquivo w.WriteLine(txtTexto.Text) w.WriteLine(2005) w.Close() End Sub

Este super programa cria um arquivo texto usando o nome informado na caixa de texto txtArquivo e grava os dados informados na caixa de texto txtTexto.

Se você executar o código como esta escrito acima o arquivo texto mac.txt será criado na pasta d:\teste.

Vamos incluir neste código uma diretiva de compilação, pois, ao distribuir este super programa não queremos permitir que o usuário gere o arquivo texto, ao invés disto, vamos exibir a mensagem : "Você esta usando uma versão de demonstração"

Para isto eu vou usar uma constante de compilação chamada DEMO.

Aconstante de compilação DEMO foi definida como True na seção DECLARATIONS do formulário.Sua declaração é exibida a seguir:

#Const DEMO = True

O código que usa a diretiva de compilação é o seguinte:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click #If DEMO Then MsgBox("Você esta usando uma versão de demonstração.") #Else Dim fs As FileStream fs = New FileStream(txtarquivo.Text, FileMode.CreateNew) "cria um streamwriter que usa o file stream Dim w As StreamWriter w = New StreamWriter(fs) "escreve dados no arquivo w.WriteLine(txtTexto.Text) w.WriteLine(2005) w.Close() #End If

Ao executar o código do projeto e clicar no botão para criar o arquivo texto o usuário irá obter o seguinte resultado:

Existe uma limitação importante na definição de uma constante de compilação : Ela não pode ser pública.

Vejamos outra possibilidade:

No código abaixo estou usando a constante TARGET para determinar o modo de compilação:

#if TARGET = "winexe" then

"codigo para compilar uma aplicação Windows

#Elseif TARGET = "exe" then

"codigo para compilar uma aplicação do tipo Console

#End If

Neste outro exemplo , estamos usando a constante DEBUG para evitar o acesso aos dados:

#if DEBUG then

Debug.WriteLine(" aplicação Demo");

#Else

AcessoBD()

#End If

Como não é possível definir uma constante de compilação que seja válida para todos os módulos de código e formulários eu vou ter que declarar constantes para cada formulário para os quais eu desejar usar a compilação condicional. Nada prático , não é mesmo !!!

Mas podemos contornar este problema definindo o valor da constante de compilação via linha de comando no momento da compilação da aplicação.

Você define um mesmo nome para a constante de compilação em todas a partes onde deseja usar a compilação condicional e não define o valor da constante em cada trecho.

Usando o nosso exemplo acima remova a declaração da constante DEMO (#Const DEMO = True) do código, e a seguir abra a página de propriedades do projeto clicando com botão direito do mouse sobre o nome do projeto e selecionando a opção Properties.

Na janela Property Pages selecione a pasta Configuration Properties e a seguir a opção Build.

Finalmente informe o nome da constante e o seu valor (DEMO=True) na caixa de texto Custom constants:

Se houver a necessidade de informar mais de uma constante podemos fazer isto separando as constantes com vírgulas:

DEMO=True,Teste=1

Após isto podemos executar o aplicativo que terá o mesmo comportamento como se a constante tivesse sido definida no código.

Eu reconheço que é um recurso limitado mas é nativo do VB e você pode usar a sua criatividade para driblar algumas limitações que serão evidenciadas quando você pretender usar pra valer este recurso. Mas dá para fazer uma versão demo do seu programa brincando...

Eu sei , é apenas VB , but I like it !!!