326ap Vbasic

Microsoft Visual Basic 4.
0 1
Módulo 1
Criando Aplicações
Visual Basic
1.1 Programação Procedural Versus Programação

Orientada a Eventos
Na programação procedural, ou seja, baseada nas chamadas de

procedimentos/rotinas, a aplicação em si inicia na primeira linha do código e
segue um fluxo determinado pelo próprio programa, durante a sua execução.
Devido a essa característica, o usuário se vê amarrado à forma de
trabalho da aplicação.
Na programação orientada a eventos, as ações do usuário
(comumente denominadas eventos) determinam o fluxo de execução do
programa, ou seja, qual procedimentos/rotina será chamada.
Isso significa que um programa desenvolvido com base nessa técnica,

as chamadas das rotinas dependem dos eventos que ocorrem, em outras
palavras, dependem do que o usuário fará ou não.
Portanto, com base nisso, podemos definir um evento como sendo

uma ação reconhecida por um controle, que nada mais é que um objeto
adicionado ao formulário. Os diversos controles do Visual Basic (campos de
entrada, lista de opções, caixas de seleção, etc.) reconhecem e respondem a
um conjunto predefinido de eventos.
Microsoft Visual Basic 4.0 2
Para que um controle responda a um evento de

uma forma particular, você deverá escrever um
procedimento na linguagem Visual Basic e atribuir
esse código ao evento desejado.
Por exemplo, você pode escrever uma rotina para avançar para o
próximo registro de uma tabela de dados assim que o botão identificado pela
legenda Avança de um formulário for pressionado. Você então atribui o nome
dessa rotina ao evento Click do botão. Assim, toda vez que o botão for
pressionado através de um clique do mouse, a rotina será chamada. Após o
término de sua execução, haverá o retorno automático ao formulário.
Podemos perceber então que o primeiro passo no desenvolvimento de

uma aplicação no Visual Basic consiste na criação dos formulários, aplicando-
lhes os controles (botões de ação, menus, caixas de listagem, caixas de
combinação, etc.).
Após isso passamos ao desenvolvimento das rotinas que serão
vinculadas aos controles do formulário.
Note que essa técnica difere do processo antigo, em que primeiro o

programador definia o que seria feito pelo programa (desenvolvia as rotinas),
para depois pensar na interface com o usuário. Agora o mesmo programador
sentir-se-á mais livre da árdua tarefa de elaboração dessa interface, já que o
Visual Basic executa a maior parte do processo, tendo assim mais tempo para
se concentrar nas rotinas principais do programa. Isso torna a tarefa de
desenvolvimento de aplicações mais produtiva.
Do lado do usuário, um programa orientado a eventos é mais fácil de

assimilar e utilizar, pois ele reflete a maneira como uma pessoa trabalharia no
mundo real. Não há necessidade de se adaptar ao aplicativo.
1.2 Criando um programa Visual Basic
Prática :
Adicionar no formulário :
1 command : Propriedade Caption = &OK

1 Label : Propriedade Caption = Nome
1 Textbox : Limpar Propriedade Text
1 Label : Propriedade Caption = Endereço
1 Textbox : Limpar Propriedade Text
Nomeá-los :Na janela de propriedades colocar no campo Name o

nome com o prefixo indicativo do tipo de objeto.
Exemplos:
Objetos Prefixo Exemplo

form frm frm_cliente
check box chk chkapenasleitura
combo box cbo cboidioma
image img imgicon
label lbl lblnome
menu mnu mnufileopen
text box txt txtnome
Dica: Para chamar o Help clique no ícone e tecle F1
1.3 Algumas Propriedades
Podemos defini-las em tempo de projeto ou em tempo de execução:
· Tempo de Projeto : No objeto lblnome - clique sobre o objeto uma vez.

Propriedade caption : vai para janela de propriedades.
Resultado : &NOME Þ NOME
( Tecla de Atalho ALT+N )
· Tempo de Execução : No objeto txtnome - dê um double clique no objeto.

No evento txtnome_click( ) - colocar :
txtnome.text = “BOCA” ou lblnome.caption =
txtnome.text
Sempre: <nome objeto.propriedade> = <valor>.

Executar Þ Clicar sobre o Label Nome.
No objeto Form colocar :

Caption exemplo
Name frmexemplo
Backcolor ( escolher )
Fillstyle ( escolher )
Uma proprieddade de um objeto1, pode ser alterada

em tempo de execução por outro objeto2
1.4 Métodos
Os métodos determinam a realização de uma ação para um

determinado objeto. Essa ação quem define é o programador.
Exemplos :
txtnome.setfocus { posiciona o ‘foco’ para a caixa de texto do

objeto txtnome}.
lblcodigo.move 0,0 { posiciona o objeto lblcodigo para as

coordenadas 0,0}.
txtfrase.textwidth { retorna o tamanho da string do objeto

txtfrase}.
frmcliente.hide { esconde, mais permanece na memória

principal, o objeto frmcliente}.
1.5 Eventos
É uma ação reconhecida por um formulário ou por um controle, o agente

da ação pode ser : o usuário ou o código.
Exemplos :
click
dblclick
keypress
load
gotfocus
lostfocus
1.6 Formulários e Controles Básicos
Formulários
O usuário interage com os controles no formulário para obter resultados
Algumas Propriedades para Formulários
backcolor Þ cor do fundo

borderstyle Þ estilo da moeda
caption Þ cabeçalho
name Þ nome do objeto
Alguns Métodos para Formulários
hide Þ esconde
nome Þ movimenta o formulário
print Þ imprime
setfocus Þ ativa o formulário
show Þ mostra na tela o formulário ( semelhante
chamada de rotina ).
Alguns Eventos para Formulários
click Þ 1 click
dblclick Þ 2 clicks
gotfocus Þ quando ele ganha o foco
load Þ carrega
mousedown Þ 1 click para baixo
mouseup Þ 1 click para cima ( larga o botão )
unload Þ descarrega
Obs. : Para obter mais informações, clique no formulário e tecle <F1>.
Controle Label
Mostra uma informação estática ( um rótulo).
Exemplo : Fornecer instruções ao usuário.
Nome
label textbox
Algumas Propriedades
caption Þ rótulo
font Þ tipo de letra
autosize Þ tamanho automático
appearance Þ aparência (2D,3D)
Alguns Eventos (mais usados)
click
dblclick
Controle Textbox
Usado para obter informação do usuário.
Obs. : Você pode utilizar o textbox em conjunto com o controle

data, para exibir informações de um Banco de Dados
multiline Þ mais de uma linha

passwordchar Þ senha ( **** )
Alguns Métodos
move Þ move o objeto

setfocus Þ deixa o objeto ativo
Alguns Eventos
change Þ qualquer alteração no campo

click Þ evento clique
gotfocus Þ evento ganho de foco
Controle Commandbutton
É utilizado para invocar uma ação. A maioria dos formulários possuem
os controles OK e CANCEL
visible Þ visível ou não

default Þ irá indicar que o botão é o que irá ficar ativo
inicialmente quando o formulário for lido. ( note
que deverá existir apenas um controle de
comando default por formulário.
Controle Combobox
Permite que você selecione uma opção existente em uma lista pre-
determinada, digitando-os em uma caixa de texto associada a esta lista
Data
Permite acessar dados armazenados em um arquivo de Banco de
Dados.
editmode
readonly
top
database
Menu
Permite a criação de menus personalizados para a sua aplicação,
deixando-a com uma aparência mais profissional.
appearance
name
caption
index
Evento ( único )
click
Ole Container
Insere no formulário outros aplicativos ( som, .doc, planilha excel, etc).
Picture Box
O controle picture box é utilizado para exibir imagens de arquivos
bitmap, icon e metafile.
Timer
Permite a você executar certas partes de seu código a intervalos de
tempo. ( Background )
Exemplo : A cada ‘ t ‘ segundos você pode verificar se foi realizada a

inclusão de um nome ou você pode inserir a hora atual.
File List Box
Apresenta uma caixa de listagem de itens. Seu ícone no toolbox

corresponde à figura de uma folha com a ponta direita superior dobrada.
Adiante faremos um exercício para melhor entendermos esse controle.
Prática 1
O Objetivo desta prática é fazer com que o aluno se familiarize com o

ambiente e obtenha conceito básicos dos objetos do Visual Basic.
Vamos simular um pequeno editor de texto para que você entenda como
o controle Timer vai realizando tarefas em segundo plano (background).
Dentro do seu aplicativo. Inclua no formulário :
1 textbox propriedades Þ multiline = true

name = txtedit
scrollbar = 2-vertical
text = <apaga>
1 timer propriedadesÞ interval = 1000(ms),

name = timer
1 label propriedades Þ caption = <apagar>

name = lbltime
Na seção General (geral) inclua o seguinte código:
Public tempo as date
No procedimento sub form_load() inclua:
tempo = now
No procedimento timer_timer inclua:
lbltime.caption = format(now-tempo, “long time”)

Execute sua aplicação.
Prática 2
Para vermos como o controle FileListBox funciona, vamos fazer o

seguinte:
Crie um objeto FileListBox em um novo formulário e dê a ele o Nome =

File1 (Já é o nome default dele!).
Depois insira o seguinte código no evento click do formulário:
Private Sub Form_Click ()
Dim nome As String, I As Integer, Msg As String ' Declarando variaveis.
File1.Pattern = "Arquivo.*" ' Setando a forma geral do nome do arquivo
For I = 1 To 8 ' oito vezes.

nome = "Arquivo." & I
Open nome For Output As FreeFile ' cria um arquivo vazio.
File1.Refresh ' abre e atualiza o file list box.
Close ' fecha ao arquivo.
Next I
Msg = "Tecle OK para remover os arquivos criados."

MsgBox Msg ' mostra mensagem.
Kill "Arquivo.*" ' Remove os arquivos de teste.
File1.Refresh ' atualiza o filelistbox.
End Sub
Agora execute a aplicação.
Prática 3
· Crie um formulário (form) {nomeie, escolha um caption}
· Insira um textbox e um label {nomear, limpar textos}

· No evento form_mousemove inclua o seguinte código:
Fillcolor = qbcolor (int (rnd * 15)) ‘ sortea-se uma cor para o fundo da
‘circunferência
Fillstyle = int(rnd * 8) ‘ sortea-se um grid para a circunf.
Circle (x,y), 250 ‘ desenha um círculo
No evento Textbox_change() inclua:
Label_caption = textbox.text ‘o que for escrito no textbox sairá no

caption ‘ do label
Prática 4
· Crie um form {nome:login}
· Desenhe o seguinte layout
Forneça seu nome e sua senha para logar:
Nome OK Command Þ cmd Ok

cmd
Cancela
Senha Cancelar
Label Textbox Þ txtnome

txtsenha
Obs .: Nomear todos os objetos

Limpar textos dos texbox’s
Inserir Código :
cmdcancela_click()
msgbox “Esse botão cancela a aplicação”
end
cmdok_click()
msgbox “Nome do usuário = “ & txtnome.text & “, senha = “& txtsenha.text
txtsenha_change()
If txtnome.text<> “ ” and txtsenha.text<> “ “
then cmdok.enable = true
endif
txtnome_change()
If txtnome.text <> “ “ and txtsenha.text <> “ “
then cmdok.enable= true
endif
Prática 5
Vamos fazer um programa em Visual Basic que calcule o número de

dias (aproximado) vividos pelo usuário após ele ter fornecido a idade.
Adicione a um formulário (abra um novo projeto) 4 label’s, 2 textbox’s e 2

command’s, conforme a figura abaixo :
Form1
Label1 Text1
Label2 Text2
Comand1 Comand2
Label3
Label4
A seguir ajuste as propriedades conforme a tabela a seguir :
Objeto Propriedade Valor

Label1 Autosize TRUE
Caption Entre com seu nome :
Name lblNome
Caption Entre com sua idade :
Name lblidade
Caption (nenhum)
Name lblNomeResposta
Caption (nenhum)
Name lblidadeResposta
text1 Name txtNome
Text (nenhum)
text2 Name txtIdade
Text (nenhum
Command1 Caption &OK
Name btnOK
Default TRUE
Command2 Caption &Cancela
Name btnCancela
Form1 Caption Dias vividos

Name Idade
Obs : A propriedade “default” do objeto command1 está setada em

“TRUE” para que inicialmente, quando o usuário teclar ENTER, acione o
botão OK.
A seguir inserir o código
btnOK_click()
DIM idade as integer, dias as long

idade = val(txtidade.text)
dias = idade * 365
lblNomeResposta.caption = txtnome.text
lblidadeResposta.caption = “Você viveu até hoje aproximadamente “
&dias& “dias.”
btnCancela_click()
end
Para executar :
1. 4
2. Criando um .EXE
· Selecione opção Make EXE File do menu File.
· Escolha Options.
· No quadro Version Number podemos entrar com o número da versão

do programa.
· No quadro application podemos informar o nome do programa ou um

ícone.
· No quadro version information podemos comentar o programa.
Clique OK duas vezes depois execute o programa através da pasta onde foi
gerado o executável.
1.7 Criando Rotinas para Validação de Dados
Como fazer para inibir a entrada de dados numéricos em um textbox

alfabético e/ou a entrada de dados alfabéticos em um textbox numérico ?
Faça o seguinte, crie um novo formulário com apenas um objeto (um

textbox) e no procedimento Keypress (para achá-lo clique sobre a seta da
caixa de combinação denominada Proc) do objeto textbox e insira o código:
If keyascii >= asc(“0”) and keyascii <= asc(“9”) then keyascii = 0
Isso irá inibir a entrada de dados numéricos.
Asc(X) - retorna a ordem de X na tabela ascii, então, se o caractere

teclado estiver entre 0 e 9 o campo é realimentado.
Para inibir entrada alfabética, insira o código a seguir em

txtidade_keypress() :
If keyascii < asc(“0”) or keyascii > asc(“9”) then keyascii = 0
Para convertermos caracteres alfabéticos, por exemplo nomes de

pessoas, para maiúsculos fazemos:
Private Sub Text1_KeyPress(KeyAscii As Integer)
If KeyAscii >= Asc("0") And KeyAscii <= Asc("9") Then
KeyAscii = 0
ElseIf KeyAscii >= Asc("a") And KeyAscii <= Asc("z") Then
KeyAscii = KeyAscii - 32
End If
Módulo 2
Trabalhando com
Formulários
Cada formulário na sua aplicação é gravado com a extensão .FRM e

contém:
· As instâncias das propriedades do formulário e do controle.
· Declaração das variáveis ao nível de formulário.

Procedimentos e módulo “General”. {O código situado neste módulo pode

ser “visto” por todos os procedimentos do formulário}
2.1 Configurando o Ambiente de Trabalho

Menu Tools/Options
Ambiente (Environment)
Grid do formulário(Form design grid) : determina o espaçamento do grid

do formulário.
Janelas superiores(Windows on top) : Determina quais janelas sempre

serão mostradas durante o projeto.
Exige declarações de variáveis(Require variable declaration) :

Determina a obrigatoriedade de declaração de variáveis (cuidado !!!)
Checagem automática de sintaxe (Auto sintaxe check) : quando

permitida fornece correção ao código durante implementação.
Project
Startup form : Indica qual formulário deverá ser executado incialmente.
É comum o programador ter mais de um formulário

em umaplicativo e com isso se esquecer de setar o início da
execução para o formulário inicial. Vamos prestar atenção.
Editor
Fonte(Font) : Determina a fonte usada nos códigos.

Tamanho(Size) : Determina o tamanho da fonte usada nos códigos.
Cor do código(code color) : determina a cor do código.
2.2 Interagindo com o Usuário
2.2.1 Função MSGBOX
Mostra informações ou questionamento ao usuário.
Sintaxe :
MSGBOX (Mensagem, [botão],[Título do Botão])
Mensagem - Informação enviada ao usuário.
Botão - Tipo de caixa de diálogo + tipo de ícone.
Valor Tipo de Ícone

16 Ä
32 ?
48 !
64 i
Valor Tipo de Caixa

0 OK
1 OK, Cancela
2 Aborta, Retorna, Ignora
3 Sim, Não Cancela
4 Sim e Não
5 Retorna e cancela
Valor Botão Default Ativo

0 1° Botão
256 2° Botão
512 3° Botão
A função MSGBOX irá retornar um valor baseado no tipo de caixa

escolhida.
Botão Valor(constantes)
OK vbok(1)
Cancela vbcancel(2)
Aborta vbabort(3)
Retorna vbretry(4)
Ignore vbignore(5)
Yes vbyes(6)
No vbno(7)
Exemplo :
Inserir o seguinte código em um objeto cmdaqui com caption = clique

aqui.
Clique Aqui
No evento click do objeto cmdaqui insira o código
Private Sub cmdaqui_Click()
Dim Resposta As Integer
Resposta = MsgBox("quer continuar?", 4 + 48 + 256, "mensagem")
If Resposta = vbYes Then MsgBox "Escolheu SIM", 0 + 48 + 0, "Resultado"

Else MsgBox "Escolheu NÃO", 0 + 48 + 0, "Resultado"
End Sub
2.2.2 Caixa de Entrada (INPUTBOX Function)
Esta função fornece um meio fácil de obter informações do usuário. É

semelhante ao controle textbox, difere na emissão de uma caixa de diálogo.
Sintaxe : INPUTBOX (Mensagem, Título da caixa, Mensagem Default)
Exemplos:
· Crie um objeto command (cmd)
· No evento Dbclick insira o código
Private Sub Form_DblClick()
Dim arquivo As String
arquivo = InputBox("Entre com o nome do arquivo", "Abrir Arquivo",

"C:\")
MsgBox "Arquivo " & arquivo & " aberto ! "
End Sub
Dica : Para mais informações, veja “INPUTBOX” no Help
2.3 Gerenciando Formulários
Na maioria dos aplicativos a interface com o usuáro é composta por

mais de um formulário.
O formulário “STARTUP” é mostrado automáticamente quando a
aplicação VB é inicializada.
Ação Método ou Função

Lê um formuláro na memória mas não LOAD
mostra na tela
Lê e mostra um formulário SHOW
Mostra um formulário já lido SHOW
Esconde um formulário mostrado na tela HIDE
Esconde e tira da memória um UNLOAD
formulário
Exemplo :
Frmform1.show Frmform1.hide
Load Frmform1 Unload Frmform1
Formulário Modal ou Não-Modal
Um formulário Modal não permite que o usuário interaja com outros

formulários da aplicação ao mesmo tempo (como o “Save File as”)
Um formulário Não-Modal permite que o usuário escolha entre os

formulários.
O método Show seta um formulário como modal ou não modal.
Exemplo:
Frmform1.show vbmodeless ‘ não modal

Frmform1.show vbmodal ‘ modal
Terminando uma aplicação
END faz um Unload em todos os formulários e termina a aplicação.
Prática 6
Faça um aplicativo que calcule raízes de um polinômio de grau dois. O

polinômio é da forma :
AX2 + BX + C = 0
Relembrando :
A,B coeficientes da equação

C termo independente
Resolver uma equação do 2° grau é encontrar o valor ou os valores

que se colocados no lugar da variável X, tornam a sentença verdadeira.
A fórmula para encontra as raízes (X1,X2) é a seguinte:
X = - B ± SQR( delta) , Delta = B^2 - 4AC

2A
Os resultados deverão ser fornecidos por outro formulário.
Você deverá fazer esta prática sozinho!
Mesmo sem conseguir você estará assimilando

com maior ênfase as características da programação
orientada a evento e os “macetes” do ambiente Visual Basic.
Deixe para olhar a resolução depois que você “eventualmente” se
perdeu!
Resolução:
Passos :
Crie um formulário com as seguintes propriedades :
Name - Frmmain
Caption - Equação do 2° grau
Objetos :
Label
1 - Name lblDados
Caption Dados da Equação
2 - Name lblA
Caption Coeficientes A=
3 - Name lblB
Caption B=
4 - Name lblC
Caption Termo independente C=
Command
1 - Name cmdcalcular
Caption &Calcular
Default TRUE
2 - Name cmdsair
Caption &Sair
Textbox
1 - Name TXTA
Text <vazio>
Maxlength 5
2 - Name TXTB
Text <vazio>
Maxlength 5
3 - Name TXTC
Text <vazio>
Maxlength 5
Código
CmdCalcular_click()
DIM Raiz1 as double, Raiz2 as double , delta as double, A as double, B

as double, C as double
A = VAL (txta.text)
B = VAL (txtb.text)
C = VAL (txtc.text)
Delta = (B*B) - 4*A*C
If Delta>0 then
Raiz1 = (-(-b) + SQR(delta))/(2*A)
Raiz2 = (-(-b) - SQR(delta))/(2*A)
FrmResultado.txtx1.text = Raiz1
FrmMain.Hide
FrmResultado.Show
Elseif Delta = 0 then
Raiz1 = (-(b) + SQR(delta))/(2*A)
FrmMain.Hide
FrmResultado.Show
Else
Msgbox ‘Não existem raízes reais !!!”
Endif
EndSub
CmdSair_click()
End
EndSub
A seguir crie outro formulário com as seguintes caracteristicas:
Name FrmResultado
Caption Resultado
Label
1 - Name lblX1
Caption X1 =
2 - Name lblX2
Caption X2 =
Command
1 - Name Cmdvoltar
Caption &Voltar
Default TRUE
Textbox
1 - Name txtx1
text <vazio>
2 - Name txtx2
text <vazio>
Depois insira o código seguinte no evento click do objeto cmdvoltar
FrmMain.txta.text = “ “
FrmMain.txtb.text = “ “
FrmMain.txtc.text = “ “
Frmresultado.Hide
FrmMain.Show
Execute a aplicação !!!

Módulo 3
Aspectos de Programação
Visual Basic
3.1 Atribuindo Valores
[LET] nome_da_palavra = <valor>
3.3 Variáveis
O que são variáveis ?
Toda linguagem de programação precisa de algum lugar para

armazenar o resultado de seus cálculos ou simplesmente para controlar o fluxo
do programa.
Assim como acontece na álgebra cotidiana, as linguagens de
programação se valem de variáveis para armazenar dados na memória do
computador.
Uma variável de memória nada mais é do que uma posição da memória
do computador reservada exclusivamente para que sejam guardadas
informações e dados. A essa posição de memória damos um nome para
referência dentro do nosso programa, como por exemplo, NomeCliente.
Quem controla qual posição de memória do computador será reservada
é a própria linguagem e o sistema operacional, ou seja, devemos apenas nos
preocupar em nomear e declarar as variáveis.
E já que estamos falando de variáveis, quando formos nomeá-las,

deveremos seguir algumas regras básicas:
Þ O nome precisa iniciar com uma letra.
Þ Somente são permitidas letras, números e o caractere de sublinhado.

Qualquer sinal de pontuação e espaço em branco será inválido.
Þ No Visual Basic 4.0, os nomes podem ter até 255 caracteres de comprimento.
Isso significa que podemos ter nomes de variáveis bem descritivos, como
por exemplo, PrimeiroNomedoCliente.
Þ Não podem coincidir com uma palavra reservada do Visual Basic, como
nomes de funções ou procedimentos.
Þ Precisam ser únicos dentro do escopo atual, ou seja, não podemos ter duas
variáveis com o mesmo nome dentro de uma rotina, porém, entre rotinas
diferentes, isso é perfeitamente possível.
Escolha nomes sugestivos para as variáveis, de tal forma que

descrevam sua função ou conteúdo que será armazenado nelas.
Por exemplo para uma variável onde seria armazenado o resultado do
cálculo do salário de um funcionário, poderíamos escrever nSalarioFunc, em
vez de X, Y ou Z.
3.4 Declaração de Variáveis
Dim Nomedavariavel [ as tipo de dados]
3.5 Tipos de Dados
Como toda linguagem de programação, o Visual Basic também possui

vários tipos de dados aplicáveis às varáveis, que definem quais os valores
que essas poderão armazenar.
O Visual Basic 4.0 define 11 tipos de dados básicos, cada qual com
suas características peculiares, como largura da faixa de dados, tamanho em
bytes, etc.
A tabela a seguir relaciona todos esses tipos:
Tipo de Tamanho em Bytes Faixa de Valores

Dado
Integer 2 Bytes - 32.768 a 32.767
Long 4 Bytes - 2.147.483.648 a 2.147.483.647
Single 4 Bytes - 3,402823E38 a - 1,401298E-45 (Val.
Negativos)
1,401298E-45 a 3,402823E38 (Val.
Positivos)
Double 8 Bytes -1,79769313486232E308 a
-4,9406564584124E-324
(Val. Negativos)
4,9406564584124E-324 a
1,79769313486232E308
(Val. Positivos)
Currency 8 Bytes - 922.337.203.685.477,5808 a
922.337.203.685.477,5807
String 1 Byte por caractere De zero a 65.500 caracteres
Em sistemas de 32 bits,máximo de 2E32
caracteres.
Byte 1 Byte 0 a 255
Boolean 2 Bytes True (verdadeiro) ou False (falso)
Date 4 Bytes Qualquer referência a objeto
Variant 16 bytes + 1 byte para Qualquer valor numérico, caractere, objeto ou
cada caractere valor nulo.
Os tipos de dados determinam o que você pode armazenar numa

variável.
Por exemplo, você não pode entrar com uma expressão caractere numa
variável do tipo numérico, nem tampouco digitar um número numa variável
lógica.
Vejamos os detalhes dos tipos de dados mais comumente utilizados.
Tipos lnteger e Long
Esses dois tipos de dados permitem o armazenamento de valores

numéricos inteiros, com os quais podemos efetuar cálculos e operações
matemáticas.
A faixa de valores permitida para o tipo lnteger vai de -32.768 a 32.767,
sendo portanto limitada para alguns tipos de operações. Variáveis desse tipo
são muito úteis como contadores de loops For... Next, por serem de
manipulação muito rápida pelo processador, pois necessitam de poucas
instruções de máquina.
O tipo Long, por outro lado, abrange uma faixa muito maior de valores, da
ordem de 2 milhões, conforme pode ser constatado pela tabela anterior.
Tipos Single e Double
Single e Double também são tipos de dados numéricos, porém permitem

a manipulação de valores decimais, como pesos, unidades de medidas, etc.
Como os tipos anteriores, podemos efetuar qualquer operação matemática com

eles.
O que diferencia o tipo Single do tipo Double é a precisão nas casas
decimais e a faixa de valores abrangida por cada um. Veja a tabela anterior
para comparação. Variáveis do tipo Single são ditas de precisão simples,
comumente chamadas apenas de variáveis de ponto-flutuante. Variáveis do tipo
Double são denominadas variáveis de dupla precisão.
Tipo Currency
O Visual Basic possui um tipo de dado especial para tratamento de

valores monetários, evitando-se assim erros de arredondamento durante
cálculos matemáticos. Esse tipo de dado é chamado de Currency. Devemos
utilizá-lo apenas para armazenamento de valores monetários.
Se num determinado cálculo, o valor resultante tiver mais de quatro
casas decimais, as casas decimais extras (a partir da quinta casa) serão
truncadas. Assim, o número 5402,105782 será armazenado como 5402,1057
numa variável do tipo Currency.
Tipo String
O tipo de dado string é certamente o mais utilizado. Ele possibilita que

uma sequência de caracteres seja armazenada numa variável.
Essa sequência de caracteres pode conter desde letras do alfabeto até
símbolos gráficos e números, muito embora não possamos efetuar cálculos com
os números armazenados numa sequência. Devemos envolver a cadeia de
caracteres com aspas (").
Com variáveis do tipo caractere, é possível efetuarmos algumas
operações de comparação, concatenação (junção) de duas ou mais seqüências
de caracteres ou extração de uma parte da seqüência.
Não é possível, porém, efetuar cálculos matemáticos e aritméticos, já que

qualquer número armazenado numa variável desse tipo será considerado como
uma sequência de texto e não um valor numérico.
Podemos determinar um tamanho máximo para urna variável do tipo

String, simplesmente adicionando um asterisco (*) seguido por um número que
define o tamanho máximo em caracteres.
Por exemplo, para declarar uma variável strNomeCliente com um

tamanho máximo de 50 caracteres, você escreveria:
Dim strNomeCliente As String * 50
Se for armazenada uma cadeia de caracteres menor que o tamanho

máximo especificado, a variável será preenchida com espaços em branco à
direita para completá-la. Se por outro lado, você tentar armazenar mais
caracteres do que o permitido, os excedentes serão descartados.
Tipo Byte
Variáveis do tipo Byte são também numéricas, mas somente podem

armazenar números na faixa de O a 255. Esse tipo de variável também , é útil
em contador de loops For... Next pequenos, cujo ciclo de repetição não
ultrapasse 255.
Tipo Boolean
Uma variável do tipo Boolean pode conter apenas dois tipos de valores:
True (verdadeiro) ou False (falso). São muito utilizadas como sinalizadores, ou
seja, variáveis que indicam se uma determinada condição lógica retornou ou
resultou num desses dois valores. Veja o pequeno exemplo a seguir :
Dim blnrepete As Boolean
blnrepete = True
While blnrepete
.
.
Wend
Tipo Date
Variáveis do tipo data permitem o armazenamento de valores que

representam uma data do calendário ou um horário. Para armazenar uma data
numa variável, especifique-a entre "#", como no seguinte exemplo:
dtDataVencimento = #05/06/95#
dthora = #05:25#
Com valores do tipo data é possível executarmos adição ou subtração,

para assim calcularmos uma nova data. Por exemplo:
dtDataHoje = Now
dtDataAmanha = dtDataHoje + 1
dtDataOntem = dtDataHoje - 1
Tipo Object
Variáveis do tipo Object podem fazer referência a objetos definidos pelo

Visual Basic ou mesmo campos de uma base de dados, como dados OLE ou
binários. Elas são armazenadas em endereços de 32 bits. Para esse tipo de
variável, precisamos utilizar o comando de atribuição Set para assinalar valores
a ela, em não apenas o sinal de igualdade.
Tipo Variant
O dado Variant é um tipo especial, já que ele permite que qualquer valor
seja armazenado. Se você declara uma variável mas não especifica seu tipo de
dado, o Visual Basic automaticamente atribui a ela o tipo Variant. Assim, o dado
que você armazenar na variável é que definirá o seu tipo naquele momento.
Podemos atribuir também um valor nulo à variáveis variant, especificando

a palavra-chave Null à direita do sinal de igual. Diversas funções podem ser
utilizadas para determinar qual o tipo de dado armazenado numa variável

Variant.
3.6 Constantes
Agora que já falamos de variáveis, vejamos as constantes, que são o

oposto das primeiras.
As constantes, diferentemente das variáveis, não podem ter seus valores
alterados durante a execução da aplicação. Elas são utilizadas principalmente
para fornecer maior legibilidade ao código-fonte, substituindo expressões
numéricas ou caractere mais complexos e de difícil entendimento.
Um dos tipos de constantes mais famoso é o famigerado valor de PI

(3,14159265358979... ).
Como convenção, adotamos letras maiúsculas para os nomes de
constantes, mas isso não é regra geral.
Essa é uma prática comum para os programadores em C/C++, Pascal ou
mesmo Assembly.
3.7 Matrizes
Dim NomeMatriz (n,m) As <tipo de dados>
Exemplo:
Dim idade(30) As integer
Dim nota( 60,4) As double
3.8 Tipos definidos pelo usuário

Semelhantemente às variáveis estruturadas da linguagem C/C + + ou às
variáveis registro do Pascal, o Visual Basic oferece a capacidade de definirmos
nossos próprios tipos de dados.
Definir um novo tipo de dado pode ser muito útil quando precisamos
agrupar vários tipos de dados diferentes mas correlacionados numa única
variável, facilitando assim seu tratamento. Você poderia pensar que as
matrizes resolveriam esse problema, mas nesse caso não são tão
convenientes.
Para criar uma variável com um novo tipo de dado você utiliza o
comando Type, colocado na seção Declarations do módulo. Vejamos um
exemplo prático, onde criaremos uma variável tipada chamada tpcliente,
contendo outras variáveis para armazenamento do código do cliente, do
endereço do cliente, nome da firma, cidade onde reside, salário e departamento
onde trabalha.
Type tpcliente
intCodigoCliente As Integer
strendereco As String * 50
strcidade As String * 25
strempresa As String * 40
strdepto As String * 20
sglsalario As Single
End Type
Aqui podemos dizer que a variável tpcliente comporta-se como um

registro completo de um banco de dados e as diversas variáveis que a
compõem, são os campos do registro.
tpCliente
intCodigoCiiente
strendereco
strcidade
strempresa
strdepto
sglsalario
Após ter sido criado o tipo de dado definido pelo usuário, você deverá
ainda declarar a(s) variável(eis) desse tipo específico, como ocorre com as
demais variáveis:
Dim DadosCliente As tpcliente
Cada campo da variável estruturada é acessado através de uma sintaxe

própria. Precisamos especificar a variável estruturada seguida pela variável
campo desejada, separadas por um ponto. Por exemplo, para acessar o campo
strEndereco, deveríamos especificar a seguinte expressão:
DadosCliente.strEndereco = "Av. Paulista, no 1815, 6o andar"
Se você tiver duas variáveis do mesmo tipo de dado definido pelo

usuário, poderá assinalar o valor de uma à outra apenas com o sinal de
atribuição (=), similarmente às variáveis simples. Por exemplo, suponhamos
que você tenha criado um tipo de dado chamado ContaCorrente, e que a partir
dele tenha declarado as variáveis ContaBanco1 e ContaBanco2. Assim você
poderia atribuir todos os valores dos campos da variável ContaBanco1 a
ContaBanco2 através da expressão:
ContaBanco2 = Contabancol
Você pode também ter campos numa variável tipada que é uma matriz de
dados. Por exemplo:
Type ConsumoMensal
strmes(12) AS String * 15
intconsumo(12) As Integer
End Type
Aqui nós temos um novo tipo de dado que nos permite entrar com os
consumos mensais de energia elétrica, e quem sabe desenvolver um sistema
aplicativo que nos auxiliará a economizar energia.
Um outro recurso interessante é que você pode ter uma estrutura de

dados dentro de outra estrutura. Veja o seguinte exemplo:
Type DadosPessoais
strNome AS String * 20
strSobreNome As String * 40
btIdade As Byte btEstadoCivil As Byte
End Type
Type DadosEndereco
strrua As String * 50
strBairro As String * 30
strCidade As String * 30
strEstado AS String * 2
End Type
Type Funcionário
DadosFuncionario As DadosPessoais
DadosResidencia As DadosEndereco
btCodigoEmpresa As Byte
btCodigoCargo As Byte
End Type
Type Empresa
strNomeEmpresa As String * 50
EnderecoComercial As DadosEndereco
End Type
Aqui definimos duas estruturas básicas, denominadas DadosPessoais e

DadosEnderecos. A partir delas,pudemos montar as outras duas estruturas de
forma mais organizada e legível.
Obviamente, para saber o nome do funcionário, teríamos de escrever a

expressão:
Funcionario.DadosFuncionario.strNome = "William Pereira Alves"

3.9 Operadores
Aritméticos
Operador Descrição
+ Efetua a soma entre dois ou mais números
- Efetua a subtração entre dois ou mais números
* Efetua a multiplicação entre dois ou mais números
/ Efetua a divisão entre dois números e resulta num número de
ponto-flutuante
\ Efetua a divisão entre dois números e resulta num número
inteiro
^ Efetua a exponênciação
Mod Retorna o resto de uma divisão não exata entre dois números
Lógicos
And Efetua a operação lógica E. Se ambas as expressões forem
verdadeiras, então o resultado será verdadeiro
Or Efetua a operação lógica OU. Se uma das expressões (ou
ambas) for verdadeira, então o resultado será verdadeiro
Not Efetua a operação lógica NÃO. Inverte o estado lógico de uma
expressão, se ela for verdadeira, torna-a falsa e vice-versa
Xor Efetua a operação OU EXCLUSIVO. Se uma das expressões for
verdadeira, o resultado será verdadeiro, porém se ambas forem
verdadeiras, o resultado será falso
Eqv Efetua a operação de equivalência de expressões. O resultado
será verdadeiro somente se ambas as expressões forem
equivalentes.
Imp Efetua a operação de implicação lógica. Retorna verdadeira se
uma expressão implica em outra
Tabela do operador lógico Imp

A primeira expressão é A segunda expressão é O resultado será
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso

Verdadeiro Nulo Nulo
Falso Verdadeiro Verdadeiro
Falso Falso Verdadeiro
Falso Nulo Verdadeiro
Nulo Verdadeiro Verdadeiro
Nulo Falso Nulo
Nulo Nulo Nulo
Operadores Relacionais
< Menor que
> Maior que
<= Menor que ou igual a
>= Maior que ou igual a
= Igual a
<> Diferente de
String
“&” ou “+” Þ concatenam duas strings

msgbox “exemplo” & “concatenação” Þ Exemploconcatenção
Prática 7
Vamos fazer uma aplicação que some dois vetores com 8 elementos do
tipo inteiro cada um. Lembre-se que os vetores na linguagem Visual Basic
inicia-se com índice zero (0).
Crie um formulário com os seguintes objetos:

cmdok
cmdok2
Entrada do vetor A Ok
lblentrada
Entrada do Vetor B Ok
Resultado
txtentrada txtentrada2
Calcular
cmdcalcular
Tente fazer sozinho! Apenas em caso de emergência consulte a

resolução.
Resolução:
Nomeie os objetos e depois insira o seguinte código:
Na seção General (declarations) insira:
Option Explicit ‘ na parte General (declarations)
Dim vetorA(8), vetorB(8), vetorC(8) As Integer

Dim i As Integer
Na rotina click do botão calcular:
Private Sub cmdcalcular_Click()
lblsaida.Caption = "Resultado = "

For i = 0 To 7
vetorC(i) = vetorA(i) + vetorB(i)
lblsaida.Caption = lblsaida.Caption & " " & vetorC(i)

Next i
End Sub
No evento click do primeiro botão Ok do formulário:
Private Sub cmdok_Click()
If i <= 8 Then
vetorA(i) = Val(txtentrada.Text)
i=1+i
txtentrada.Text = ""
txtentrada.SetFocus
If i = 8 Then
txtentrada.Enabled = False
txtentrada.Text = ""
cmdok.Enabled = False
cmdok2.Enabled = True
txtentrada2.SetFocus
i=0
End If
End If
No evento click do segundo botão Ok:
Private Sub cmdok2_Click()
If i <= 8 Then
vetorB(i) = Val(txtentrada2.Text)
i=i+1
txtentrada2.Text = ""
txtentrada2.SetFocus
If i = 8 Then
txtentrada2.Enabled = False
txtentrada2.Text = ""
cmdok2.Enabled = False
End If
End If
End Sub
No evento load do formulário:
Private Sub Form_Load()
lblentrada.Caption = "Entrada do vetor A"

lblentrada2.Caption = "Entrada do vetor B"
End Sub
Prática 8
Fazer uma aplicação que simule uma calculadora, as operações possíveis

serão:
+ soma
- subtração
/ divisão com resto
Mod resto
\ divisão com inteiro
^ exponenciação
* multiplicação
Ajuste as propiedades dos objetos da seguinte forma:
frm (formulário)
caption = calculadora
icon = <escolhe um ícone>
name = frm calculadora
cmd (botões de comando)

1. name = cmdsair
caption = &sair
2. name = cmdlimpar
caption = &limpar
3. name = cmdcalcular
caption = &calcular
default = true
txt (caixas de texto)
1. name = txtresultado
enable = false
text = <vazio>
2. name = txtop2
tabindex =2
text = <vazio>
3. name = txtop
tabindex =1
text = <vazio>
3. name = textop1
tabindex =0
text = <vazio>
lbl
1. name = lblresultado
captiom = resultado
2. name = lblanuncio
caption = operações : + - / mod ^ \ *
3. name = lbloperação
caption = operação
4. name = lbloperador2
caption = operador2
5. name = lbloperador1
caption = operador1
6. name = lbligual
caption ==
A seguir insira o seguinte código:
cmdcalcular_click( )
dim op1 as double, op2 as double, opção as string
op1 = val (txtop1.text)
op2 = val (txtop2.text)
opção = txtop.text
select case opção ‘nós ainda não vimos esta estrutura mas ela já nos é
‘ familiar
case “+” : txtresultado.text = op1 + op2

case “-” : txtresultado.text = op1 - op2
case “/” : txtresultado.text = op1 / op2
case “\” : txtresultado.text = op1 \ op2
case “Mod” : txtresultado.text = op1 Mod op2
case “^” : txtresultado.text = op1 ^ op2
case “*” : txtresultado.text = op1 * op2
end select
cmdlimpar.setfocus
end sub
No evento click do objeto cmdlimpar insira:
cmdlimpar_click( )
txtop1.text = “ “
txtop2.text = “ “
txtop.text = “ “
txtop1.setfocus
No evento click do botão sair escreva:

cmdsair_click( )
end
end sub
Módulo 4
Estruturas de
Controle
Neste módulo, aprenderemos a criar estruturas de controle, que são

importantes componentes de qualquer linguagem de programação.
Estas estruturas permitem que você verifique a ocorrência de
determinadas condições lógicas bem como reutilize blocos de código, tomando
seu trabalho de programação mais produtivo.
Como já adiantamos a você, as estruturas de controle são uma

importante ferramenta de programação, permitindo não só a realização de
desvios lógicos no processamento de seu programa, mas também a reutilização
de blocos de código existentes até que determinado resultado seja obtido.
O Visual Basic coloca à sua disposição uma série de comandos com esta
finalidade, permitindo-lhe uma grande flexibilidade no desenvolvimento de suas
aplicações.
Como você já deve estar imaginando, a melhor maneira de aprender
como estas estruturas operam é na prática, através de um novo aplicativo que
iremos desenvolver.
4.1 Criando o Aplicativo Estruturas de Controle
Vamos iniciar a criação de nosso aplicativo selecionando a opção New

Project no menu File.
Prática 9
Crie um formulário com o seguinte layout:

Imagem
ESTRUTURAS DE CONTROLE
FOR NEXT (LABEL1)
Text 1 Text 2 Text3

Início Limite Passo
(label2) (label 3) (label 4)
(label 5, sem texto)
Text
4
Valor Atual de Início: (label 6)
(Text 5)
Iniciar (command)
Determine as seguintes propriedades aos objetos:
Vamos iniciar pelo Formulário.
Propriedade Valor
Caption Estrutura de Controle
Name frmEstruturas
Selecione agora o controle Label1:
Propriedade Valor
Alignment 2 - Center
Caption FOR NEXT
Font MS Sans Serif - Negrito - 14*
Name LblTítulo
* Ao selecionar o botão “...”, é aberta a janela “Fonte” onde você pode

definir as características do texto a ser exibido.
Passe agora para o controle Label2:
Propriedade Valor
Alignment 1 - Right Justify
Caption Início:
Name LblÍnicio
Vamos ajustar agora o controle Text1.
Propriedade Valor
Name TxtÍnicio
Text <apagar o valor atual>
Selecione o controle Label3:

Propriedade Valor
Caption Limite:
Name LblLimite
Passe agora para o controle Text2:
Propriedade Valor
Name TxtLimite
Ajuste agora Label4:
Propriedade Valor
Caption Passo:
Name LblPasso
Faça o mesmo com Text3:
Propriedade Valor
Name TxtPasso
Selecionar agora Label5 e ajuste as suas propriedades conforme a tabela

abaixo :
Propriedade Valor
Alignment 2 - Center
Caption <apagar o valor atual>
Name LblMsg
Aproveite para alterar as propriedades do Label6 para :

Propriedade Valor
Alignment 1 - Right justify
Caption <apagar o valor atual>
Name Lblação
Calma, agora falta pouco. Pode parecer cansativo, mas seja sincero:
Quanto tempo você gastou para criar este aplicativo ? Uns poucos minutos não
foi ? Pode ter certeza de que os minutos que você empenhou na criação deste
aplicativo renderão bons conhecimentos sobre as estruturas de controle que
estamos estudando agora.
Respire fundo e passe para o próximo controle, que é o Text4.
Faça as seguintes alterações :
Propriedade Valor
Name TxtValorAtual
TabStop False
O próximo passo será alterar o controle Text5:
Propriedade Valor
Name TxtAção
TabStop False
Complementando nosso aplicativo, altere as propriedades do controle Image1

para o seguinte:
Propriedade Valor
BorderStyle 1 - FixedSingle
Enabled False
Repita o mesmo para o controle Image2 :
Propriedade Valor
BorderStyle 1 - FixedSingle
Enabled False
Finalmente, ajuste as propriedades do controle Command1:
Propriedade Valor
Caption &Iniciar
Default True
Name BtnIniciar
A única coisa que falta agora é definirmos o código que será associado
ao botão "Iniciar" de nosso formulário, mas isto dependerá dos próximos
assuntos que iremos aprender em seguida.
4.2 Adicionando Comentários em seu Código
Agora que você já está ficando com mais prática na utilização do Visual
Basic e pouco a pouco está desenvolvendo aplicativos cada vez mais
sofisticados, está na hora de começar a documentar as suas rotinas.
Talvez você até ache desnecessário fazer isto devido à simplicidade dos
códigos que estamos criando, mas não custa nada documentar desde o início,
pois é uma boa prática ir se acostumando a documentar as rotinas criadas por
voce.
Lembre-se de que uma rotina que é óbvia hoje pode não ser tão óbvia
quando você voltar a estudá-la daqui há seis meses ou um ano.
Imagine também que talvez outra pessoa irá analisar sua rotina no futuro,
e que poderá ter grandes dificuldades para entender o que você fez.
Documentar suas rotinas é muito importante para

tornar seu código mais legível não só para você, mas também
para as outras pessoas que irão analisá-lo mais tarde.
Adotar este hábito saudável irá poupar seu tempo
no futuro, quando será necessário relembrar por que
você adotou determinadas soluções técnicas
e , não outras aparentemente mais simples.
A Instrução REM
A instrução REM nada mais é do que uma abreviação da palavra

Remark, que significa Comentário.
Você pode incluir comentários em seus códigos de duas formas: através

da instrução REM seguida do comentário desejado, ou do apóstrofo ( ‘ ) antes
do comentário a ser incluído.
Tudo o que estiver à direita da palavra Rem ou do sinal de apóstrofo será

simplesmente ignorado pelo Visual Basic.
Quando você utilizar a instrução REM, deixe um espaço em branco entre
esta instrução e o comentário propriamente dito, como em:
REM Este é um exemplo de comentário
Já para o apóstrofo, não é necessário deixar o espaço em branco entre o

sinal e o comentário:
'Exemplo de comentário usando o apóstrofo
Estes comentários também podem ser utilizados em linhas de código que

contêm outras instruções, como em:
Dim Teste As lnteger 'Declara a variável Teste como Inteiro
O único cuidado que deve ser tomado quando incluímos comentários em

uma linha que contém instruções para o Visual Basic, é quando utilizamos a
instrução REM.
Neste caso, será necessário acrescentarmos o sinal de dois pontos ( : )

logo após a última instrução válida, para em seguida incluirmos a instrução
REM. Você entenderá melhor vendo o exemplo abaixo:
Dim Teste As lnteger: REM Não esqueça de incluir : antes de

REM !
Note que este caso somente se aplica à utilização de REM em uma linha
que já contém comandos.
Este recurso é bastante útil durante a fase de

desenvolvimento de aplicativos, pois podemos evitar
a execução de determinadas linhas de nosso código pelo
Visual Basic, sem que haja necessidade de apagarmos tais informações
de nossas rotinas. Após os testes, basta eliminar os
sinais de comentário para que o Visual Basic volte a
interpretar as linhas de código
existentes.
Agora que já sabemos utilizar os comentários para documentar nossas rotinas,

vamos iniciar nosso estudo pela estrutura de controle lf Then Else.
4.3 Estrutura lf Then Else
Uma das estruturas de controle mais utilizadas na programação em Visual Basic é

sem dúvida alguma a instrução lf Then, que é utilizada para avaliar uma determinada
expressão e definir se um determinado bloco de código deve ou não ser executado.
A sintaxe para utilização deste comando é a seguinte:
If Condição Then
[Bloco de Código]
[Elseif Condição-n Then

[Bloco de Códígoll
[Else
[Bloco de Código]]
End lf
Detalhes:
· Condição - É a condição a ser avaliada pelo VB. Esta condição utiliza os

operadores de comparação que aprendemos anteriormente, sendo que a
mesma tanto pode ser do tipo numérico como do tipo String.
· Condlção-n - É uma outra condição lógica que pode ser avaliada pelo VB.
O índice n indica que você pode inserir quantas condições lógicas quiser,
bastando para isso repetir a instrução Elself.
· Else - O bloco de código associado a esta instrução só será executado caso

nenhuma das condições lógicas anteriores tenha sido verdadeira, ou seja, se
todas as condições lógicas associadas ao lf e Elself resultaram em False, o VB
executará o bloco de código associado ao Else.
· End lf - Indica o final da estrutura de controle lf Then. Ao longo deste

módulo você notará que a maioria das estruturas de controle são
iniciadas pelo comando que as identifica e terminadas pela instrução
End. Por questões de documentação, o VB aceita que você identifique
que estrutura está sendo finalizada através do acréscimo do comando
inicial da estrutura à palavra End, como em End lf por exemplo.
Descrição
A instrução lf ... Then (Se ... Então) sempre está associada a uma
comparação lógica qualquer, como A > 10, por exemplo .
Se a condição for verdadeira (True), o VB executa o bloco de código
imediatamente abaixo desta linha até encontrar uma outra instrução Elself, Else
ou Endif, quando então a execução do programa passa para a linha

imediatamente abaixo da instrução Endif.
Caso o primeiro teste lógico resulte em False, o VB irá procurar pela
próxima instrução de comparação da estrutura lf Then. Caso exista alguma
instrução Elself, o VB procederá da mesma forma como fez com a instrução lf,
executando o bloco de código logo abaixo desta linha se a comparação for
verdadeira, ou continuando a busca pela próxima instrução se a comparação for
falsa.
Caso todas as comparações lógicas anteriores tenham resultado em

False e exista uma instrução Else no bloco de código, esta será executada sem
a realização de qualquer tipo de comparação lógica.
Caso não exista a condição Else em sua estrutura lf Then, a execução

será encerrada quando o VB encontrar a instrução Endlf, que sinaliza o fim da
estrutura de controle.
Como já construímos um novo aplicativo para o estudo das estruturas de

controle, vamos utilizá-lo para entender melhor como funciona o comando lf...
Then.
Prática 10 Alterando o Aplicativo Estruturas de Controle
Selecione o botão "Iniciar" e dê dois cliques sobre o mesmo para ter

acesso à janela de código.
Entre com as seguintes instruções neste arquivo:
Rem Estudo de lfThenElse
Dim Inicio As Integer, Limite As Integer
lnicio = Txtinicio.TEXT ' inicializa variável com o valor do controle
Limite = TxtLimite.TEXT ' Idem
lf Inicio > Limite Then ' Se Inicio > Limite executa esta opção
TxtAção.TEXT = "A opção IF foi a escolhida! "
Elseif Inicio = Limíte Then ' Se Inicio = Limite executa esta:

TxtAção.TEXT = "A opção ELSEIF foi a escolhida!"
Else 'Se nenhuma das anteriores executa esta:
TxtAção. TEXT = "A opção ELSE foi a úníca escolhida! "
Endif
Faça um último ajuste em sua janela de código, selecionando a opção

Form na caixa de listagem Object e a opção Load na caixa de listagem Proc.
Digite a seguinte expressão nesta janela:
LbiTitulo. Caption = "IF THEN " ' Altera o titulo da janela
TxtPasso.Enabled = False 'Desabilita a TextBox Passo

Execute o seu aplicativo e entre com os valores 100 e 10 nas caixas de
texto Início e Limite. Não se preocupe com os demais controles, pois os
mesmos serão utilizados pelos exercícios futuros no momento adequado.
Por enquanto utilizaremos apenas as caixas de texto citadas.

Clique sobre o botão "Iniciar" e veja o resultado obtido em nosso primeiro
exemplo.
Note que agora a condição associada à instrução IF não é mais

verdadeira (início não é maior do que Limite) e desta forma o VB procurou a
próxima instrução de comparação. Como existe uma condição lógica que
analisa se o valor de Início e Limite são iguais, o VB executou esta opção,
apresentando a mensagem correspondente a esta situação.
Um último teste: entre com 1 e 10.
Se você reparar com atenção, perceberá que nós estabelecemos três

condições lógicas possíveis em nossa estrutura lf then se o valor Inicial fosse
maior do que o valor Limite, se ambos os valores fossem iguais e se nenhuma
das condições anteriores ocorresse.
Aliás, foi o que ocorreu em nosso exemplo, pois os valores que entramos
não satisfazem as condições do lf ou do ElselF.
Diante disso a opção Else foi executada sem maiores perguntas.
Vamos fazer uma leve modificação em nosso aplicativo.

Pare a sua execução e dê dois cliques sobre o botão "iniciar" ou selecione F7

para abrir a janela de código.
Acrescente a seguinte expressão dentro da estrutura lffhen, logo a seguir
da opção Elself existente:
Elself Inicio = 12 Then ' Somente se Inicio = 12 executa esta opção

TxtAção. TEXT = "A 2a. opção ELSEIF foi escolhida! "
Execute o seu aplicativo mais uma vez e entre com os valor 12 e 10 para
ver o que ocorre:
Pode parecer estranho, mas apesar de termos declarado o valor Início

como sendo igual a 12 o VB não executou o segundo Elself como haviamos
determinado.
A explicação para este fato serve de alerta para quando você for criar
seus próprios aplicativos utilizando as estruturas de controle lfThen.
Observe seu código com cuidado e note que o segundo Elself que
inserimos na estrutura somente será executado quando o valor Início for igual a
12 e o valor Limite for maior que 12, caso contrário a instrução IF será
executada em primeiro lugar, pois sempre que 12 for maior do que o valor
Limite, a primeira condição lógica será satisfeita e o VB não analisará nenhuma
outra condição do lf. O mesmo acontecerá se você utilizar os valores 12 e 12,
pois também neste caso o VB executará o primeiro Elseif da estrutura onde a
condição estabelecida é valor Início = Limite, ignorando todas as demais
condições.
Instrução Será executada se...
lf Início > Limite

Elself Início = Limite
2o Elself Início = 12 e Limite > 12
Else Início < Limite
Execute o aplicativo novamente com os valores 12 e 20 e veja que desta

vez sua rotina foi executada sem maiores problemas.
É importante perceber que o VB analisa as

condições lógicas em seqüência, de forma que se
você quiser que uma determinada ação seja

tomada quando ocorrer uma situação bastante
específica, coloque esta condição em primeiro
lugar na estrutura lf then.
Utilizando apenas uma Linha

Você também pode definir condições lógicas lfthen utilizando apenas uma
linha de código, tornando seu código bem compacto, porém menos legível.
Geralmente, esta opção é mais utilizada durante a fase de testes de

aplicativos devido sua praticidade, pois basta acrescentar a palavra REM na
frente da expressão para que o seu aplicativo simplesmente ignore-a. Já,
utilizando uma estrutura como a que estudamos no item anterior, teríamos bem
mais trabalho para torná-la "transparente" para o Visual Basic.
A sintaxe para esta estrutura não difere muito do que vimos

anteriormente:
lf Condição Then Expressão [Else Expressão]
Um exemplo de utilização desta sintaxe poderia ser a seguinte condição:
íf Teste = 'Sim' Then A = 1 Else A = O
Note que o VB operaria da mesma forma que na estrutura completa,

avaliando primeiramente se a condição proposta é verdadeira. Em caso
afirmativo, seria atribuído à variável A o valor 1, caso contrário a mesma
receberia o valor zero.
Você também pode executar mais de um comando associado ao IF ou ao

Else quando utiliza esta estrutura em uma única linha basta separá-los pelo
sinal de dois pontos entre um e outro, como no exemplo a seguir:
lf Teste = "Sim' Then A = l : Nome = "João” Else A = O: Nome = "Nulo"

O único cuidado a ser tomado é que todos os componentes da expressão

devem estar numa mesma linha e separados pelo sinal de dois pontos ( : ) um
do outro.
4.4 Estrutura Select Case
Você também pode selecionar um determinado grupo de comandos

simplesmente avaliando o valor de uma expressão através da estrutura Select
Case.
Este comando possui a seguinte sintaxe:
Select Case Expressão
[Case condição-n
[Bloco de Código1]...
[Case Else
[Bloco de Códígon]
End Seíect
Detalhes:
· Expressão - É qualquer expressão numérica ou de string avaliada pelo

Visual Basic.
· Condição-n - É a condição lógica a ser avaliada pelo VB. O índice n

indica que você pode inserir quantas condições lógicas quiser,
bastando para isso repetir a instrução Case.
· Case Else - O bloco de código associado a esta instrução só será

executado caso nenhuma das condições lógicas anteriores tenha sido
verdadeira.
· End Seiect - Indica o final da estrutura de controle Select Case.
Descrição:
Inicialmente, é necessário definir a expressão que será avaliada pela

estrutura Case, atribuindo a mesma à instrução Select Case.
A partir daí o Visual Basic compara o valor desta expressão com a primeira
instrução Case existente na estrutura de controle. Se os valores de ambas
forem iguais, o Visual Basic executará o bloco de código associado à condição
Case avaliada, e ao final desta passará o controle do programa para a primeira
linha de código logo abaixo da instrução End Seiect.
Caso o valor da instrução Case seja diferente da expressão associada ao

Select Case, o Visual Basic passará para a próxima instrução Case da
estrutura, repetindo o processo até encontrar uma instrução que satisfaça a
condição lógica definida.
Se não existir nenhuma instrução na estrutura de

controle que satisfaça esta condição proposta, o VB
poderá adotar dois caminhos: executar a instrução
Case Else caso a mesma exista, ou simplesmente
encerrar a execução da estrutura.
A instrução Case Else será executada sempre que todas as demais

condições existentes resultarem em False na comparação com a expressão
definida em Select Case.
Você entenderá melhor o que queremos dizer, observando na prática o
funcionamento desta estrutura.
Prática 11
Faça a seguinte alteração no código associado ao botão "iniciar" do

nosso aplicativo:
Rem Estudo de Select Case
Dim Inicio As lnteger
Inicio = Txtlnlcio. TEXT 'lnicializa variável com o valor do controle

Select Case Inicio 'Avalia a expressão
Case 1 'Verifica se Início = 1

TxtAção.TEXT = "Você escolheu o número 1 "
Case 2 'Verifica se Inicio = 2

TxtAção.TEXT = "Você escolheu o número 2”

TxtAção. TEXT = "0 número 5 foí a sua escolha!"
Case Else 'Se as condições anteriores forem Falsas

TxtAção. TEXT = "Você não escolheu 1, 2 ou 5. "
End Select I
Necessitamos ainda de um outro pequeno ajuste em nosso

formulário.
Altere a rotina Form_load conforme abaixo:
LblTítulo.Caption = "CASE SELECT" ' Altera o título da janela
TxtPasso.Enabled = False 'Desabilita a TextBox Passo
TxtLimite.Enabled = False 'Desabilita a TextBox Limite

Como você pode reparar, apenas quando o valor de entrada for igual a 1,
2 ou 5 é que o VB emitirá uma mensagem específica.
Para todos os demais valores informados o Visual Basic exibirá a
mensagem associada à instrução Case Else.
Execute agora o seu aplicativo e entre com o valor 1 na caixa de texto

Início.
Definindo Faixas de Valores
No exemplo que criamos, todas as instruções Case estão vinculadas à

ocorrência de um número ou string predeterminado, porém você pode definir
que ações serão tomadas para determinadas faixas de valores.
Você pode fazer isto simplesmente definindo a condição Case da

seguinte forma:
Case i To j
Onde i é o valor inicial e j o valor final da faixa avaliada.
Prática 12
Encerre a execução de seu aplicativo e faça uma rápida alteração na

estrutura Select Case:
Select Case Inicio 'Avalia a

expressão
Case 1 To 4 'Verifica se Inicio

está entre 1 e 4
TxtAção.TEXT = "Você escolheu um número entre 1 e
4"

TxtAção.TEXT = "0 número 5 foi a sua escolha! "
Case 6 To 8 'Verifica se Inicio está entre 6 e 8

TxtAção.TEXT = "Você escolheu um número entre 6
e8"
Case Else 'Se as condições anteriores forem

Falsas
TxtAção.TEXT = "0 número escolhido é maior que
8! "
End Select
Execute seu aplicativo novamente e entre com alguns valores entre 1 e
10 e veja como o VB interpreta seus dados.
Você perceberá que esta característica é muito útil quando os valores

avaliados podem ter determinadas tolerâncias, pois permite que você torne seu
código bem mais compacto do que definir uma condição Case para cada valor a
ser avaliado.
Utilizando Operadores de Comparação

Você também pode utilizar operadores de comparação com a instrução

Case, basta acrescentar o operador ls na expressão lógica definida por você,
como por exemplo em:
Case ls >= 20
Altere o código de seu aplicativo acrescentando mais uma instrução

Case na estrutura de controle, logo abaixo da última instrução Case definida por
você e antes da instrução Case Else:
Case ls > 20
TxtAção.TEXT = "Você escolheu um número maior que 20 "
Execute o seu aplicativo e entre com qualquer valor acima de 20 para ver
o que acontece.
Avaliando Expressões do Tipo String
Até agora em nossos exemplos, sempre utilizamos valores numéricos para

estudar o comportamento da estrutura Case, porém o Visual Basic também
permite que você utilize valores do tipo String em suas expressões.
Vamos alterar um pouco o código de nosso aplicativo, alterando os

valores analisados nas instruções Case para dados do tipo string, como
mostramos a seguir:
Rem Estudo de Select Case
Dim Inicio As String
Início = Txtinlcio.TEXT 'lnicializa variável com o valor do controle
Select Case Inicio 'Avalia a expressão
Case "José " 'Verifica se Inicio é igual a

José
TxtAção.TEXT = "José foi escolhido "
Case "João " 'Verifíca se Início = João

TxtAção.TEXT = "0 nome é João!"
Case "Maria " 'Verifica se Inicio = Maria

TxtAção.TEXT = "Você dígitou Maria"
Case Else TxtAção.TEXT = "Nenhum nome foí selecionado! 'Se as

condições anteriores são False
End Select
Coloque seu aplicativo em execução e entre com os nomes José, jose,

João e joao e repare como o VB trata cada um destes nomes. Note que nesta
comparação de strings, o Visual Basic diferencia palavras acentuadas ou não e
palavras grafadas em maiúsculas e minúsculas, por isso tome muito cuidado ao
realizar comparações de strings, pois seu programa pode apresentar um
comportamento bastante estranho apesar de você ter a certeza de que tudo
está em perfeito estado.
Vamos estudar agora a estrutura For Next, que é uma outra instrução
muito utilizada na programação em Visual Basic.
4.5 Estrutura For Next
Este comando repete um mesmo bloco de código um determinado

número de vezes independentemente de qualquer condição lógica.
A sintaxe deste comando é a seguinte:
For Contador = Valorinicial To ValorFinal [Step Passo] [Bloco de Código] [Exit

For]
[Bloco de Código]
Next [Contador]
Detalhes:
· Contador - É uma variável de memória numérica que será utilizada para

controlar o número de execuções do bloco de código.
· Valorlniclal - Valor de inicialização do contador. Você pode iniciá-lo

com o valor zero, um ou mesmo qualquer outro que julgue necessário.
· ValorFinal - É o valor final que a variável Contador assumirá antes de

encerrar a execução do loop.
· Passo - Você pode determinar se a variável contador será incrementada

de um em um ou de dois em dois por exemplo.
Caso você não informe este parâmetro, o Visual Basic considera
que o incremento será positivo de uma em uma unidade. Você também
pode definir números negativos para esta opção.
· Exit For - Você pode interromper a execução do loop através desta

instrução. Ao encontrá-la no meio de seu bloco de código, o loop é
interrompido. Esta instrução normalmente está associada à ocorrência
de uma determinada condição lógica.
Descrição
Para utilizar esta estrutura de controle você necessitará de uma variável

de memória para ser o contador do número de repetições que a estrutura fará.
Esta variável é inicializada com o valor especificado por você em

Valorlnicial e é feita uma comparação de seu valor com o valor definido por você
em ValorFinal.
Se o valor do Contador é menor do que o valor de ValorFinal, o bloco de código
localizado entre as declarações For e Next é executado uma vez.
Ao final da execução do bloco de código, o Visual Basic incrementa a

variável de controle o número de unidades especificado em Passo.
É feita uma nova comparação, e se o contador ainda for menor que a variável
ValorFinal, o ciclo se repete.
Quando o contador atinge um valor maior que a variável limite, a
execução do loop é encerrada e o Visual Basic passa para a linha
imediatamente seguinte à declaração Next.
Vamos aprender na prática como se comporta um loop do tipo For Next
através do aplicativo que criamos no início deste módulo.
Prática 13
Alterando o Aplicativo Estruturas de Controle.
Selecione o botão "Iniciar" e dê dois cliques sobre o mesmo para ter

acesso à janela de código.
Entre com as seguintes instruções neste arquivo:
Vamos considerar que o sinal @ indica que o comando

continua na mesma linha, que por questões de editoração da
apostila, o mesmo foi dividido em duas ou mais linhas.
Rem Estudo de For Next
Dim Contador As integer, Inicio As integer, Limite As integer, @

Passo As integer, Vezes As integer
Início = Txtinlcio.TEXT 'lnicializa vanável com o valor do controle

Limite = TxtLimite.TEXT 'Idem
Passo = TxtPasso.TEXT 'Idem
Vezes =0 'lnicializa a vanável Vezes com zero
LblMsg.Captfon = " Enquanto Contador for menor ou igual a " &

Limite @
& " o bloco de código será executado! "
LblMsg.Refresh 'Atualiza o controle LblMsg
For Contador = inicio To Limite Step Passo
Vezes = Vezes +1
TxtValorAtual. TEXT = Contador
TxtValorAtual.Refresh 'Atualiza o controle
TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & @
“ a. vez”
TxtAção.Refresh 'Atualiza o controle
Next
Rem Depois de executar o loop o controle do programa passa para esta

linha:
TxtAção.Text = "0 bloco de código foí executado " & Vezes & " vezes!"
Faça um ajuste na procedure Form-load, deixando apenas as seguintes

linhas de código:
LblTítulo.Caption = "FOR NEXT” ‘ Altera o titulo da janela

LblAção.Caption = "Valor Atual do Contador"
Execute o aplicativo e entre com os valores 1 para Inicio, 10 para Limite e

1 para Passo.
Clique sobre o botão "iniciar" e veja o que ocorre.
Dependendo da velocidade de seu microcomputador, você só conseguirá ver a

última mensagem exibida na tela após o término do loop.
Na prática, o que o sistema faz é exibir na tela os valores das variáveis

definidas por nós conforme a instrução For Next vai alterando as mesmas.
Para facilitar a sua vida vamos fazer uma pequena alteração em nosso
aplicativo, incluindo mais algumas linhas de código a fim de "desacelerarmos" nosso
computador.
Acrescente as seguintes instruções logo abaixo da linha TxtAção.Refresh, de
modo a deixar sua rotina com a seguinte aparência:
For n = 1 To 100000
REM Este loop não faz nada!
Next
Na verdade, o que fizemos foi nada mais do que acrescentar um outro loop
dentro do já existente, para fazer com que o Visual Basic gaste um determinado tempo
entre uma atualização de tela e outra, e assim podermos ver o conteúdo das variáveis
envolvidas no loop.
Saiba que o valor de 100000 foi obtido experimentalmente, e

dependendo da velocidade de seu computador, você terá que aumentar ou
reduzir este valor até obter o intervalo desejado entre uma exibição e outra em
seu monitor.
Saindo de um Loop For Next
Como já vimos no item anterior, sempre que você inicia a execução de

um loop For Next, ele somente encerra sua operação quando o contador atingir
um valor maior do que o valor final do loop.
Na verdade, você pode interromper a execução do mesmo, utilizando
para isso o comando Exit For.
Geralmente, este comando é utilizado em conjunto com uma instrução lf,
como a que vimos no início deste capitulo.
Vamos supor que você deseja executar um bloco de código um

determinado número de vezes ou até que um dado valor seja atingido. Este
valor tanto pode ser proveniente do cálculo de uma fórmula qualquer como de
uma variável de memória existente.
Você poderia, por exemplo, definir esta condição da seguinte maneira:
lf Vezes = Limite / 2 Then

Exit For
End lf
Como a variável Vezes é incrementada em uma unidade a cada

execução do loop, você pode definir que assim que o valor da mesma for igual
ao valor da variável Limite dividido por dois, o loop será encerrado.
É claro que neste caso, seria mais fácil definirmos logo de início o valor
adequado para a variável Limite ao invés de acrescentarmos uma cláusula Exit
For, mas como estamos apenas querendo mostrar a você o mecanismo desta
instrução Exit, vamos aproveitar as variáveis de memória que já existem em
nosso código, evitando assim termos que fazer mais alterações na rotina
existente.
Utilizando Instruções For Next Aninhadas
No exemplo anterior, utilizamos duas instruções For Next aninhadas, isto

é, uma dentro da outra. Veja a seguir, um fragmento do código que utilizamos
em nosso exemplo:
For Contador = Inicio To Limite Step Passo
Vezes = Vezes + 1
TxtValorAtual.TEXT = Contador
For n = 1 To 100000
Rem Este loop não faz nada!
Next
Next
Até que olhando desta forma não há muitas dúvidas sobre que instrução
Next está relacionada à primeira instrução For, mas e quando suas rotinas
forem ficando cada vez maiores complexas?
Ao analisar seu código, você pode ser levado a concluir erroneamente que um
determinado Next está associado a uma instrução For, quando na verdade
ambas não têm nada a ver uma com a outra, o que fatalmente o levará a
cometer um erro de avaliação de sua rotina.
Outro ponto importante é que se por um erro seu, uma instrução Next for
encontrada antes da instrução For correspondente, o VB apresentará um erro
em tempo de execução, paralisando a execução de seu aplicativo.
Este tipo de erro bastante comum pode ser evitado, bastando para isso declarar
junto à instrução Next o nome da variável de memória que é utilizada como
contador pelo Visual Basic, como no exemplo a seguir:
For Contador = Inicio To Limite Step Passo
Vezes = Vezes + 1
TxtValorAtual.TEXT = Contador
For n = 1 To 100000
Next n ‘Incrementa a variável n
Next Contador ‘Incrementa a variável Contador
Para evitar erros de execução ao utilizar

instruções For aninhadas, você sempre deve declarar a
instrução acompanhada do nome da respectiva
variável utilizada como contador do loop.
Um último comentário sobre a estrutura For Next:
Como você pode observar nos exemplos que criamos, o valor do

contador sempre é armazenado em uma variável de memória, e por isso mesmo
sempre é possível modificarmos o seu valor, alterando o comportamento do
loop. Isto tanto pode ser um importante recurso de programação como uma
fonte de dores-de-cabeça, dependendo da forma como você utilize esta
possibilidade e da complexidade de seu código.
A utilidade deste recurso é que você pode repetir a execução do loop

indefinidamente até que uma determinada condição desejada seja obtida.
Na verdade, existem outras formas mais adequadas de se fazer isto,
porém não podemos deixar de considerar a possibilidade de realizarmos esta
tarefa com a estrutura For Next.
O ponto negativo é que alterando o valor do contador do loop durante a

execução, você pode levar o seu programa a entrar num loop infinito caso a
meta definida por você não possa ser atingida, além de tornar o seu aplicativo
mais difícil de entender e depurar.
Só para ter uma idéia do que queremos dizer, imagine que seu aplicativo
faça uso do seguinte bloco de código:
Private Sub BtniniciaLClíckO
Rem Estudo de For Next com alteração do Contador durante a

execução
Dim Contador As integer, Resultado As Single, Vezes As integer
Resultado = 100 ‘ lnicializa a variável com o valor 100
For Contador = 1 To 10
Resultado = Resultado + (1.005 ^ 2) 'Fórmula a ser calculada

Vezes = Vezes + 1 'Número de execuções
TxtValorAtual. TEXT = Resultado 'Exibe o resultado na

Textbox
For n = 1 To 100000 'Loop para desacelerar o programa

Next n
lf Resultado < 120 And Contador = 10 Then Contador

=1'Ajusta valor do Contador Para o valor 1
Next Contador
Rem Depois de executar o loop o controle do programa

Rem passa para esta linha:
TxtAção. TEXT = "0 bloco de código foí executado ". & Vezes & " vezes!"
End Sub
Note que o ponto crítico é a linha que analisa o valor atual da fórmula. Em nosso
exemplo, sabemos que num determinado momento o valor da fórmula será maior que 120,
fazendo com que o loop deixe de ser executado.
Mas e quando os valores são definidos no decorrer do programa com valores
entrados pelo usuário? Dependendo dos dados entrados pelo usuário, pode ser bastante
complicado estimar se uma determinada condição irá ocorrer ou não, comprometendo o
funcionamento de seu aplicativo.
A nossa sugestão é que você evite alterar o valor do

contador do loop durante a execução deste, se não
tiver a certeza de que o valor limite para o encerramento
do loop será atingido em um determinado momento da execução.
Aliás, se você executar o aplicativo acima, verá que o valor limite para o
encerramento do loop será atingido após 28 execuções, isto é, o contador mesmo foi
reiniciado duas vezes após a execução inicial.
4.6 Estrutura DO...LOOP
Este comando repete a execução de um bloco de código enquanto uma

determinada condição for verdadeira, ou até que uma condição especificada
torne-se verdadeira.
Este comando pode ser declarado de duas formas distintas:

Do [{While I Until} Expressão]

[Bloco de Código]
[Exit Do]
[Bloco de Código]
Loop
Ou se você preferir, da seguinte maneira:
Do
[Bloco de Código]
[Exit Do]
[Bloco de Código]
Loop [{While I Until} Expressão]
Detalhes:
· Expressão - É qualquer expressão numérica ou de string avaliada

pelo Do While / Do Until. Utilizando o comando While o bloco de
código associado ao loop é executado enquanto a expressão definida
for verdadeira. Quando isto não mais ocorrer, o Visual Basic passará o
controle do programa para instrução imediatamente seguinte à
instrução Loop estrutura de controle. Já, utilizando a sintaxe Do Until,
o bloco de código será executado até que uma determinada situação
torne-se verdadeira, ou seja, enquanto a expressão especificada for
falsa.
· Exit Do - Você pode interromper a execução do loop através desta

instrução. Ao encontrá-la no meio de seu bloco de código, o loop é
imediatamente interrompido, e a execução do programa passa para a
primeira instrução abaixo do comando Loop. Esta instrução
normalmente está associada à ocorrência de uma determinada
condição lógica.
Descrição:
O funcionamento desta estrutura é bastante simples, mas nem por isso

menos poderosa que as outras instruções que estudamos anteriormente.
Como você já deve ter percebido, existem duas formas de utilizarmos

esta estrutura de controle, de modo que vamos iniciar pela sintaxe Do While
primeiro.
Inicialmente, é feita uma avaliação da expressão associada à instrução

Do While. Se a mesma for verdadeira (resultar em True), o bloco de código
associado a esta instrução é executado. Ao encontrar a instrução loop, o Visual
Basic retorna à linha inicial, onde a expressão lógica é novamente avaliada. Se
a mesma ainda for verdadeira, o bloco de código será executado outra vez, até
encontrar a instrução loop. Isto se repetirá ininterruptamente enquanto a
expressão lógica resultar em verdadeira.
Aliás o nome Do While pode ser traduzido como Faça Enquanto.
O mesmo ocorre com a expressão Do Until, só que de maneira contrária,

já que esta expressão pode ser traduzida como Faça Até .
Neste caso, o bloco de código será executado até que a expressão

avaliada torne-se verdadeira.
Como já dissemos a você, existem duas formas diferentes de utilização

desta estrutura. A primeira, como vimos, parte inicialmente da análise da
expressão antes da execução do bloco de código. Isto significa que, se a
expressão lógica for falsa desde a primeira análise, o bloco de código não será
executado uma vez sequer. Já com a segunda sintaxe, antes de mais nada o
bloco de código será executado, independentemente do resultado da
expressão.
No final do bloco de código, está a instrução Loop While / Loop Until,

associada à expressão lógica.
Mais uma vez, ver na prática é o melhor caminho para entender a
diferença entre ambas estruturas.
Prática 14
Selecione mais uma vez o aplicativo Estruturas de Controle e faça as

seguintes alterações no código associado a este projeto:
Na procedure Form_load( ) altere o código existente para:
LblTítulo.Caption = "DO WHILE" 'Altera o título da janela

TxtPasso.Enabled = False 'Desabilíta a Textbox Passo
LblAção.Caption = "Valor Atual de inicio:" 'Exibe a mensagem indicada
Já para a procedure Btnlniciar_Click faça os seguintes ajustes:

Rem Estudo de Do While
Dim Inicio As integer, Limite As lnteger, Vezes As integer
Início = Txtlnício.TEXT 'lnicializa variável com o valor do controle

Limite = TxtLimite.TEXT 'idem
Vezes = 0 'Inicializa a variável Vezes com zero
LblMsg.Caption = "Enquanto Inicio for menor ou igual a " & Limite & " o
bloco de código será executado!”
Do While Inicio <= Limite
Inicio = Inicio + 1 'lncrementa a variável Início

Vezes = Vezes + 1 'lncrementa a variável Vezes
TxtValorAtual.TEXT = Início
TxtAção.TEXT = "Executando o bloco de código pela " & Vezes &

"a . vez”
TxtAção.Refresh 'Atualíza o controle
For n = 1 To 100000
Next
Loop
Rem Depois de executar o loop, o controle do programa

TxtAção.TEXT = "0 bloco de código foi executado " & Vezes & "
vezes!"
Execute o aplicativo e veja o que ocorre.
A princípio, não existe muita diferença entre o comando For Next e a

rotina que acabamos de desenvolver se você observar apenas a tela de
resultados, mas lembre-se de que enquanto o For Next repete um bloco de
código um determinado número de vezes, o comando Do While repete este
mesmo bloco até que uma determinada condição seja atingida ou enquanto
determinada situação for verdadeira.
Faça agora duas pequenas alterações no código associado ao botão

"Iniciar" para vermos na prática esta condição. Altere a seguinte linha do seu
código:
De:
LblMsg.Caption = "Enquanto Inicio for menor ou igual a " & Limite & " o
bloco de código será executado!"
Para:
LblMsg. Caption = "Enquanto Inicio for maior que " & Limite & " o bloco
de código será executado!"
Aproveite para alterar as seguintes linhas também:
De:
Do While Inicio <= Limite
Inicio = Inicio + 1 'lncrementa a variável Início
Para:
Do While Inicio > Limite
Inicio = Início - 2 'Decrementa a variável Inicio
Execute novamente o aplicativo e entre com os valores 20 e 10.
Utilizando a Segunda Sintaxe Do While
Como já havíamos adiantado no início deste módulo, você tanto pode

definir que o bloco de código associado à instrução Do While seja executado
somente se a expressão de controle for verdadeira, ou mesmo que o bloco de
código seja executado uma única vez antes de avaliarmos a expressão de
controle.
Você perceberá a diferença da seguinte forma:
Execute o aplicativo que alteramos no item anterior e entre com os
valores 20 e 20 nas respectivas caixas de texto. Você receberá a mensagem
que o bloco de código não foi executado uma única vez sequer.
Isto ocorre porque a avaliação da expressão Início > Limite resulta em

False, já que 20 não é maior do que 20. Neste caso, o Do While passa o
controle do programa para a instrução imediatamente seguinte ao comando
Loop.
Faça uma pequena alteração no seu código, de modo a deixar a

avaliação da expressão para depois da execução do loop. Para fazer isto basta
transferir a palavra While e a expressão associada a esta da linha que contém o
Do para a linha Loop:
Do
Inicio = Inicio - 2 'Decrementa a variável inicio
Vezes = Vezes + 1 ‘Incrementa a variável Vezes
TxtValorAtual.TEXT = Inicio
TxtAção. TEXT = "Executando o bloco de código pela " & Vezes &
"a. vez’
TxtAção.Refresh ‘Atualiza o controle
For n = 1 To 100000
Next
Loop While Inicio > Liniite
Reexecute o aplicativo e torne a entrar com os valores 20 e 20.
Note que desta vez o bloco de código foi executado pelo menos uma vez
antes que o Visual Basic avaliasse a expressão lógica definida por nós. Após a
avaliação da expressão (que resultará em False), o Visual Basic não mais
executará o loop, passando para a próxima instrução da rotina.
4.7 A Estrutura Do Until
Como já havíamos antecipado a você, a diferença entre o Do Until e o Do

While é o modo com que a estrutura avalia a expressão lógica associada à
mesma. No caso do Do Until, o Visual Basic executará o bloco de código
enquanto o resultado da expressão avaliada for False. Quando o mesmo se
tornar verdadeiro (True), o Visual Basic encerra a execução do bloco de código.
Prática 15
Vamos aproveitar parte do código que utilizamos para estudar o Do

While, fazendo apenas algumas rápidas modificações.
Rem Estudo de Do Until
Dim Inicio As lnteger, Limite As Integer, Vezes As lnteger
Inicio = Txtlnício.TEXT 'Inicializa variável com o valor do controle

Limite = TxtLimite.TEXT 'Idem
Vezes = O 'lnicializa a variável Vezes com zero
LblMsg.Caption = “Enquanto Início for menor que “ & Limite &” o bloco de
código será executado!”
LblMsg.Refresh 'Atualíza o controle LblMsg
Do Until Início > Limite

Início = Início + 1 'íncrementa a variável Início
Vezes = Vezes + 1'lncrementa a variável Vezes
TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & "
a .vez"
For n = 1 To 100000
Next
Loop
TxtAção. TEXT = "0 bloco de código foi executado " & Vezes & " vezes! "
End Sub
Faça também um rápido ajuste na rotina Form-load( ), alterando a seguinte

linha:
LblTítulo.Caption = "DO UNTIL" 'Altera o título da janela

Ponha seu programa para rodar e entre com os valores 1 e 10. Note que o
resultado da expressão Inicio > Limite com estes valores será False, já que 10 é
menor que 20. Mesmo assim o VB executará o bloco de código, sendo que só
deixará de fazê-lo quando a expressão tornar-se verdadeira, ou seja, quando o
valor de início for igual a 21, que por sua vez tornará a expressão avaliada
verdadeira (21 > 20).
Se você entrar com os valores 25 e 20, por exemplo, o Visual Basic não
executará uma vez sequer o bloco de código, pois desde o início a avaliação da
expressão associada ao Do Until resulta em Verdadeiro.
Para garantir que seu bloco de código será executado pelo menos uma vez,
faça as seguintes alterações no Código de seu aplicativo:
Do
Início = Início + 1 'lncrementa a varíável início
Vezes = Vezes + 1 'lncrementa a variável vezes
TxtValorAtual.TEXT = Início
TxtValorAtual.Refresh 'Atualíza o controle
TxtAção.TEXT = "Executando o bloco de código pela “ & Vezes &

“ a. vez 11”
For n = 1 To 100000
Next
Loop Until Início > Limite
Agora é só executar o programa novamente com os valores 25 e 20 e ver

o resultado obtido.
Saindo do Loop com Exit Do
Como já vimos anteriormente, você pode encerrar a execução de um loop

a qualquer momento através da palavra de comando Exit.
A estrutura Do While/Do Until não é exceção, pois também permite que

você utilize este recurso sempre que necessitar interromper a execução de um
loop qualquer.
Aproveite o último exercício que criamos e acrescente as seguintes

linhas antes da instrução Loop Until Início > Limite:
if Início = 15 Then
Exit Do
End íf
Execute novamente o seu aplicativo e entre com os valores 1 e 20 para

ver o que ocorre.
Assim que a variável Início atingir o valor predeterminado, o loop será
encerrado, e o controle do programa passará para a próxima linha abaixo da
instrução Loop.
Note que não existe um número limite para o uso de instruções Exlt Do,
ou seja, você pode utilizar esta declaração quantas vezes necessitar, como por
exemplo no código abaixo:
Do
Inicio = Inicio +1 'lncrementa a variável Início
lf Início = 15 Then
Exit Do
Elseif Início = 1 And seleção = False Then
Exlt Do
Elseif Início = 1 And Teste = 20 Then
Exit Do
End lf
Loop Until Inicio > Limite
Vamos aprender agora uma nova estrutura de controle bastante parecida

com a estrutura Do Loop que acabamos de estudar, a While... Wend.
4.8 While Wend
Este comando repete a execução de um determinado bloco de código

enquanto uma determinada condição for verdadeira.
Este comando possui a seguinte sintaxe:
While condição
[Bloco de Código]
Wend
Detalhes:
· Condição - É qualquer expressão numérica ou de string avaliada pelo

While.
Descrição:
O funcionamento desta estrutura é bem simples: se a condição

especificada for verdadeira, o Visual Basic executará o bloco de código
associado à estrutura.
Ao atingir a declaração Wend, o Visual Basic retoma à primeira linha da

estrutura e reavalia a expressão. Se a mesma ainda for verdadeira, o Visual
Basic repetirá a execução do código, reiniciando o processo ao alcançar o
Wend. Quando esta condição de controle tornar-se falsa, a execução do loop
será interrompida, e o controle do programa passará para a linha imediatamente
seguinte ao Wend.
Apesar da simplicidade desta estrutura de controle, você deve

preferencialmente utilizar-se da estrutura Do Loop, já que a mesma oferece uma
maior flexibilidade na criação de loops, através da possibilidade de encerrá-los
a qualquer momento.
Na estrutura While... Wend não existe o comando Exit.
O problema é que se você definir uma expressão de controle que nunca

resultará em False, seu aplicativo será executado indefinidamente, já que não
há a possibilidade de utilizar um comando Exit para encerrá-lo após um
determinado número de execuções, ou da ocorrência de alguma condição que
indique a anormalidade na execução do código.
Caso você tenha interesse em ver na prática como esta estrutura de

controle se comporta, faça as seguintes alterações no código de seu aplicativo:
Rem Estudo de While... Wend
Dim Início As lnteger, Limite As lnteger, Vezes As lnteger
Inicio = TxtInício.TEXT 'lnícialíza varíável com o valor do controle

Limíte = TxtLimite.TEXT 'Idem

Vezes = 0 'Inicializa a variável Vezes com zero
LblMsg.Caption = "Enquanto Início for menor que " & Limite & ", o bloco
de código será executado!"
While Início < Limite

lnício = Inicio + 1 'lncrementa a variável
TxtAção.TEXT = "Executando o bloco de código pela " & Vezes & "
a .vez"
For n = 1 To 100000
Next
Wend
Rem Depois de executar o loop o controle do programa

TxtAção.TEXT = "0 bloco de código foi executado " & Vezes & "
tezes! "
End Sub
Só para deixar bem documentado o que você está fazendo, altere a

rotina Form-load( ) conforme a seguir:
LblTítulo.Caption = "WHILE" 'Altera o título da janela
Execute o seu aplicativo e repare que ele funciona de maneira idêntica à

estrutura Do Loop que estudamos anteriormente.
4.9 Utilizando Funções

Nesta seção, aprenderemos o que são Funções e como utilízá-Ias em

nossos aplicativos. Aprenderemos também o que são argumentos e valores de
retomo de funções, além de vermos uma listagem completa das funções
disponíveis no Visual Basic agrupadas de acordo com a sua finalidade.
O Que São Funções ?
As funções nada mais são do que um determinado tipo de rotina

(procedimentos) que realiza tarefas específicas dentro de seu aplicativo,
retomando ao aplicativo um determinado valor resultante ou não da execução
destas tarefas.
Basicamente, as funções dividem-se em dois tipos distintos:
· Funções definidas pelo usuário, que são as rotinas desenvolvidas por você
de acordo com as suas necessidades.
· Funções internas do Visual Basic, que foram criadas pela própria equipe de
desenvolvimento do Software na Microsoft.
Nesta seção, aprenderemos sobre as funções internas do Visual Basic,

ou seja, sobre aquelas funções que já estão prontas para serem utilizadas por
você, não necessitando de nenhuma programação adicional.
Como já adiantamos a você, as funções internas realizam tarefas

bastante específicas, que podem ser agrupadas em várias categorias conforme
a sua finalidade.
Entre as várias categorias existentes podemos citar como exemplo as

funções matemáticas, financeiras, de data, de manipulação de strings,
ambientais, de conversão, etc.
Por que Utilizar Funções?
A grande vantagem da utilização das funções é permitir o

reaproveitamento de determinadas partes seu código, evitando que você tenha
que repeti-Ias mesmas várias vezes dentro de seu programa.
Isto evita que o seu aplicativo fique enorme devido à repetição de várias
linhas de código sem necessidade, bem como diminuir a possibilidade de
ocorrerem erros, já que com menos linhas seu código ficará mais fácil de ler e
de depurar. Além disso, se uma função foi criada e testada adequadamente, as
chances da mesma apresentar algum problema no futuro são praticamente

nulas ou muito reduzidas, dando uma maior confiabilidade à sua aplicação.
Outra vantagem a ser destacada é que a manutenção de seu código
ficará bem mais fácil, pois ao invés de corrigir linhas e linhas de comandos
basta revisar apenas a função que sofreu alterações para atualizar todo o seu
código de uma só vez.
Outra vantagem indiscutível das funções é a maior facilidade na criação

de suas aplicações, pois permite que você utilize não só as funções internas do
Visual Basic, mas também as funções desenvolvidas por você e mesmo por
outros programadores, resultando numa maior produtividade por parte do
programador.
Aliás foi pensando nisso que a Microsoft desenvolveu as funções

internas do VB, poupando o seu trabalho de criação de funções básicas como
as que retomam a data e hora do sistema ou de funções complexas, de difícil
criação, como as que calculam valores de Seno e Cosseno, por exemplo.
Utilizando as Funções Internas do Visual Basic
A utilização das funções internas do Visual Basic é bastante simples,

basta observar as informações (argumentos) que você deve fornecer ou não à
função a ser utilizada.
Você pode utilizar as funções internas do Visual Basic simplesmente

declarando o nome da função desejada dentro de suas rotinas, como por
exemplo, no código a seguir:
Valor = Date
Neste caso, Valor é uma variável que receberá uma resposta vinda da
função Date.
O único cuidado a ser tomado na utilização das funções é verificar se a

função desejada necessita ou não de alguma informação adicional (chamada de
argumento pelo VB) para conseguir realizar as tarefas às quais esta se propõe.
Repare que nem todas as funções internas do VB exigem que você forneça esta
informação adicional, sendo que para muitas delas basta incluir seu nome na
linha de comando como fizemos no exemplo anterior.
Vamos aprender agora um pouco mais sobre o que são argumentos e

sua utilização.
Argumentos de Funções
O argumento é uma variável, constante ou mesmo uma expressão que

você precisa informar à função para que ela possa executar a tarefa à qual se
propõe.
Um exemplo de função que necessita de argumento é a função que

calcula o Cosseno de um determinado ângulo. Neste caso, você deve
obrigatoriamente informar o valor do ângulo a ser calculado, como no exemplo a
seguir:
Valor = Cos(0,785)
Note que neste caso o argumento deverá ser informado entre

parênteses, logo após o nome da função.
O tipo de dado de argumento varia conforme a função escolhida, sendo

que ele tanto poderá ser do tipo de dados numérico, data, string, lógico, etc.
Valores de Retorno
Toda função sempre apresenta um valor de retorno, que nada mais é do

que o resultado final obtido após a sua execução.
Para que entenda melhor, imagine que você necessita calcular a raiz
quadrada de um número qualquer como 16, por exemplo. Você pode fazer isto
no Visual Basic através da função Sqr (de square), bastando para isso fornecer
como argumento o valor a ser calculado, de forma que nossa função ficaria
igual a Sqr(16). Como todos nós sabemos, a resposta encontrada por esta
função será o valor 4. Mas fica uma dúvida, como o Visual Basic nos indicaria
que esta foi a resposta encontrada?
Como já havíamos adiantado a você, a resposta para esta pergunta é o

Valor de Retomo. Isto que dizer que sempre que você utilizar uma função
qualquer para a realização de urna tarefa, deverá associá-la a uma variável de
memória ou controle de seu formulário, de modo a ter um lugar determinado
para receber o valor retomado pela função.
4.10 Funções Internas do Visual Basic 4.0
Funções Matemáticas
Abs Retorna o Valor Absoluto de um Número

Atn Calcula o Arco Tangente de um Número
Cos Calcula o Cosseno de um Número
Exp Retorna o Valor de e Elevado a uma
Potência
Fix Retorna a Parte Inteira de um Número
Int Retorna a Parte Inteira de um Número
Log Calcula o Logaritmo Natural de um
Número
Rnd Retorna um Número Aleatório
(Randômico)
Sgn Retorna um Inteiro Conforme o Sinal do
Número
Sin Calcula o Seno de um número
Sqr Calcula a Raiz Quadrada de um Número
Tan Calcula a tangente de um Número
Funções de Data e Hora
Date Retorna a Data Atual do Sistema

DateAdd Retorna a Data Especificada Acrescida
do Intervalo de Tempo Informado
DateDif Retorna o Intervalo ed Tempo Decorrido
entre Duas Datas Especificas
DatePart Retorna a Parte Especificada de uma
Determinada Data
DateSerial Retorna uma Data para o Ano, Mês e
Dia Especificados
DateValue Retorna uma Data a Partir de uma Data
na Forma de String
Day Retorna o Número do Dia de uma Data
(de 1 a 31)
Format Formata uma Expressão de Acordo com
as Instruções Definidas pelo Usuário
Hour Retorna o Número da Hora (0 a 23) de

uma Determinada Hora Especificada
Minute Retorna o Número de Minutos da Hora
Especificada (0 a 59)
Mounth Retorna o Número do Mês de uma
Determinada Data (1 a 12)
Now Retorna a Data e Hora Atuais do seu
Sistema
Time Retorna a Hora Atual do Sistema

Timer Retorna o Número de Segundos
Decorridos desde 0:00h (de 0 a 59)
Weekday Retorna o Número do Dia da Semana (1
- Domingo, ..., 7 - Sábado)
Year Retorna o Número do Ano de uma
Determinada Data
Funções de Sistema Operacional
Command Retorna o Argumento Informado na

Linha de Comando Utilizado na
Inicialização do Visual Basic ou de um
Programa Executável Desenvolvido pelo
mesmo
CreateObject Cria um Objeto OLE
CurDir Retorno a Pasta (ou diretório) Atual
Dir Retorna o Nome do(s) Arquivo(s) ou
Diretório(s) que combina(m) com o
Padrão Especificado ou Atributo de
Arquivo, ou Volume de um Drive
DoEvents Interrompe Momentaneamente a
Execução de seu Aplicativo para que o
Sistema Operacional possa Processar
outros Eventos
Enviroment Retorna a String Associada a uma
Variável de Ambiente do Sistema
Operacional (como Path e Prompt, por
exemplo)
Error Retorna a Mensagem de Erro que
Corresponde a um Dado Número de
Erro
GetObject Recupera um Objeto OLE de um Arquivo
InputBox Exibe uma Caixa de Dialogo para que o
Usuário possa Digitar uma Resposta
Qualquer. Após Escolher um dos Botões

Disponíveis, o VB Retorna o Valor
Digitado
LoadPicture Carrega uma Imagem dentro de uma
Objeto Form Object, Controle
PictureBox ou Controle Image
MsgBox Exibe uma Mensagem em um Quadro
de Dialogo e Espera que o Usuário
Escolha um dos Botões Disponíveis.
Após a Seleção, o VB retorna um Valor
Indicando o Botão Escolhido
QBColor Retorna o Valor da Cor RGB
Correspondente ao Número de Cor
Informado
RGB Retorna um Número Representando
uma Cor do Padrão RGB
Shell Indica a Execução de um Programa
Qualquer
Spc Utilizada com o Comando Print # ou
com o Método Print para Posicionar a
Saída de uma Expressão Qualquer
Tab Utilizada com o Comando Print # ou
com o Método Print para Posicionar a
Saída de uma Expressão Qualquer
4.11 Procedimentos
Nesta seção, aprenderemos o que são procedimentos, seus tipos e como

e onde criá-los.
Veremos também como os mesmos podem aumentar em muito a nossa
produtividade no desenvolvimento de aplicativos em Visual Basic.
Qualquer necessidade de informações adicionais consulte as referências
citadas na Bibliografia Básica.
O que são Procedimentos ?
Os Procedimentos (ou Procedures) nada mais são do que uma

determinada seqüência de comandos que são executados de uma só vez ao
serem chamados, operando como um bloco de código para o aplicativo.
As funções que estudamos na seção anterior não deixam de ser

procedures, pois apesar de você não poder ver o seu conteúdo, elas executam
vários comandos internamente para realizarem as tarefas às quais as mesmas
se propõem.
Qual a Diferença entre Procedimentos Sub e Function?
A diferença básica entre estes dois tipos de procedimentos é que os

procedimentos Function podem retomar valores para o aplicativo que solicitou a
execução do procedimento, enquanto os procedimentos Sub não retomam
valores.
Na seção anterior, você viu que ao chamarmos a função Date, obtivemos

como resposta a data atual do sistema, sendo que esta resposta foi
armazenada em uma variável de memória. Esta função poderia ser chamada
em um procedimento como este:
Private Sub BtnExecutar Click( )
Dim Valor As Date
Valor = Date 'Função Date

TxtEntrada. TEXT = "Função Date"
TxtResultado. TEXT = Valor
BtnExecutar.Enabled = False 'Desabilita o botão Executar
BtnLimpar.Enabled = True 'Habílita o botão Limpar
End Sub
Neste caso o valor de retorno da função Date foi armazenado na variável

de memória Valor.
Se você tentasse fazer o mesmo corn uma procedure Sub, receberia a
seguinte mensagem de erro do Visual Basic:
Expested Function or variable
Isto ocorre pois quando você atribui uma procedure a uma variável de
memória como em
NovoValor = Calculaldade(“12/03/65")
você está indicando ao Visual Basic que CalculaIdade é uma procedure do tipo
Function, e que o valor de retorno gerado pela mesma será armazenado na
variável de memória NovoValor.
Agora que você já sabe a diferença básica entre estes dois tipos de
procedimento, vamos relembrar um pouco quais as vantagens de utilizarmos
estes componentes em nossos aplicativos:
Porque Utilizar Procedimentos ?
Já falamos um pouco sobre a vantagem da utilização das funções no dia-

a-dia do programador, mas tendo em vista apenas as funções internas do Visual
Basic. (Abordaremos os procedimentos desenvolvidos pelo usuário, também
conhecidos como UDF (de User Defined Functions) ou funções definidas pelo
usuário (isto no caso das funções) nos exercícios práticos.
Basicamente, existem três grandes vantagens em utilizarmos os

procedimentos em nossos aplicativos:
1. A primeira grande vantagem é a possibilidade de reaproveitarmos rotinas

criadas anteriormente por nós (ou por outros) no desenvolvimento de novas
aplicações, poupando com isso tempo e esforço. Você pode aproveitar
Funções e Subs que realizará tarefas bem específicas (como um cálculo
científico bastante complexo) já existentes em outro aplicativo desenvolvido
por você, ou mesmo criadas por algum colega que seja especialista no
assunto. Neste caso, o único cuidado a ser adotado por você é fornecer os
argumentos corretamente e saber o que esperar como resposta.
2. Outra vantagem indiscutível é a possibilidade de modularização de seu

código, tornando mais legível e menos sujeito a erros. A modularização
permite que você divida tarefas complexas em pedaços menores, como as
Funções ou Subs. Desta forma, quando você tiver a certeza de que um
determinado procedimento está operando corretamente, menores serão as
chances de ocorrerem erros de processamento em seu aplicativo.
3. Como vantagem adicional poderíamos citar a possibilidade de um programa

ser desenvolvido por mais de um programador ao mesmo tempo. Basta
definir que tarefas cada função deverá realizar, os dados que cada uma irá
utilizar na entrada e a resposta que deverá ser obtida. Então, é só entregar
a tarefa de codificação a cada um dos programadores e unir as Funções e
Subs criadas por cada um deles em um único aplicativo.
Isto significa que você pode padronizar determinados procedimentos

para serem reaproveitados em outros aplicativos, Imagine que você esteja
desenvolvendo um programa para a sua empresa e que normalmente você

necessita calcular a média de dois números, por exemplo.
Ao invés de reescrever as linhas de código que executam esta tarefa em
cada um dos seus aplicativos, você poderia criar uma função que realizasse
esta tarefa e simplesmente copiar o código desta função dentro de cada
aplicativo quando fosse necessário.
Uma solução bastante prática seria criar uma função que recebesse os
dois valores a serem calculados como argumentos, e que a mesma retomasse o
valor resultante do cálculo da média dos dois números. Desta forma você não
precisaria perder tempo definindo variáveis ou tipo de dados, simplificando
bastante o seu trabalho. Um exemplo de como esta função seria utilizada em
seus futuros aplicativos poderia ser a seguinte linha de código:
ValorMedio = CalculaMedia(12,5)
Agora que você já sabe as vantagens que a utilização dos procedimentos

pode trazer aos seus aplicativos, vamos aprender a criar estes componentes na
prática.
Prática 16
Crie um formulário como o da figura abaixo :

Funções
Entrada
Resultado
Executar Limpar
Enabled = False
Nomeie os objetos conforme os label’s fornecidos no layout.
A seguir inclua o código seguinte no evento click do botão executar.
CmdExecutar_click( )
Dim Valor as date
Valor = Txtentrada.Text
TxtResultado.Text = Month(Valor) ‘esta função
retorna a ‘parte da data que diz respeito ao mês
CmdExecutar.Enabled = False
CmdLimpar.Enabled = True
No evento click do objeto botão limpar insira o código:
TxtEntrada.Text = “”
TxtResultado.Text = “ “
CmdLimpar.Enabled = False
CmdExecutar.Enabled = True
Execute a aplicação colocando uma data (D/M/A) no campo de

entrada e pressionando executar.
Prática 17
Vamos ver agora, utilizando o formulário anterior, como funciona a

função DATEDIFF, e como fazemos para criar um procedimento nosso.
Altere o código do evento click do botão executar colocando o

código.
Dim Valor as Date, Retorno as Integer
Valor = TxtEntrada.Text
Retorno = Datediff (“d”, #1/1/95#, Valor) ‘Valor - 1/1/95
TxtResultado.Text = Retorno
CmdExecutar.Enabled = False
CmdLimpar.Enabled = True
Agora digite na parte General (declarations) o seguinte

procedimento
Sub limpar
TxtEntrada.Text = “”
TxtResultado.Text = “ “
CmdLimpar.Enabled = False
CmdExecutar.Enabled = True
End Sub
obs: Digite tudo.
Depois insira a chamada deste procedimento no evento click do

botão limpar.
Sub cdmlimpar_click()
limpar ‘Chamando procedimento limpar
End sub
Execute novamente a aplicação e veja os resultados. Consulte a

tabela de funções e verifique outras funções de manipulação de datas.
Prática 18
Construir um aplicativo VB que calcule a área de uma determinada

figura geometrica. Formulário principal deverá conter o seguinte LayOut :
Cálculo de áreas
Escolha uma Opção

Form
O Cálculo da Área de um retângulo
O Cálculo da Área de uma Circunferência
O Cáluco da Área de um Triângulo

Frame
Termina
Option Control Command
Para cada cáculo de área deverá ser utilizado um formulário separado.
Exemplo : Cálculo da Área do Triângulo

Cálculo da Área de um Triângulo
Forneça :
Base Resultado
Altura
Calcular Voltar
Fórmulas :
Área do Triângulo = (Base * Altura)/2
Área do Retângulo = (LadoA * LadoB)
Área da Circunferência = (P * R2) , com P = 3.1416
Este exercício não possui a resolução na apostila,

tente realmente fazer sozinho!!!
Prática 19
Contruiremos um aplicativo bastante simples que nos ensinará a

trabalhar com o controle Progressbar:
PROGRESSBAR
Crie um formulário com o seguinte conteúdo :
Utilizando PROGRESSBAR
Inicio Fim
Controle
Progressbar
Command
Depois insira o seguinte código na sua aplicação :
CmdInicio_Click( )
Dim I as Integer
For I = 1 to 1000
Progressbar.Value = i / 10
Next I
Cmd_Fim( )
End
Execute sua aplicação e teste novos valores para o laço acima.
Prática 20
Vamos construir um aplicativo que nos ensine a trabalhar com os

controles: Lista de Drivers, Diretórios e Lista de Arquivos.
· objetivo do nosso aplicativo é : o usuário “busca” através dos

controles, um arquivo de figura e após selecioná-lo, o aplicativo
imprimirá a figura em um segundo formulário.
Crie um formulário com os seguintes objetos:
Visualização de Figuras
Visualizar
Encerrar
Drivers Diretórios FileListBox Command
Ajuste as seguintes propriedades aos objetos:
Formulário:
Name FrmLista
Caption visualização de Figuras
Command:
Name CmdEncerrar
Caption Encerrar
Name CmdVisualizar
Caption &Visualizar
Default True
Enabled False
Driver:
Name DrvDrives
Diretório :
Name DirDiretórios
FileListBox :
Name Filarquivos
Pattern *.bmp (ou Icon)
Insira o código:
CmdEncerrar_Click( )
End
CmdVisualizar_Click( )
Dim Arquivo as string

Arquivo = ucase(filarquivos.path + “\”+ Filarquivos.filename)
FrmVisualização.show
FrmVisualização.windowstate = 2
FrmVisualização.caption = ärquivo:”+ arquivo
FrmVisualização!imgfigura.picture = loadpicture(arquivo)
DirDiretórios_change( )
Filarquivos.path = disdiretorios.path
CmdVisualizar.Enable = false
Drvdrives_change( )
Dirdiretorios.path = Drvdrives.drive
Cmdvisualizar.enable = false
Filarquivos_click( )
Cmdvisualizar.enabled = true
Depois disso abra um novo formulário com a seguinte forma:
Image
Retorna
Command
Propriedades:
Formulário:
Name FrmVisualização
Image :
Name ImgFigura
Command:
Name Cmdretorna
Caption &Retorna
Default True
Depois disto, insira o seguinte código no procedimento

CmdRetorna_Click():
FrmVisualização.WindowState = 0
Unload FrmVisualização
Prática 21
Vamos aprender agora como trabalhar com os controles de barras

verticais e horizontais (Controles ScrollBar).
Crie um formulário com os seguintes objetos :
Animação
Controle Image
(Situar na
Posição 1800,600)
Controle
Barras
Verticais
Controle
Barras
Horizontais
Propriedades:
Formulário :
Name FrmBarras
BackColor &H00FFFFFF&
Caption Animação(demonstração scrollBar)
ScrollBar Vertical:
Name VscrEixoY
LargeChange 500
Max 2000(tamanho do eixo)
SmallChange 100(grid)
ScrollBar Horizontal:
Name HscrEixoX
LargeChange 500
Max 2000
SmallChange 100
Image:
Name ImgFigura
Picture (Sugestão : Arquivos de
programa1\MicrosoftVisualBasic\Bitmap
s\Assorted\Beany
A seguir insira o código:
HscrEixoX_Change( )
ImgFigura.Left = 1300 + HscrEixoX.Value
End Sub
VscrEixoY_Change( )
ImgFigura.Top = 600 + VscrEixoy_value
End Sub
Execute a aplicação e faça alterações nas propriedades dos

controles de barra para melhor compreendê-los.
Módulo 5
Criando Menus
Personalizados
Neste módulo, aprenderemos a melhorar ainda mais a interface de nossa

aplicação com usuário , desenvolvendo menus personalizados para a execução
de tarefas
5.1 Incluindo Menus em nossa Aplicação
O Menu Editor
Criar menus de comandos no Visual Basic é bastante simples, pois o

Menu Editor encarrega-se da parte gráfica, que sem dúvida alguma é a parte
mais trabalhosa.
Você praticamente só irá definir os nomes dos menus, os comandos que

cada um conterá e os procedimentos que serão executados quando o usuário
selecionar uma das opções disponíveis no mesmo.
O Menu Editor não aparece na caixa de ferramentas junto com os demais
controles, mas sim na barra de ferramentas do VB.
Selecione o ícone correspondente ou a opção Menu Editor no menu
Tools.
5.2 Criando uma Barra de Menu
Da mesma forma que nunca devemos iniciar a criação de um aplicativo

sem termos uma idéia bem-definida do que queremos que ele faça, também no
caso dos menus é necessário ter em mente as opções que queremos que ele
assuma, e os comandos que serão executados quando estas opções forem as
escolhidas.
Também será necessário definirmos se determinadas opções do menu

ficarão desabilitadas quando determinados comandos estiverem sendo
executados pelo usuário. Tudo isso deverá estar definido antes de iniciarmos o
trabalho de criação dos menus, a fim de evitarmos erros de concepção em
nosso projeto.
O primeiro passo para criarmos urn menu é definirmos onde ele será
incluído. Vamos abrir um novo projeto e deixar um formulário como a janela
ativa do VB.
O próximo passo a ser dado é definir o nome que o nosso menu terá, ou
seja, o nome que será exibido na barra de menu de nosso aplicativo. Em nosso
exemplo, queremos que o primeiro menu a ser exibido tenha o nome de Arquivo.
Este nome deverá ser incluído na caixa de texto Caption do Menu Editor.
Lembre-se de que sempre que você inclui o símbolo “&” antes de uma
letra, ela é exibida no menu (ou controle) sublinhada, indicando que você pode
acessá-la através da combinação de teclas ALT mais a letra destacada.
Em nosso caso, as tecias ALT+A abrirão o menu Arquivo que estamos

criando.
Você também pode definir um nome para este menu. Da mesma forma
como você faz com os controles de seu aplicativo, também é possível
ajustarmos propriedades dos menus durante a execução de seu programa,
habilitando e desabilitando opções, modificando nomes, etc.
Este nome não aparece na tela, serve apenas para ser utilizado pelo seu
código. Da mesma forma como já fizemos com vários controles de seu
aplicativo, procure utilizar-se das letras mnu antes do nome do controle, a fim
de facilitar o seu trabalho de codificação.
Dê o nome de mnuArquivo para este controle e pronto, nosso menu já
está criado, só que sem nenhum comando ainda. Por enquanto você só criou a
palavra Arquivo no alto de sua tela.
Clique sobre o botão "OK" para fechar o Menu Editor e veja que o menu
já foi incorporado ao seu formulário.
Coloque o seu aplicativo em execução e veja que o VB inclui o menu

Arquivo, porém ele está vazio, isto é, não possui nenhum comando.
Pare a execução do aplicativo e abra novamente o Menu Editor.
5.3 Adicionando Itens em um Menu

Vamos incluir um ítem em nosso menu Arquivo. Clique sobre o botão

“Next” (dentro da janela de Menu) e veja que o VB inclui uma nova linha em
branco logo abaixo do menu existente, além de limpar os dados da janela.
Vamos incluir mais um ítem no menu Arquivo, desta vez o comando Sair,
que encerrará a execução de nosso aplicativo.
Abra novamente o Editor de Menus e clique sobre a opção Abrir. A
seguir, clique novamente sobre o botão "Next" para iniciar uma nova opção de
menu e digite o comando &Sair.
Passe para a caixa de texto Name e dê o nome de MnuArquivoSair para
este comando. Note que desta vez não é necessário dar um nível para a direita
ao comando Sair, pois o VB assume que você está indo na seqüência de
criação do menu Arquivo.
Feche a janela com o botão “OK” e dê uma olhada com está ficando o
seu menu. Realmente está ficando muito bom!
Só para você ter uma idéia melhor de como funcionam os níveis, abra
novamente o Editor de Menus e dê mais um nível para a direita no item Sair.
Feche a janela do Editor e veja que o VB criou um submenu dentro do

menu Arquivo.
O VB permite que você crie até quatro níveis de submenus em seus

aplicativos, que cá entre nós, é mais do que suficiente para a maioria das
aplicações.
Apesar de termos citado no início deste módulo

que os menus são importantes recursos para tornar
sua aplicação amigável, é bom evitar exageros.
Nada é mais cansativo do que ter que abrir três
ou quatro menus em cascata até encontrar o
comando desejado. O ideal é utilizar menus
com no máximo dois níveis hierárquicos.
Utilize agora o botão com a seta para a esquerda para retomar a opção
Sair à sua Posição original.
5.4 A Posição dos Itens no Menu

Você pode alterar facilmente a posição de um item no menu através das

setas que apontam para cima e para baixo.
Basta destacar o comando a ser movido e escolher o botão adequado.
5.5 Incluindo novos Itens
Você pode incluir novos itens em um menu, simplesmente escolhendo o

botão "lnsert". Basta selecionar um comando do menu e clicar sobre este
botão. O VB deslocará o comando selecionado (e todos os abaixo deste) em
uma linha, e você poderá incluir o novo comando em sua posição. Faça isso
agora, selecionando o comando Sair com um clique e escolhendo o botão
"Insert ".
Dê o Caption de &Imprime a este botão e o Name de

MnuArquivoImprime.
Não se preocupe com este comando, pois vamos apagá-lo em seguida
inclua mais um comando entre as opções Imprime e Sair, chamado de
Ferramentas. Ajuste as suas propriedades conforme a seguir:
Caption: &Ferramentas
Name: MnuArquivoTools
5.6 Exibindo Separadores
Você já deve ter notado que determinados menus possuem linhas

separando os seus diversos itens, tornando-os mais organizados. Aliás, quase
todos os menus do VB possuem um separador de itens, que nada mais é do que
uma linha que atravessa o menu de lado a lado.
Você também pode incluir este recurso em seus menus bastando para isso
digitar na caixa de texto Caption um hífen (-).
Faça isso agora, selecionando o comando Sair com um clique e

escolhendo a seguir o botão "lnsert", como você já sabe, será incluída uma nova
opção entre os comandos lmprime e Sair. Digite o sinal - na caixa de texto
Caption e dê o nome de MnuSeparador para este controle.
Feche o Menu Editor e veja o resultado obtido.

Procure agrupar os comandos de

seus menusdentro de uma determinada
lógica. Observe como os produtores de software
organizam seus menus, separando as operações de acordo
com a finalidade das mesmas. Isto ajuda muito o usuário
e até mesrno quem desenvolve, poistodos os comandos
relacionados a uma determinada tarefa ficam juntos,
permitindo a sua rápida localização.
5.7 Eliminando Itens do Menu
Tão fácil quanto incluir é eliminar itens do menu.

Selecione o comando Imprime com um clique e em seguida escolha o
botão "Delete". O item selecionado será eliminado do menu, e todos os itens
serão reaiocados em suas novas posições.
5.8 Criando outro Menu

Bem, até agora criamos o menu Arquivo e alguns itens debaixo do
mesmo. Mas, e como podemos criar um novo menu, como um menu Ajuda
(Help), por exemplo?
Bem, o procedimento é o mesmo. Selecione o último comando do menu

Arquivo (o comando Sair) e clique sobre o botão "Next". Como lhe dissemos, o
VB assume que você pretende continuar criando comandos para o menu
arquivo e obedece ao último nível existente.
Neste caso, você pode comunicar ao VB que está criando outro menu,
simplesmente utilizando-se da tecla com a seta para a esquerda, aumentando o
nível do menu. Então é só complementar as informações que você deseja.
Entre com os seguintes dados:
Caption: A&juda
Name: MnuAjuda
Inclua logo abaixo deste item (porém num nível inferior) o comando
Sobre com as seguintes especificações:
Caption: S&obre
Name: MnuAjudaSobre
Pronto, já temos dois menus distintos criados.
Vamos Incrementá-los um pouco, utilizando mais alguns recursos

existentes no Menu Editor.
5.9 Teclas de Atalho
Você já viu que basta utilizarmos o sinal “& antes de uma letra de um
nome ou comando para criar uma tecla de atalho. Só que esta combinação de
teclas que criamos refere-se somente ao acionamento da barra de menus. Você
também pode utilizar o Menu Editor para definir teclas de atalho que executem
tarefas, sem a necessidade de acionamento dos comandos via menu.
Um exemplo é o próprio Visual Basic., você pode abrir um projeto

existente utilizando a combinação de teclas ALT+F (abre o menu File) e em
seguida teclando “O” (de Open Project) ou sem ter que abrir nenhum menu
através da combinação de teclas CTRL+O.
Note que por coincidência, as duas letras são iguais, mas isto não é uma
regra obrigatória. Você pode observar isto no menu Tools, na Opção Menu
Editor. Note que a combinação de teclas para este comando é CTRL+E, e não
CTRL+M como pode parecer.
Repare ainda que a combinação de teclas de atalho é exibida no próprio
menu ao lado do nome do comando.
Vamos fazer isto agora, atribuindo a combinação de teclas CTRL+A à
tarefa de abrir um arquivo.
Selecione o comando Abrir no Menu Editor e clique sobre a caixa de

listagem Shortcut (atalho).
Em nosso caso, vamos selecionar a combinação CTRL+A (de Abrir).
Note que não é necessário efetuar nenhum outro ajuste em seu aplicativo
para que as teclas de atalho entrem em operação. Basta definir a procedure que
está associada ao comando do seu menu e sempre que você acionar as teclas
combinadas, o VB chamará automaticamente o procedimento correto. Perceba
que a sua escolha passou a ser exibida no menu Arquivo, orientando o usuário
sobre a nova possibilidade.
Uma boa regra para a definição de teclas de atalho é procurar

associá-las com o nome da tarefa a ser executada. CTRL+A para Abrir um
arquivo, CTRL+S para Salvar, CTRL+I para Imprimir, e assim por diante.
Outra sugestão é procurar definir as mesmas

letras tanto paras as teclas de atalho como para as
opções dos menus. Note que é mais fácil associar Salvar
com CRTL+S e Imprimir com CTRL+I, por exemplo,
do que Imprimir com CTRL+P (de Print).
5.10 Marcando Opções de Menu
Outro recurso bastante interessante é a característica de acrescentarmos

uma marca (ou check) em uma opção de menu, indicando a sua seleção ou não.
Este recurso é muito utilizado para indicar ao usuário as opções que

estão ativadas ou não no momento, como por exemplo a opção Toolbar do
menu View do Visual Basic.
Se você estiver visualizando a barra de ferramentas do software, a opção
Toolbar estará marcada com o check, indicando a seleção. Se você clicar sobre
este comando do menu novamente, apagará o check, e a barra de ferramentas
deixará de ser exibida na tela. Para tornar a exibi-Ia basta repetir o
procedimento, e a marca voltará a ser exibida ao lado do comando no menu.
No nosso aplicativo, o comando Ferramentas no menu Arquivo utilizará

esta opção. Para isso destaque este comando na janela que mostra a
hierarquia dos menus e clique sobre a caixa de verificação Checked.
Quando você observar o menu Arquivo da próxima vez, verá urna
pequena marca do lado esquerdo do comando Ferramentas, indicando a sua
seleção.
Este recurso é muito interessante para ativar a

exibição de janelas como caixas de Ferramentas,
Paletas de Cores, exibir determinadas informaçõesa
na tela, como a data e hora, por exemplo.
5.11 Desabilitando Opções de um Menu
Você pode criar menus em que determinadas opções estão desabilitadas

inicialmente, e conforme o usuário vai realizando determinadas tarefas, estas
opções de menu vão sendo habilitadas.
Este é um recurso super-importante para facilitar a vida dos usuários do seu

sistema, pois se você deixar todas as opções dos menus habilitadas, pode
haver casos (quase com certeza) que em determinadas situações, podem
causar um erro ou pelo menos não executarem nada, deixando seu usuário
perdido.
Um exemplo seria deixar a opção Imprime habilitada antes de o usuário ter

aberto um arquivo qualquer. Neste caso, ao selecionar o comando Imprime,
como reagiria o seu aplicativo? Por isso procure sempre ir habilitando as
opções, conforme forem surgindo condições para a realização das tarefas
disponíveis nos menus.
Para desabilitar uma opção de menu basta eliminar a marca da caixa de

verificação Enabled do menu Editor. Mais tarde você poderá tornar esta opção
ativa através de suas rotinas de código. Aliás, nós faremos o caminho inverso:
desabilitaremos um comando quando ocorrerem determinadas condições em
nosso aplicativo.
5.12 Ocultando Opções
Outro recurso disponível é a capacidade de ocultarmos comandos em

nossos menus, ou seja, o comando existe, tem suas propriedades definidas,
está associado a um evento, porém não aparece no menu.
Quando for o momento adequado, você altera a sua propriedade Visible e

ele reaparece no menu, estando pronto para ser utilizado.
Isto é muito comum em aplicativos bem-planejados, como o Word, por

exemplo. Se você fechar todas as janelas de documento abertas, o menu
arquivo do Word exibirá quatro ou cinco opções de comandos. Se você abrir
um arquivo qualquer, estas opções aumentam para doze comandos disponíveis!
A grande vantagem deste tipo de recurso é que

você exibe menus inteligentes, que apresentem
somente opções aplicáveis à situação que o usuário
se encontra no momento, tornando seu aplicativo
mais fácil de ser usado pelos usuários.
5.13 Associando Eventos aos Comandos de Menu
Feche a janela do Menu Editor e selecione o menu Arquivo em seu

formulário. Assim que ele for aberto, clique sobre a opção Sair.
O Visual Basic automaticamente abrirá a janela de códigos para que você
crie os procedimentos que farão o seu aplicativo funcionar.
No caso específico da opção Sair do menu Arquivo, queremos que esta
opção execute a tarefa de finalizar a aplicação. Desta forma vamos solicitar ao
VB que execute o comando End quando este comando for selecionado no
menu:
Private Sub MnuSair
End
End Sub
Execute o seu aplicativo e veja que o VB realmente obedece ao comando

do menu.
Módulo 6
Quadros de Diálogo e
Uso de Arquivos
5.1 Criação de Quadros de Lista
Você usa quadros de lista quando tem uma série de escolhas para
apresentar ao usuário e deseja limitar as escolhas. Ao contrário, um quadro
combo é usado mais para escolhas sugeridas; ou seja, os usuários podem
entrar com sua própria escolha no quadro de texto de um quadro combo, se
quiserem.
Digamos, por exemplo, que você tenha uma lista personalizada de
aplicações do Windows, às quais o seu programa consegue iniciar; as escolhas
poderão aparecer em um quadro de lista. Ou então, você pode apresentar as
várias opções de atributo de arquivo (arquivo simples, leitura, escondido etc.)
quando gravar em um arquivo.
Em geral, os quadros de lista podem ser úteis em qualquer lugar onde
existe uma série de escolhas. E como esses quadros de lista podem ter barras
de paginação, o número dessas escolhas pode ser muito maior do que você
pode apresentar em um menu (o que os torna usuais em quadros de diálogo).
Como exemplo, vamos reunir um programa de minibancos de dados. Os

bancos de dados normalmente ordenam seus registros de dados de acordo com
alguma chave. Você pode fazer isso aqui com um quadro de lista. Digamos
que esse programa de bancos de dados deve acompanhar um inventário de
estoque numa farmácia ou na sua gaveta de medicamentos. Você poderia
querer acompanhar coisas como:
Nome do produto
Quantidade do produto
Comentários
Por exemplo, se tivéssemos sete vidros de aspirina, cada um com 100

comprimidos, os dados poderiam ser estes:
Nome do produto: "Aspirina"

Quantidade do produto: "7"
Espaço adicional para comentários: "Vender até quinta-feira."
Cada um desses itens ("Aspirina", "7" e "Vender até quinta-feira.") é

chamado campo em um banco de dados . Juntos, eles compõem um registro.
Para preparar nossa aplicação, podemos incluir um menu à nossa janela
principal, com um item chamado Find Record... [encontrar registro]; quando
selecionado, um quadro de diálogo será aberto com um quadro de lista
mostrando os nomes associados a cada registro - por exemplo, Aspirina,
Bandagem, Creme para Mãos etc.
Dando um duplo clique em um desses nomes, o usuário pode fazer

aparecer o registro correspondente (isto é, o quadro de diálogo desaparece e
os dados do registro são colocados em quadros de texto na janela principal).
Uma das propriedades dos quadros de lista que nos ajudará aqui é a
propriedade Sorted; se for True, o Visual Basic manterá todos os itens no
quadro de lista ordenados alfabeticamente. Em outras palavras, o Visual Basic
cuidará automaticamente da ordenação dos nossos produtos.
Para projetar essa aplicação, inicie o Visual Basic, chame esse projeto de
Database.vbp e dê ao formulário a legenda "Database". Precisaremos de três
quadros de texto nesse formulário principal, que podemos chamar Name,
Number e Comment, aos quais podemos dar os Names NameField,
NumberField e CommentField. De fato, podemos tornar o quadro de comentário
um quadro de texto multilinhas, de modo que possamos armazenar bastante
texto nele. Em seguida, podemos incluir um menu chamado File, com os
seguintes itens:Add Item, Find Item..., Save File.... Load File... e Exit.
Para a primeira escolha de menu, Add Item, vamos usar o Name

AddAnItem (Addltem é uma palavra reservada, como veremos); esse item está
disponível para que o usuário possa preencher o banco de dados.
Depois de editar os três quadros de texto, o usuário poderá selecionar

Add Item para incluir esse dado a um novo registro no nosso banco de dados.
Podemos usar o Name Findltem para a próxima escolha de menu, Find Item ... ;
esse item é aquele que abrirá o quadro de diálogo (o quadro de diálogo conterá
o quadro de lista que mantém os nomes do produto de cada registro, ordenados
alfabeticamente).
Quando o usuário der um duplo clique em um item na lista, o quadro de

diálogo desaparecerá e o registro correto aparecerá na janela principal. Você
aprenderá a incluir o código para os dois itens de menu seguintes, Save File... e
Load File.... neste módulo sobre arquivos. Enquanto isso, dê-lhes os Names
Saveltem e Loadltem.
Vamos escrever primeiro a procedure AddAnltem_Click( ). Acione a

escolha de menu Add Item, abrindo este gabarito de procedure Sub:
Sub AddAnItem_Click( )
End Sub
Quando o usuário acionar Add Item, ele desejará que o conteúdo ativo
dos quadros de texto seja armazenado no banco de dados. Podemos fazer isso
definindo algumas variáveis globais (observe que elas devem ser variáveis
globais, e não em nível de formulário, pois nosso quadro de diálogo um
formulário inteiramente separado - terá que alcançar todas elas) da seguinte
forma em um módulo chamado Database.Bas (Selecione o ícone de inserção de
módulos no toolbar):
Global Names(100) As String

Global Numbers(100) As String
Global Comments(100) As String
Global TotalRecords As Integer
Desse modo, estamos separando espaço suficiente para manter registros

para 100 produtos. Observe também que estamos registrando o número total
de registros em um inteiro global chamado TotalRecords. Agora estamos livres
para preencher esses arrays com dados, pois o usuário colocou os dados de
que precisamos nos quadros de texto da janela principal antes de acionar Add
Item. Ou seja, podemos armazenar dados em nossos arrays de bancos de
dados dessa forma em AddAnItem_Click( ). Observe que incrementamos
TotalRecords primeiro, pois estamos incluindo um novo registro:
TotalRecords = TotalRecords + 1
Names(TotalRecords) = NameField.Text
Numbers(TotalRecords) = NumberField.Text
Comments(TotalRecords) = CommentField.Text
.
.
End Sub
Por exemplo, suponha que estamos para criar o primeiro registro, e estes
são os dados nos quadros de texto da janela principal:
Nome do produto: "Aspirina"
Quantidade do produto: "7"
Espaço adicional para comentários: "Vidros com 100 comprimidos

cada."
Você definiria Names(1) com "Aspirina", Numbers(1) com "7" e

Comments(1) com "Vidros com 100 comprimidos cada.". Agora que
armazenamos os dados, temos que incluir o nome desse produto (Aspirina) ao
nosso quadro de lista organizado em ordem alfabética automaticamente, de
modo que o usuário possa selecionar com facilidade os registros. Fazemos isso
com o método AddItem. Observe que este é um método, o que significa que
temos que conectá-lo ao nome do quadro de lista que queremos mudar. Por
exemplo, podemos chamar de NameList o quadro de lista que mantém todos os
nomes de produto, o que significa que incluiríamos essa linha em
AddAnltem_Click( ):
Numbers(TotalRecords) = NunmberField.Text
Form2.NameList.Addltem NameField.Text
End Sub
Form2 é o nome do segundo formulário, que aparecerá quando o usuário

quiser selecionar um registro. Em geral, é assim que você usa AddItem no
Visual Basic:
formulário.quadro_de_lista.Addltem string$ [índice]
O argumento opcional chamado índice especifica a posição da nova

entrada no quadro de lista, onde 0 (no alto do quadro de lista) é a primeira
posição, a próxima é 1, e assim por diante.
Como nosso quadro de lista será ordenado automaticamente, não

especificaremos um índice para nossas entradas. Em contrapartida, para
remover um item, você poderá usar o método Removeltem:
formuláno.quadro_de_lista.RemoveItem índice
Aqui, um índice não é opcional. Você deverá usá-lo para especificar qual
item na lista deverá ser removido. E isso é tudo para a inclusão de um item.
O passo seguinte é encontrar itens conforme a necessidade. Acione a

escolha de menu Find Item... para fazer surgir este gabarito:
Sub FindItem_Click( )
End Sub
O trabalho real de encontrar um registro será feito pelo segundo

formulário, Form2. Agora podemos mostrá-lo na tela.
Sub FindItem_Click( )
Form2.Show
End Sub
E isso é tudo para Findltem_ Click( ). Vamos projetar agora o quadro de

diálogo chamado Form2.
Crie Form2 acionando o item New Form do menu File do Visual Basic,
dando-lhe uma legenda de Find Item.... Remova os botões Min e Max, dando ao
formulário uma borda fixa por meio da seleção da propriedade Minbotton,
Maxbotton e BorderStyle. Em seguida, crie um quadro de lista acionando a
ferramenta de quadro de lista na caixa de ferramentas. Dê a esse quadro de
lista o Name que já usamos, NameList. Defina a propriedade Sorted para True,
de modo que as entradas nele apareçam em ordem alfabética.
Observe que o Name, NameList, aparece no quadro de lista; ele

desaparecerá em tempo de execução. Não existem barras de paginação nessa
lista, mas elas aparecerão automaticamente se a lista for muito longa para o
quadro.
Agora inclua os dois botões de controle normais para um quadro de

diálogo, OK e Cancel, com os Names OKButton e CancelButton. É sempre bom
tornar o botão OK o padrão (isto é, definir sua propriedade Default para True).
Como antes, é fácil escrever a procedure CancelButton - tudo que precisamos

fazer é esconder Form2 da seguinte forma:
Sub CancelButton_Click( )
Form2.Hide
End Sub
Agora vamos trabalhar com a procedure OKButton_Click( ) do quadro de

diálogo:
OKButton_Click( )
End Sub
Quando o usuário acionar o botão OK - ou der duplos cliques em um item

no quadro de lista, ele terá selecionado um item no quadro de lista, e
deveremos mostrar o registro correspondente.
Então acionar em Aspirina preencherá os quadros de texto da janela

principal com os dados que já armazenamos usando Add Item:
Nome do produto. "Aspirina"

Quantidade do produto: “7"
Espaço adicional para comentários: “Vidros com 100 comprimidos
cada."
Em geral, podemos determinar qual o item selecionado em um quadro de

lista (um item sempre está selecionado em quadros de lista) usando estas
propriedades do quadro de lista:
Text O item atualmente selecionado
List Array de string contendo todos os itens
Listlndex O índice do item selecionado (base O)
ListCount Número total de itens na lista

A propriedade mais usada é Text, um string que mantém o item

atualmente selecionado. No entanto, os outros também são muito úteis (e
poderíamos notar que Text = List(Listlndex)).
No nosso caso, teremos que encontrar o registro correspondente à

seleção e exibi-lo. Podemos encontrar o registro correto com um loop, em
OKButton_click( ), da seguinte forma:
Sub OKButton_click( )
For loop_index = 1 To 100
If Names(loop_index) = NameList.Text Then Exit

For
Next loop_index
.
.
Aqui estamos apenas comparando o nome do produto selecionado com

os nomes de produto de cada registro. Quando encontrarmos o que queremos
(ele deverá estar na lista, pois o quadro de lista simplesmente mostra esses
nomes), saímos do loop com o comando Exit For do Visual Basic. Nesse ponto,
podemos preencher os campos corretamente no formulário principal e esconder
Form2 da seguinte forma:
Sub OKButton_click( )

If (Names(loop_index) = NameList.Text) Then Exit
For
Next loop_index
Form1.NameField.Text = Names(loop_index)
Form1.NumberField.Text = Numbers(loop_index)
Form1l.CommentField.Text = Comments(loop_index)
Form2.Hide
End Sub
Devemos observar que os eventos importantes para quadros de lista são

Click, quando o usuário faz uma seleção, e DblClick, quando o usuário faz uma
escolha. Isso significa que dar um duplo clique em um item é o mesmo que
acionar o botão OK, de modo que podemos incluir a mesma procedure:
Sub NameList_DblClick( )

If (Names(loop_index) = NameList.Text) Then Exit
For
Next loop_index
Form1.CommentField.Text = Comments(loop_index)
Form2.Hide
End Sub
A única coisa restante a fazer é tornar o item Exit ativo no menu da janela
principal, o que fazemos pelo modo comum, com o comando End do Visual
Basic:
Sub ExitItem ( )
End
End Sub
Você irá utilizar o programa acima digitando dados nos quadros de texto
da janela principal. Quando você quiser ler um registro, poderá selecionar Find
Item... no menu File para gerar nosso quadro de diálogo na tela. Selecione o
item no quadro de lista e acione o botão OK, ou então dê um duplo clique no
item do quadro de lista, e os registros desse item aparecerão na janela
principal.
Entretanto, poderíamos observar que tivemos que duplicar o mesmo

código em NameList.DblClick( ) e OKButton_Click( ) - isto é, os dois mostram os
registros do produto selecionado. Uma maneira de evitar isso é colocar esse
código em um módulo, e chamá-lo a partir dessas duas procedures.
Por exemplo, se criássemos uma procedure Sub contendo todo esse

código, chamada GetItem( ), poderíamos mudar NameList.DbiClick( ) e
OKButton_Click( ) para:
Sub NameList.DblClicko
GetItem
End Sub
Sub OKButton_Click( )
Getltem
End Sub
Com GetItem igual a:
Sub Getltem( )
For loop_index% = 1 To 100

If (Names(loop_index%) = Form2.NameList.Text) Then
Exit For
Next Ioop_index%
Form1.NameField.Text = Names(loop_index%)
Form1.NumberField.Text = Numbers(loop_index%)
Form1.CommentField.Text = Comments(loop_index%)
Form2.Hide
End Sub
Os arrays globais Names( ), Numbers( ) e Comments( ), logicamente, não são

ligados a formulário algum. Esse módulo é como qualquer outro arquivo
associado ao projeto ativo; ou seja, ele é salvo e carregado junto com os outros.
5.2 Criação dos nossos próprios Tipos De Dados
Como o programa de bancos de dados se encontra, estamos

mantendo três arrays de dados:
Global Names(100) As String

Global Numbers(100) As String
Global Comments(100) As String
Na verdade, campos como estes são normalmente reunidos no seu

próprio tipo (e isso nos leva a um poderoso conceito no Visual Basic). Em geral,
esse tipo de declaração (que ocorre sempre no módulo global) se parece com
isto:
Type nometipo
nomeelemento As tipovariável
[nomeelemento As tipovariável]
[nomeelemento As tipovariável]
.
.
End Type
Por exemplo, podemos criar um tipo Record para nosso banco de

dados da seguinte forma:
Type Record
Name As String * 50
Number As String * 20
Comment As String * 200
End Type
Esse código define um novo tipo de dados, Record, que contém os

campos individuais, como mostramos acima. Observe que estamos dando a
cada string um tamanho definido - isso é o que significam os caracteres * 50,
*20 e * 200. Name As String * 50 significa que o string chamado Name terá
exatamente 50 caracteres de extensão. Podemos declarar um array desse tipo
chamado, digamos, TheData( ), da seguinte forma:
Type Record
Name As Stririg * 50
Comment As String * 200
End Type
Global TheData(100) As Record
Podemos alcançar qualquer um deles usando o operador ponto (.) (assim

como fazemos para alcançar uma propriedade do Visual Basic):
TheData(3).Name = "Cenoura"
TheData(3).Number = "287"
TheData(3).Comment = "Preço muito alto?"
Vamos usar esse novo array na nossa aplicação de bancos de dados

para combinar todos os três arrays separados, Names( ), Numbers( ) e
Comments( ), juntos em um array - Database( ).
Depois de definir o tipo do novo registro, Record, e o array desse tipo,

Database( ), temos que mudar as referências correspondentes no nosso
programa. Por exemplo, Names(TotalRecords) torna-se
TheBase(TotalRecords).Name.
Existem apenas duas procedures Sub para mudar, a procedure em que

armazenamos os dados e a procedure em que os recuperamos. Em Form1, a
procedure para incluir um item deverá ser mudada disto:
Numbers(TotalRecords) = NumberField.Text
Form2.NameList.AddItem NameField.Text
End Sub
para isto:
TheData(TotalRecords).Name = NameField.Text
TheData(TotalRecords).Number = NumberField.Text
TheData(TotalRecords).Comment = CommentField.Text
Form2.NameList.AddItem NameField.Text
End Sub
Aqui, apenas mudamos Names(TotalRecords) para

TheData(TotalRecords).Name, e assim por diante.
Além disso, no nosso módulo, temos que mudar a procedure para

pesquisar um item, Getltem( ), disto:
Sub GetItem( )

If (Names(loop_index%) = Form2.NameList.Text) Then
Exit For
Next loop_index
Form1.CommentField.Text = Comments(loop_index)
Form2.Hide
End Sub
para isto:
Sub GetItem( )

lf (Rtrim$(TheData(loop_index).Name) =
Rtrim$(Form2.NameList.Text)) Then Exit For
Next loop_index
Form1.NameField.Text = TheData(loop_index).Name
Form1.NumberField.Text = TheData(loop_jndex).Number
Form1.CommentField.Text = TheData(loop_jndex).Comment
Form2.Hide
End Sub
Observe que estamos usando um string de tamanho fixo para todos os

campos. Como o Visual Basic completa esses strings com espaços à direita,
tivemos que remover esses espaços com a função Rtrim$( ) do Basic; seu
correspondente para retirar espaços à esquerda é Ltrim$( ). A função Rtrim$( )
simplesmente retira quaisquer espaços do lado direito dos strings antes de
compará-los com os itens no quadro de lista.
5.3 Criação de Quadros Combo

A diferença entre quadros combo e quadros de lista é que os quadros

combo combinam um quadro de lista com um quadro de texto (motivo pelo
qual eles são chamados quadros combo), de modo que os usuários possam
digitar seu próprio texto se não quiserem selecionar urna das escolhas
oferecidas. Existem três estilos diferentes de quadros combo.
O primeiro deles (estilo 0) é o quadro combo padrão, onde a seta fica

separada do quadro de texto. Quando o usuário acionar a seta, a lista de itens
a escolher cairá. O segundo estilo (estilo 1) é o mesmo, exceto que o quadro de
lista é sempre mostrado. O terceiro estilo (estilo 2), com a seta conectada, não
é realmente um quadro combo: é um quadro de lista (chamado quadro de lista
suspensa). Esse é o mesmo que o quadro de lista normal (ou seja, o usuário
não pode editar as seleções conforme pode em um quadro combo), exceto que
a lista fica escondida até que o usuário acione a seta.
Como os quadros combo em estilo 2 são realmente quadros de lista, nós

os veremos antes de trabalhar com os quadros combo reais.
É fácil adaptar nossa aplicação de bancos de dados para usar quadros

de lista suspensa em vez de quadros de lista normais. Tudo que precisamos
fazer é excluir o quadro de lista chamado NameList em Form2 e substituí-lo por
um quadro combo, estilo 2, chamado NameList. Para fazer isso, acione o
quadro de lista original e selecione Cut no menu Edit. Em seguida, acione na
ferramenta de quadro combo na caixa de ferramentas (em seguida à ferramenta
de quadro de lista), selecione o estilo 2 e posicione-o corretamente.
Como você pode ver, isso permite que o quadro de diálogo Find Item... seja
muito mais compacto. Usar um quadro de lista suspensa é fácil.
Agora vejamos os próprios quadros combo. Como o usuário pode mudar ou

editar o item no quadro de texto que faz parte do quadro combo, os dois eventos
importantes conectados aos quadros combo são Click e Change (o evento Change
ocorre quando o texto no quadro é alterado). Além disso, um quadro combo simples
(estilo 1, e não um quadro suspenso) reconhece o evento DblClick, mas o outro
quadro combo (estilo 0), não. Aqui estão as propriedades associadas aos quadros
combo:
Text O item atualmente selecionado
List Array de String contendo todos os itens
Listlndex O índice do item selecionado (base 0; -1 se o usuário entrou

com texto em vez de selecionar um item)
ListCount Número total de itens na lista

Na verdade, as propriedades de um quadro combo são muito parecidas com as

propriedades de um quadro de lista, mas com uma diferença: se o usuário digitou a
seleção ativa em vez de selecioná-la pela lista disponível (uma opção que não existe
com quadros de lista), então a propriedade ListIndex é definida em -1.
Quanto ao restante dos detalhes dos quadros combo - manter o texto

selecionado, marcar o texto e assim por diante -, o Visual Basic cuida disso para você.
Para ver como isso funciona, vamos alterar nosso programa de bancos
de dados para mostrar seus nomes de produto em um quadro combo em vez de
um quadro de lista.
A vantagem é que o usuário poderá simplesmente digitar o nome do

produto que está procurando em vez de pesquisar por uma lista que poderia ser
muito longa. Infelizmente, há a possibilidade de a entrada selecionada não
corresponder a registro algum (isto é, no caso de o usuário ter errado na
digitação do nome do produto).
Isso é algo que teremos que verificar quando o usuário acionar o botão
OK.
Enquanto isso, abra a aplicação de bancos de dados no Visual Basic e

selecione o quadro de lista suspensa que acabamos de incluir nele. Como o
Visual Basic o trata como um quadro combo de estilo 2, podemos mudá-lo para
outro tipo de quadro combo sem substituí-lo. Vamos usar o estilo de quadro
combo 0. Embora devamos renomeá-lo de NameList para NameCombo, é mais
conveniente deixar o nome como NameList, pois o código já se refere a ele
dessa forma.
Agora temos que nos assegurar de que a seleção realmente corresponde

a um dos registros. Para isso, podemos incluir este código em nossa procedure
Sub Getltem( ):
Sub GetItem( )
Matched = False
lf (Rtrim$(TheData(loop_index).Name) =
Rtrim$(Form2.NameList.Text)) Then
Matched = True
Exit For
End If
Next loop_index
lf (Matched) Then
Form1.NameField.Text = TheData(loop_index).Name
Form1.NumberField.Text =
TheData(loop_index).Number
Form1.CommentField.Text =
TheData(loop_index).Comment
Form2.Hide
Else
MegBox “Sorry, I cannot find the record.”, 48,
“Database”
End If
End Sub
Aqui, se não pudermos achar o registro que foi digitado, geramos um

quadro de mensagem de erro e deixamos o usuário começar de novo. Depois
dessa mudança, o programa funciona como antes, exceto que agora o usuário
pode digitar o nome do registro que está procurando como um atalho. No
entanto, se o usuário entrar com o nome de um registro que não combine com
um dos registros existentes, aparecerá um quadro de erro.
5.4 Uso de Arquivos
Nesta seção você verá como trabalhar com arquivos no Visual Basic. O
modo mais comum de manter seus dados após o término de um programa é
armazená-los em arquivos. Esta seção discute essa importante habilidade,
além dos seguintes tópicos:
· Criação, abertura e fechamento de arquivos
· Leitura e gravação de arquivos
· As funções de fim de arquivo (EOF) e tamanho de arquivo (LOF)
· Arquivos seqüenciais
· Arquivos de acesso aleatório
· Quadros de lista de diretório
· Quadros de lista de arquivo
· Quadros de lista de unidade

· O comando Seek
· Os comandos Get e Put
· Como cuidar de erros de arquivo
Você também incluirá capacidades de manipulação de arquivos a alguns

dos programas que já desenvolveu, sobretudo nos programas Editor e
Database.
A maior parte dos programas do Windows usa arquivos de algum tipo, de

modo que a capacidade de uso de arquivos será importante para todos os tipos
de programas: programas gráficos, processadores de textos, programas de
bancos de dados etc.
Você deve se lembrar de que nosso programa Editor tinha duas escolhas
de menu que nunca foram usadas: Load File... e Save File.... Até agora, todos
os dados que nossos programas usaram foram temporários.
Quando a aplicação terminava, eles desapareciam. Os arquivos, é claro,

são o meio mais comum de armazenar dados no PC, de modo que são
vitalmente importantes à maior parte das aplicações do computador.
O sistema de comandos de manipulação de arquivos no Visual Basic é

muito semelhante ao que existe em outros Basics; logo, se você estiver
acostumado com Open, Close, lnput$ e Seek, já terá um bom ponto de partida.
No entanto, como você já deve imaginar, as coisas são muito diferentes quando
se trata da interação com o usuário.
Por exemplo, o usuário normalmente seleciona nomes de arquivo para

carregar ou salvar dados por meio de quadros de diálogo em aplicações do
Windows (o que, a propósito, é o motivo para vermos os quadros de diálogo
antes dos arquivos), e veremos como fazer isso nesta seção, à medida que
prepararmos nosso quadros de diálogo de arquivo.
Dois desses quadros de diálogo serão para os itens Save File... e Load
File... da nossa aplicação Editor. Além disso, também veremos como trabalhar
com arquivos estruturados, onde os dados são divididos em registros
específicos, como a nossa aplicação de bancos de dados na seção anterior. De
fato, poderemos modificar essa aplicação nesta seção de modo que ele possa
salvar seus dados no disco. Com isso e outros tópicos que irão aparecer, por
que não começar imediatamente?
Gravação de dados em um Arquivo
Se quisermos incluir suporte para arquivo à nossa aplicação de editor,

poderemos começar com o item Save File... (afinal, temos que criar e salvar
arquivos antes de lê-los de volta).
Quando você selecionar o item Save File.... poderá gerar um quadro de

diálogo na tela com um quadro de lista e dois botões: OK e Cancel. Você
poderia então digitar o nome do arquivo em que deseja salvar seu documento, e
o seu programa criaria o arquivo com esse nome (se necessário) e depois
armazenaria lá o documento.
Para colocar isso em prática, inicie o Visual Basic e abra o projeto Editor.
Se você der uma olhada no menu File, verá que o item Save File... já existe.
Acione-o com o mouse para gerar o seguinte gabarito:
Sub SaveItem_Click( )
End Sub
Para salvar o documento ativo, você deverá colocar o quadro de diálogo

Save File... na tela. Vamos nomear o quadro de diálogo com SaveForm. Para
apresentá-lo, tudo o que precisamos fazer é isto:
Sub SaveItem_Click ( )
SaveForm.Show
End Sub
Em seguida, devemos montar esse quadro de diálogo (ainda no projeto

Editor), nomeando-lhe SaveForm, dando uma legenda Save File..., e salvar
nosso trabalho como, digamos, SaveForm.Frm. Além disso, temos que incluir
um quadro de texto a esse novo formulário; colocar um label acima do quadro
de texto, com os dizeres Save File As... (de modo que o usuário saiba que
deverá entrar com um nome de arquivo), incluir um botão OK com sua
propriedade Default em True, e um botão Cancel.
Finalmente, como esse é um quadro de diálogo, podemos remover os

botões Min e Max.
A procedure do botão Cancel é muito fácil, de modo que poderemos fazer

isso primeiro. Tudo que precisamos fazer se o usuário decidir cancelar é ocultar
novamente o formulário, e, para tanto, colocaremos isto em CancelButton_Click(
):
Sub CancelButton-Click ( )
SaveForm.Hide
End Sub
O serviço real é feito quando você aciona o botão OK. Acione esse botão
para abrir a procedure click do botão OK, da seguinte maneira:
Sub OKButton_Click ( )
End Sub
Quando atingirmos esse ponto no programa, poderemos supor que o

texto em FilenameBox contém um nome de arquivo e que deveremos salvar o
documento ativo - ou seja, o string chamado Form1.display.Text - a este arquivo.
Existem três passos nesse processo: abrir o arquivo (ou criá-lo, se ainda
não existir), gravar os dados no arquivo e fechá-lo. Podemos dar uma olhada
em cada um desses três passos em ordem enquanto montamos OKButton-
Click(); cada passo nos dirá algo sobre o sistema de arquivo do Visual Basic.
Abertura de Arquivos no Visual Basic
Para abrir ou criar um arquivo no Visual Basic, basta você usar o

comando Open. No entanto, temos que considerar algo a respeito do
modo como abrimos ou abrimos ou criamos esse arquivo.
Tipos de Arquivo no Visual Basic
Os três primeiros modos têm a ver com arquivos seqüenciais. Os

arquivos seqüenciais normalmente são usados para arquivos de texto, onde
você grava o arquivo do início ao fim e o lê da mesma maneira; ou seja, você
não salta de um lugar para outro dentro do arquivo. Trabalhar com arquivos
seqüenciais é como usar fitas cassete; se você quiser ouvir algo no final da fita,
terá que passar primeiro por tudo que esteja na frente. Da mesma forma, se
você quiser algo do texto no final de um arquivo aberto com acesso seqüencial,
terá primeiro que ler todo o texto que vem antes dele.
Se os arquivos de acesso seqüencial são como fitas cassete, os arquivos

de acesso aleatório são como discos de pickups. Ao contrário de uma fita, em
um disco você pode movimentar à vontade, sem ter que passar por todas as
faixas intermediárias. Da mesma forma, você pode movimentar-se à vontade
em um arquivo de acesso aleatório, retirando dados de qualquer local onde
desejar. O preço a ser pago é que os dados em um arquivo de acesso
aleatório devem ser cuidadosamente seccionados em registros, de modo que
você saiba exatamente onde estão os dados que deseja obter.
Por exemplo, se os registros que desenvolvemos na nossa aplicação de

bancos de dados fossem todos do mesmo tamanho, eles funcionariam
perfeitamente em um arquivo de acesso aleatório; quando quiséssemos o
vigésimo registro, poderíamos simplesmente saltar sobre os 19 primeiros e
então começar a leitura. No entanto, o texto - como armazenamos na
aplicação Editor - não é seccionado corretamente em registros do mesmo
tamanho, e por isso colocaremos o texto que estamos para salvar em um
arquivo seqüencial.
O terceiro tipo de arquivo são os arquivos binários; aqui o Visual Basic não
interpreta o conteúdo do arquivo de forma alguma. Por exemplo, os arquivos
executáveis (.Exe) são arquivos binários, e nós os tratamos numa base byte a
byte no Visual Basic. Para copiar um arquivo desses, precisamos ler cada byte
do arquivo original (o arquivo de origem) e depois enviá-los para um novo
arquivo (o arquivo de destino). Embora possamos definir a quantidade de
dados que queremos ler sob arquivos seqüenciais ou aleatórios, os arquivos
binários são sempre tratados byte a byte.
Cada um desses três tipos de acesso ao arquivo possui seu próprio

conjunto de comandos no Visual Basic, como veremos neste capítulo. Como
podemos nos confundir, você encontrará uma coleção dos comandos mais
comuns de manipulação de arquivo do Visual Basic, organizados por tipo de
arquivo, na tabela.
Comandos de Arquivo do Visual Basic.
Acesso Comandos Comuns do Visual Basic
Seqüencial Open, Line lnput #, Print #, Write #, Input$, Close
Aleatório Type... End Type, Open, Put #, Len, Close, Get #
Binário Open, Get #, Put #, Close, Seek, lnput$
Nossa tarefa aqui é salvar o documento ativo do Editor, e faremos isso

abrindo um arquivo seqüencial (embora realmente pudesse ser tratado como
arquivo binário). Existem três maneiras de abrir arquivos seqüenciais: para
entrada (Input), saída (Output) e acréscimo (Append).
Abrimos um arquivo para entrada se queremos ler algo dele, para

saída se queremos gravar nele, e para acréscimo se queremos incluir algo
ao seu final.
Esses três modos são coerentes com a idéia de abrir o arquivo e depois
trabalhar com os dados do início ao fim. Por exemplo, se abrimos um arquivo
para saída seqüencial, gravamos nele um string, e depois o seguimos por um
segundo string, este vai diretamente após o primeiro, e assim por diante para
strings subseqüentes, um após o outro. Se quiséssemos lê-los novamente
teríamos que fechar o arquivo e abri-lo para entrada, e depois poderíamos ler
os dados de volta, do início ao fim.
Os arquivos aleatórios, onde você poderá movimentar-se à vontade pelo

arquivo, não possuem qualquer uma dessas restrições. Quando você abre um
arquivo para acesso aleatório, ele está preparado para entrada e saída (por
outro lado, lembre-se de que, nos arquivos aleatórios, você precisa seccionar os
dados em registros).
Nesse caso, quando estivermos gravando nosso documento do Editor no

disco, abriremos nosso arquivo para saída seqüencial. Em geral, o comando
Open do Visual Basic será este:
Open fff$ [For mmm][Access aaa] [111] As [#] nnn% [Len = rrr%]
Onde os argumentos possuem este significado:
fff$ O nome de arquivo (incluindo um caminho opcional)
mmm Modo: pode ser Append, Binary, lnput, Output ou

Random
aaa Acesso: pode ser Read, Write ou Read Write
111 Lock: restringe o acesso de outras aplicações
nnn% Número do arquivo (1-255): o número que usaremos

para nos referir a esse arquivo daqui em diante,
rrr% Tamanho do registro para arquivos aleatórios, ou

tamanho do buffer que você quer que o Visual
Basic use para arquivos seqüenciais
No nosso caso, o usuário deseja gravar no arquivo agora existente em

FilenameBox.Text, de modo que poderemos usar este comando Open para abrir
o arquivo:
Open FilenameBox.Text For Output As # 1
De fato, esse arquivo poderia nem mesmo existir; o usuário poderia

querer que o criemos. Isso é feito automaticamente pelo comando Open: se o
arquivo não existir e estivermos tentando abri-lo para algo diferente de lnput, o
Visual Basic criará o arquivo para nós. Por outro lado, observe que quando
abrimos um arquivo já existente para saída e depois gravamos algo nele, o

conteúdo original do arquivo é destruido. (Se quiser incluir algo ao final de
um arquivo seqüencial e manter o que já existe antes, abra o arquivo para
Append.) Agora podemos iniciar o quadro de diálogo Save File... com esta linha
na procedure click do botão OK:
Open FilnameBox.Text For Output As # 1 'Abre arquivo

.
.
End Sub
Assim como no Basic normal, poderemos nos referir a esse arquivo como
arquivo # 1 quando quisermos gravar nele ou fechá-lo. No entanto, temos que
notar que existe a possibilidade de erro quando abrirmos um arquivo dessa
maneira: o usuário pode ter especificado um caminho inválido, por exemplo, ou
errado na digitação do nome do arquivo. Para cuidar desses erros, podemos
incluir um comando On Error GoTo, da seguinte forma:
On Error GoTo FileError

Open FilenameBox.Text For Output As # 1 'Abre arquivo
.
.
.
Isso funciona da seguinte maneira: se houver um erro, o programa

saltará imediatamente para o label FileError, onde poderemos colocar um
quadro de mensagem na tela e depois executar um comando Resume, que
salta de volta à linha que causou o erro, permitindo que o usuário tente
novamente.
Sub OKButton-Click( )

.
.
Exit Sub ‘ Sai da rotina e pula o tratamento de erro
FileError:
MsgBox “File Error", 48. "Editor" 'MsgBox para erro de
arquivo
End Sub
Como tratar de erros “acusáveis"
Se não tivéssemos colocado esse comando no código, não

poderíamos apanhar esses erros - chamados erros "acusáveis".
Nesse caso o próprio Visual Basic avisaria sobre o erro
diretamente, com um quadro de mensagem, o que não
é desejado na maior parte das aplicações.
Em outras palavras, se o nome do arquivo for válido e o arquivo

correspondente puder ser aberto ou criado, faremos isso. Se houver um
problema, indicaremos o fato e permitiremos que o usuário mude a
especificação de arquivo para outra tentativa. Nesse ponto, então, o arquivo
estará aberto; o próximo passo é gravar nele o nosso documento.
Gravação em Arquivos no Visual Basic
O modo normal de gravar em um arquivo seqüencial é usar os comandos

Print # ou Write #. Veja como podemos usá-los:
Print # nnn%, expressionlist
Write # =%, expressionlist
Aqui, nnn% é o número do arquivo (1 para o nosso caso), e

expressionlist é uma lista das variáveis (incluindo strings) que você deseja
gravar no arquivo. Os dois comandos, Print # e Write #, são diferentes; Write #
insere vírgulas entre os itens separados na expressionlist, à medida que os
grava no arquivo, coloca aspas ao redor dos strings e insere uma nova linha
(em branco) ao final do arquivo. Como não queremos qualquer um desses
caracteres adicionais, usaremos Print # em vez disso. De fato, só desejaremos
enviar um único string ao arquivo: Form1.display.Text, de modo que nosso

comando Print # estará como neste trecho:
Sub OKButton_Click()

Print # 1, Form1.PadText.Text 'Grava documento
.
.
.
Exit Sub
FileError
MsgBox "File Error", 48, "Editor" 'MsgBox para erro de

arquivo
End Sub
E isso é tudo para gravar o texto no arquivo. Fechar o arquivo não é

muito mais dificil; use o comando Close, como vemos aqui:
Print # 1, Form1.PadText.Text 'Grava documento

Close #1 'Fecha o arquivo
.
.
.
Exit Sub
File Error

arquivo
End Sub
Close # 1 fecha o arquivo número 1, que é o arquivo em que estamos

trabalhando. Depois de fechar o arquivo, teremos terminado, de modo que
saímos da procedure Sub com um comando Exit Sub. Nesse ponto, o arquivo
foi gravado com sucesso no disco, ou, se não, alertamos o usuário para o fato.
(Saltamos para o label FileError e geramos nosso quadro de mensagem na tela,
como antes.)
Fechando todos os arquivos ao mesmo tempo
Se você usar o comando Close sem qualquer número

de arquivo, então oVisual Basic fechará de uma
só vez, todos os arquivos que a sua aplicação abriu.
O passo final, se a manipulação de arquivo tiver sido tranqüila, é

esconder o quadro de diálogo Save File... (isto é, SaveForm) da seguinte forma:
Sub OKButton-click( )

Print # 1, Form1.display.Text 'Grava documento

Close #1 'Fecha o arquivo
SaveForm.Hide
Exit Sub
FileError:
arquivo
End Sub
Para ver isso em ação, faça as mudanças acima e tente digitar algumas
linhas de texto no Editor e depois salvá-las. Quando o fizer, verá que o texto é
gravado no disco, no arquivo escolhido.
Observe que o texto no arquivo é simplesmente armazenado como uma

longa cadeia de texto sem carriage returns [ou Enter] - a menos que estejam
presentes no documento original -, pois o próprio quadro de texto principal o
armazena dessa maneira. E isso termina nosso item Save File.... Pudemos
gravar um arquivo de texto seqüencial no disco, e nossa aplicação Editor
tornou-se ainda mais sofisticada. No entanto, o próximo passo correspondente
é ler os arquivos de volta no item Load File... do Editor. Veremos esse processo
em seguida.
Uso de Controles de Arquivos no Visual Basic
O primeiro passo na leitura do conteúdo de um arquivo é obter o nome

desse arquivo. No entanto, isso não é uma simples questão de pedir ao usuário
para digitar o nome em um quadro de texto. Temos que ter a capacidade de
procurar no disco (assim como outras aplicações semelhantes Windows) e
permitir que o usuário selecione a partir do que já existe lá. O Visual Basic
oferece três controles especiais para fazer exatamente isso, e estes são
quadros de lista de disco, quadros de lista de diretório e quadros de lista de
arquivo.
As ferramentas para criar esses controles de arquivo aparecem no final da
caixa de ferramentas do Visual Basic. Acontece que esses controles farão
grande parte do trabalho para nós. A caixa de ferramentas pesquisará
automaticamente unidades e diretórios, e poderemos trabalhar com as várias

propriedades associadas com eles.
Esta caixa de diálogo já foi criada em nosso curso,

vamos agora utiliza-la para manipular nossos arquivos!
Se você salvou o formulário que corresponde
a essa caixa de diálogo, reaproveite-º
Caso contrário, crie um novo.
Vamos iniciar esse processo projetando um quadro de diálogo para a

opção Load File.... que poderemos chamar LoadForm e salvá-lo como
Loadform.Frm. Primeiro, vamos conectá-la ao item de menu Load File...
acionando esse item no menu File do Editor:
Para mostrar o quadro de diálogo Load File... (LoadForm), podemos

simplesmente mostrá-lo da seguinte forma:
Sub LoadItem
LoadForm.Show
End Sub
Para projetar LoadForm, use o item New Form do menu File do Visual
Basic. Para criar o formulário, dê a ele um Name de LoadForm; use, Load
File... como legenda; remova os botões Min e Max; mude a propriedade de
BorderStyle para dupla fixa; e inclua os botões OK e Cancel.
Em seguida, inclua um quadro de lista de unidade com um clique duplo
na ferramenta de lista de unidade na caixa de ferramentas, que está próxima à
ferramenta do temporizador. Observe que o quadro de lista de unidade é um
quadro de lista suspensa, o que nos economizará algum espaço. Também
precisamos de um quadro de lista de diretório e um quadro de lista de arquivo,
e, portanto, acione com um clique duplo também essas ferramentas (que se
encontram no final da caixa de ferramentas), e arrume-as como você desejar no
quadro de diálogo.
O usuário poderá carregar qualquer arquivo existente dessa maneira, por

meio da combinação dos quadros de unidade, diretório e lista de arquivos. Ele
pode usar o quadro de lista de unidade para especificar a unidade, o quadro
de lista de diretório para especificar o diretório nessa unidade, e o quadro de
lista de arquivos para indicar o arquivo real que deseja abrir.
Esse arquivo pode ser aberto de duas maneiras: dando um duplo clique no
nome do arquivo no quadro de lista de arquivo ou selecionando-o
(destacando-o) no quadro de lista de arquivo e acionando o botão OK.
E, como sempre, ativar o botão Cancel é muito fácil. Basta esconder o

quadro de diálogo quando esse botão for acionado:
Sub CancelButton_Click( )
LoadForm.Hide
End Sub
Agora vamos passar aos controles de arquivo. Nesse ponto, os três

quadros de lista (de unidade, diretório e arquivo) não estão se comunicando um
com o outro; ou seja, eles estão apenas mostrando informações independentes
para o diretório ativo no disco. Se tivéssemos que rodar esse programa e
mudar o disco no quadro de lista de disco, os outros dois quadros não
responderiam à mudança. Para que possam se comunicar, temos que saber um
pouco mais sobre os eventos importantes para cada um deles, e veremos isso
em seguida.
Quadros de Lista de Unidade
O quadro de lista de unidade é um quadro de lista suspensa. A unidade

ativa é indicada nela.
Quando o usuário aciona a seta conectada, o quadro de lista desce,
mostrando que outras unidades estavam disponíveis para escollia. Quando o
usuário escolher uma, um evento Change ocorrerá no quadro de lista. Como
não definimos o nome para nosso quadro de lista de unidade, ele ainda possui
o nome original de Drive1 (a definição básica para os quadros de lista de
unidade), de modo que a procedure de evento é Drive1_Change( ). A
propriedade do nosso quadro Drive1 que mantém a unidade é simplesmente
Drive1.Drive, e nossa próxima tarefa é passar essa nova unidade adiante para o
quadro de lista de diretório, que ainda possui o nome original Dir1 (como é
normal para quadros de lista de diretório). Para fazer isso, só precisamos
passar a propriedade Drive1.Drive para a propriedade Dir1.Path:
Podemos fazer isso acionando o quadro de lista de unidade com o

mouse, o que faz surgir a procedure Drive1_Change. Basta atribuir a
propriedade Drive de Drive1 à propriedade Path de Dir1, da seguinte forma:
Sub Drive1_Change( )
Dir1.Path = Drive1.Drive
End Sub
E isso é tudo que precisamos fazer para conectar os quadros de unidade

e diretório. De fato, podemos rodar o programa nesse ponto. Quando o
fizermos, poderemos acionar o item Load File... do menu File do Editor. O
quadro de diálogo que projetamos, LoadForm, aparece em seguida, mostrando
a unidade ativa, diretório e arquivos nesse diretório. Se acionarmos o quadro
de unidade, a lista suspensa de todas as unidades no sistema aparecerá.
Acionando uma dessas unidades, passaremos para essa unidade, e a mudança
também afeta o quadro de lista de diretório, que também muda para listar os
diretórios nesse novo disco. O próximo passo no nosso programa é conectar o
quadro de lista de diretório ao quadro de lista de arquivo, de modo que, quando
o diretório for alterado, os arquivos mostrados sejam os arquivos nesse
diretório.
Quadros de Lista de Diretório
O quadro de lista de diretório mostra os diretórios disponíveis em uma

certa unidade. Ele é um quadro de lista simples - ou seja, é sempre mostrado, e
não um quadro de lista suspensa. A unidade de trabalho é mostrada na linha
superior, e os diretórios dessa unidade aparecem logo abaixo. Se houver mais
diretórios do que o espaço permitido, uma barra de paginação vertical
aparecerá à direita do quadro. O diretório ativo aparecerá como uma pasta
aberta sombreada; seus subdiretórios aparecerão como pastas fechadas (sem
sombra) logo abaixo dele. Quando o usuário mudar de diretório, acionando um
novo diretório, um evento Dir1_Change será gerado, e o novo caminho será
colocado em Dir1.Path. Além disso, pelo modo como preparamos as coisas,
quando o usuário mudar de unidade, Drive1.Drive será carregado em Dir1.Path,
que também gera um evento Dir1_Change. Em outras palavras, o único evento
com que precisamos nos preocupar aqui é Dir1_Change, que agora cuida das
mudanças de unidade e diretório.
Quando ocorrer esse evento, precisamos dar a notícia ao quadro de lista
de arquivo, o que pode ser feito passando adiante a propriedade Dir1.Path à
propriedade Path do quadro de lista de arquivo. Como essa lista ainda é

chamada File1 (a definição original para quadros de lista de arquivo), podemos
fazer isso.
Sub Dir1_Change( )
File1.Path = Dir1.Path
End Sub
Desse modo, toda vez que houver uma mudança no diretório de trabalho
- ou unidade de trabalho -, o quadro de lista de arquivo saberá disso.
Se fizermos essa mudança e depois iniciarmos o programa, poderemos

ver que agora todos os quadros de lista estão conectados. Por exemplo,
podemos acionar o quadro de lista de unidade para mudar a unidade, e a
mudança automaticamente será comunicada ao quadro de lista de diretório,
cuja lista de diretórios é alterada de acordo. Essa mudança, por sua vez,
também é comunicada ao quadro de lista de arquivo, que mostra os arquivos no
novo diretório de trabalho.
Por conseguinte, se mudarmos o diretório de trabalho no quadro de lista

de diretório, essa mudança também será comunicada ao quadro de lista de
arquivo, que mostrará os arquivos no novo diretório. Em outras palavras, os
eventos importantes foram Drive1_Change e Dir1_Change, e as propriedades
importantes que tiveram que ser transferidas foram Drive1.Drive ® Dir1.Path, e
Dir1.Path ® File1.Path. Para realmente lermos o nome do arquivo que o usuário
deseja carregar, teremos que verificar a propriedade FileName de File1 - ou
seja, File1.FileName - da, seguinte forma:
Unidade Diretório Arquivo
Drive1.Drive Dir.Path Arquivo1.Path Nome do

File1.FileName Arquivo
Também poderíamos notar que, embora você possa selecionar uma nova
unidade com um único clique do mouse, são necessários dois cliques para
selecionar um novo diretório no quadro de lista de diretório. Essa diferença tem
a ver com a diferença entre os arquivos de lista suspensa e simples.
O motivo para precisar de dois cliques no quadro de listas de diretórios é

para que os usuários possam se movimentar para cima e para baixo nas listas
usando as teclas de direção sem mudar o diretório de trabalho para cada
entrada destacada durante o percurso; ou seja, a mudança é feita apenas
quando ele chegar ao diretório que deseja.
Leitura de Arquivos no Visual Basic
Os comandos-padrão de leitura de um arquivo seqüencial no Visual Basic

são lnput #, Line lnput # e Input$. Você deverá usá-los da seguinte forma:
lnput # nnn%, expressionlist
Line lnput # nnn%, stringvariable
Input$ (bbb%, [#] nnn%)
Aqui, nnn% é o número do arquivo (isto é, 1 para o nosso caso), bbb% é

o número de bytes a ser lido, stringvariable é o nome de uma variável de string
para colocar os dados, e expressionlist é uma lista de expressões onde os
dados serão colocados.
Por exemplo, se usarmos lnput # para preencher Form1.display.Text, o

comando poderia ser este: lnput # 1 Form1.display.Text. No entanto, o problema
com Input # é que ele espera que os itens no arquivo, sejam separados por
vírgulas, espaços ou mais de uma linha (isto é, um carriage return). Para
números, isso significa que quando lnput # encontrar a primeira vírgula, espaço
ou final de linha, ele achará que o número ativo terminou; para strings, lnput #
termina o string quando alcançar uma vírgula ou o fim de linha. Isso não pode
ser aceito por nós, pois o texto de um documento que estamos lendo poderá
conter muitas vírgulas. De fato, o usuário pode ter colocado carriage returns em
vários pontos do documento (embora não sejam necessários, pois o quadro de
texto multilinha do Editor possui uma quebra de linha automática), ou então
podemos estar tentando ler um documento de outra aplicação, que já contenha
carriage returns.
De maneira semelhante, a função Line lnput# lê strings dos arquivos, até

encontrar um carriage return, quando termina. Isso significa que teríamos que
alcançar o final de cada linha do arquivo (se for dividido em linhas)
separadamente. Uma forma de fazer isso seria a seguinte:
Do Until EOF(1)
Line Input # 1, Dummy$

Form1.PadText.Text = Form1.PadText.Text + Dummy$ +
Chr$(13) + Chr$(1O)
Loop
Os comandos nesse loop, se houver algum, serão executados

repetidamente até que a condição seja verdadeira, quando a execução
terminará. (Observe que se a condição for verdadeira no início, os comandos no
corpo do loop não são executados uma única vez.) No nosso caso, estamos
usando a função EOF( ) para compor a condição do nosso loop. Essa função
apanha um número de arquivo como seu argumento (para nós, isso seria
EOF(1)) e retorna um valor True quando atingirmos o final do arquivo. No loop
do exemplo acima, então, continuaríamos lendo as linhas do arquivo até
alcançarmos o final do arquivo. Além disso, toda vez que lemos uma linha,
incluímos os caracteres carriage return e avanço de linha ao final da linha, da
seguinte forma:
Do Until EOF(1)
Line Input # I, Dummy$

Form1.display.text = Form1.display.text + Dummy$ + Chr$(13) +
Chr$(10)
Loop
Aqui, estamos usando a função Chr$(), que retoma o caracter ANSI

correspondente ao código ANSI passado a ela. Por exemplo, Chr$(13) retorna
um carriage return. O motivo para incluirmos um par carriage return/avanço de
linha ao final de cada linha é que Line lnput # trata esses dois caracteres
simplesmente como delimitadores de string, excluindo-os do texto. Entretanto,
como eles fazem realmente parte do arquivo, podemos simplesmente colocá-los
de volta.
Uma opção melhor para nós do que lnput # ou Line lnput # é a função
lnput$, que é feita especialmente para ler strings, e que não suprime carriage
returns dos avanços de linha. Para usar essa função, no entanto, temos que
indicar o número exato de bytes que queremos ler; quando o fizermos, lnput$
retomará um string (que podemos atribuir a Form1.display.Text). O número de
bytes que queremos ler é simplesmente o tamanho do arquivo em bytes;
podemos usar outra função de arquivo, LOF(), para obter isso para nós. Assim
como EOF(), LOF() apanha um número de arquivo como argumento. LOF(), no
entanto, retorna o tamanho do arquivo indicado em bytes (o arquivo deve estar
aberto para LOF() funcionar), de modo que podemos ler tudo da seguinte forma,
com a função Input$o:
Form1.display.Text = Input$(LOF(1), # 1)
Limitações de lnput$()
A função lnput$() é limitada à leitura de arquivos de 32.767 bytes se você

o abrir para acesso seqüencial ou binário. No entanto, se quiser usar arquivos
maiores, poderá simplesmente verificar o tamanho do arquivo, LOF(), e depois
ler o arquivo várias vezes em sucessão até obter todos os dados de que
precisa.
De fato, como você especifica o número de bytes a serem lidos, poderá

também usar esse comando para ler dados de arquivos binários. Podemos
incluir nosso comando lnput$ a OKButton_Click() da seguinte forma, onde
colocamos o string lido (isto é, o conteúdo inteiro do arquivo) diretamente no
quadro de texto do Editor (Form1.display.Text):
Sub OKButton_Click ()

If (Right$(Dir1.Path,1) = "\") Then Filename = Dir1.Path +
File1.Filename
Else
Filename = Dir1.Path + "\" + File1.Filename
End If
Open Filename For Input As # 1
Form1.display.text = lnput$(LOF(1), # 1)
close #1
loadform.hide
Exit Sub
FileError:

arquivo
End Sub
Agora o quadro de diálogo Load File... está completo. Para usá-lo, basta
iniciar o programa e selecionar o item Load File... no menu File.
O quadro de diálogo Load File... é mostrado na tela. Como você pode
ver, o quadro de lista de arquivo apresenta os nomes de arquivo em ordem
alfabética. Para abrir um deles, basta dar um duplo clique no seu nome ou
selecioná-lo e acionar o botão OK. Quando o fizer, a procedure
OKButton_Click() será executada, o arquivo será aberto e lido para o Editor.
Nesse ponto, você poderá editá-lo e depois gravá-lo no disco novamente com a
opção Save File....
Uso de Arquivos de Acesso Aleatório no Visual Basic
Estamos prontos para passar de arquivos de acesso seqüêncial para

arquivos de acesso aleatório. Esses tipos de arquivos normalmente dividem
seus dados em registros, todos eles contendo o mesmo formato, mas
(normalmente) com dados diferentes. E, como você deve se lembrar,
preparamos os dados no nosso programa de bancos de dados anteriormente
exatamente para os tipos de registros, da seguinte forma:
Type Record
Name As String* 50
Comments As String * 200
End Type
Global TheData(100) As Record
Gravação de Arquivos de Acesso Aleatório
Podemos começar gravando o arquivo depois que o usuário selecionar o

item Save File... no menu File. O Name desse item é Saveltem. Podemos abrir
Saveltem_Click() acionando o item do menu.
Quando o usuário acionar esse item, ele poderá salvar o banco de dados
em um arquivo particular, de modo que precisamos gerar um quadro de
diálogo semelhante àquele que projetamos anteriormente para o nosso Editor.
De fato, podemos usar aqui o mesmo quadro de diálogo. Para carregar esse
formulário, basta abrir o menu File do Visual Basic, selecionar o item Add
File... e dar o nome do formulário Save File... (usamos Saveform.Frm no
exemplo anterior). Esse arquivo é automaticamente carregado - dessa forma,
você poderá trocar formulários como quadros de diálogo entre projetos,
economizando muito tempo durante o projeto, e fazendo com que suas
aplicações se tornem mais uniformes. Agora podemos gerar esse quadro de
diálogo na tela da seguinte forma em Saveltem_Click():
Sub Saveltem_Click()
SaveForm.Show
End Sub
Em seguida, temos que fazer algumas mudanças no código de SaveForn,

pois está preparado para armazenar arquivos seqüenciais. Basta passar para
esse formulário usando a janela de projeto, e acionar na procedure
OKButton_Cllck(), que atualmente contém o seguinte código:
Sub OKButton_Click ()

Open Filenamebox.text For Output As#1
Print # 1, Form1.display.text ‘Grava documento

Close # 1 'Fecha o arquivo
SaveForm.Hide
Exit Sub
File error:
MsgBox “File Error”, 48, “Database”
End Sub
Como estamos usando um arquivo de acesso aleatório com registros

dessa
vez, e não um arquivo seqüencial de texto, abrimos o arquivo como Random:
Open FilenameBox.Text For Random As #1 Len =

Len(TheData(1))
Print # 1, Form1.display.Text 'Grava o documento
SaveForm.Hide
Exit Sub
FileError:
MsgBox "File Error", 48. "Database" 'MsgBox para erro no
arquivo
End Sub
Aqui, estamos indicando que o tamanho de registro que iremos usar é

Len(TheData(1)), que retorna o tamanho (em bytes) do nosso registro. Em
seguida, queremos gravar o array de registros inteiro, Database(), nesse
arquivo, de modo que deveremos ver as opções para gravação de arquivos de
acesso aleatório.
Os comandos comuns de I/0 para arquivos binários e de acesso aleatório

são Get# e Put #; esses comandos podem obter ou colocar registros no arquivo.
Nesse caso, usaremos Put #, cuja sintaxe é a seguinte:
Put [#] nnn%, [rrr%], vvv%
Aqui, nnn% é um número de arquivo, rrr% é o número de registro que você

quer colocar no arquivo, e vvv% é a variável que queremos colocar lá. Se não
especificarmos um número de registro, o Visual Basic simplesmente coloca um
registro após o últirno no arquivo. O número total de registros é armazenado no
inteiro global TotalRecords, de modo que possamos gravar esse número de
registros da seguinte forma (observe que nenhum registro é gravado se
TotalRecords for 0):

Open FilenameBox.Text For Random As # 1 Len =
Len(TheData(1))
For loop_index = 1 To TotalRecords

Put # 1, TheData(loop_index)
Next loop_index

SaveForm.Hide
Exit Sub
FileError:
MsgBox "File Error", 48, “Database" 'MsgBox para erro no

arquivo
End Sub
E é isso aí. Agora podemos usar a opção Save File... do aplicativo

Database.
Nesse ponto, o arquivo é gravado no disco. (Observe que também

devemos mudar o quadro de mensagem de erro na seção FileError do código,
dando-lhe o título "Database" em vez de "Editor".) Se quiséssemos,
poderíamos ter gravado qualquer registro no lugar de todos eles especificando
um número de registro em particular, da seguinte maneira:
Put # 1, 5, TheData(23)
Isso grava no registro 5 do arquivo, preenchendo-o com o registro

TheData(23). Desse modo, o acesso aleatório é verdadeiramente aleatório,
pois ternos acesso a todos os registros do arquivo. Em outras palavras,
podemos nos movimentar à vontade no arquivo, gravando registros em
qualquer ordem. Isso funciona de forma semelhante com Get #, como
veremos em seguida, ao lermos os registros do arquivo.
Leitura de Arquivos de Acesso Aleatório
Já copiamos o quadro de diálogo Save File da aplicação Editor para o

nosso banco de dados, e podemos também copiar o quadro de diálogo Load
File. Mais uma vez, selecione o item Add File no menu File do Visual Basic,
e depois inclua o arquivo Frm contendo o quadro de diálogo Load File...
(nós o chamamos Loadform.Frm anteriormente). Em seguida, ative o item Load
File no menu File do Database da seguinte forma:
Sub Loadltem -ClickO
Loadform.show
End Sub
Agora acione o botão OK desse novo formulário, LoadForm, para mostrar

a procedure mais importante, OKButton_Click(), que atualmente é a seguinte:
Sub Okbotton_Click( )
If (Right$(Dir1.Path,1 ) = " \") Then 'Obtém nome do arquivo
Filename = Dir1.Path + File1.FileName

Else
Filename = Dir1.Path + "\" + File1.Filename
End if
Open Filename For Input As # 1

Form1.display.Text = Input$(LOF(1), # 1)'Lê o arquivo
'Abre o arquivo
Exit Sub
FileError:
MsgBox ”File Error",48,”Editor" 'MsgBox para erro
End Sub
Mais uma vez, abrimos o arquivo como antes, para acesso aleatório:

.
.
.
Open Filename For Random As # 1 Len =

Len(TheData(1))
Form1.display.Text = Input$(LOF(1), # 1)'Lê o arquivo

LoadForm.Hide 'Esconde o quadro de diálogo
Exit Sub
FileError:
MsgBox "File Frror", 48. "DataBase"
End Sub
Agora temos que obter os registros do arquivo usando Get #, que você
usa para ler a partir de arquivos aleatórios e binários, e cuja sintaxe é a
seguinte:
Get [#] nnn%, [rrr%], vvv%
Assim como em Put #, nnn% é o número do arquivo, rrr% é o número do

registro que você quer obter do arquivo, e vvv% é a variável queremos colocar
os dados. Se não especificarmos um número de registro o Visual Basic
simplesmente apanhará o próximo registro da posição ativa no arquivo. Nossa
primeira tarefa aqui é descobrir quantos registros existe no arquivo, e podemos
fazer isso simplesmente dividindo o tamanho arquivo pelo tamanho de cada
registro. Depois disso, podemos ler os dados da seguinte forma, registro por
registro:
Open Filename For Random As # 1 Len =

Len(TheData(1))
NumberFileRecords = LOF(1)/ Len(TheData(1))
For loop_index =1 To NumberFileRecords

Get # 1, TheData(loop_index)
Next loop_index

LoadForm.hide 'Esconde o quadro de diálogo
Exit sub
FileError:
MsgBox "File Error", 48, "Database" 'MsgBox para
erro de arquivo
End Sub
(Observe que, mais uma vez, mudamos o nome do título do quadro na seção
FileError do código de "Editor" para "Database").
No entanto, simplesmente carregar um arquivo não torna o banco de dados

ativo. Além disso, temos que carregar os nomes de registro que lemos ao nosso
quadro de lista ordenado do banco de dados, onde podem ser selecionados
pelo usuário. Esse quadro de lista é mantido no quadro de diálogo Find Item...
do banco de dados. Para carregar os nomes de registro para esse quadro de
lista, temos primeiro que apagar todas as entradas ativas (usando o método
Removeltem do Visual Basic), e depois podemos recarregá-las de TheData(),
usando o método Addltem:
If (Right$(Dir1.Path, 1) = "\") Then 'Obtém nome do arquivo

Filename = Dir1.Path + File1.FileName
Else
Filename = Dir1.Path + "\" + File1.FileName
End If
open Filename For Random As # 1 Len = Len(TheData(1))

NumberFileRecords = LOF(1) / Len(TheData(1))
For loop_index = 1 To NumberFileRecords
Get # 1, , TheData(loop_index)
Next loop_index
close # 1 'Fecha arquivo
For loop_index = 1 TO TotalRecords
Form2.Namelist.Removeitem 0
Next loop_index
TotalRecords = NumberFileRecords ‘ Depois de ler o arquivo

com segurança
For loop_index = 1 To TotalRecords
Form2.NameList.AddItem TheData(loop_index).Narne
Next loop_index
Form1.NameField.Text = TheData(1).Name
Form1.NumberField.Text = TheData(1).Number
Forml.CommentField.Text = TheData(1).Comment
LoadForm.Hide 'Esconde quadro de diálogo
Exit sub
FileError:
MsgBox "File Error", 48, "Database" ‘MsgBox para erro
End Sub
Uso do Comando Seek
Esse comando pode ser extremamente útil, pois nos permite especificar
qual o registro que será lido ou gravado em seguida. Sua sintaxe é a seguinte:
Seek [#] nnn%, PPP&
Aqui, nnn% é o número do arquivo, e ppp& (um inteiro longo) é a nova

posição no arquivo; para arquivos seqüenciais, ppp& é medido em bytes; para
arquivos aleatórios, em números de registro. Em outras palavras, esta linha:
Get # 1, loop_index, TheData(loop_index)
é o mesmo que as linhas:
Seek # 1, loop_index
Get # 1, TheData(loop_index)
Prática
Crie um pequeno banco de dados para controlar as operações dos

clientes de uma suposta Locadora de Vídeo. O registro de cada cliente deverá
ser composto por
Nome
Endereço
Fitas alugadas
Observações
O mini-banco deverá conter um Menu principal com os Itens: Arquivo

(Sub-itens Abrir, Salvar e Sair), Clientes (Sub-itens Adicionar e Remover).
No canto do formulário principal deverá aparecer o número de clientes

cadastrados.
Dica: Utilize as caixas de diálogos (Save e Open) criadas nas aplicações

anteriores.

326ap Vbasic

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

326ap Vbasic

Enviado por

Direitos autorais:

Formatos disponíveis

Microsoft Visual Basic 4.

1.1 Programação Procedural Versus Programação

Na programação procedural, ou seja, baseada nas chamadas de

Isso significa que um programa desenvolvido com base nessa técnica,

Portanto, com base nisso, podemos definir um evento como sendo

Para que um controle responda a um evento de

Podemos perceber então que o primeiro passo no desenvolvimento de

Note que essa técnica difere do processo antigo, em que primeiro o

Do lado do usuário, um programa orientado a eventos é mais fácil de

1.2 Criando um programa Visual Basic

1 command : Propriedade Caption = &OK

Nomeá-los :Na janela de propriedades colocar no campo Name o

Objetos Prefixo Exemplo

Dica: Para chamar o Help clique no ícone e tecle F1

1.3 Algumas Propriedades

Podemos defini-las em tempo de projeto ou em tempo de execução:

· Tempo de Projeto : No objeto lblnome - clique sobre o objeto uma vez.

( Tecla de Atalho ALT+N )

· Tempo de Execução : No objeto txtnome - dê um double clique no objeto.

Sempre: <nome objeto.propriedade> = <valor>.

Executar Þ Clicar sobre o Label Nome.

No objeto Form colocar :

Uma proprieddade de um objeto1, pode ser alterada

Os métodos determinam a realização de uma ação para um

txtnome.setfocus { posiciona o ‘foco’ para a caixa de texto do

lblcodigo.move 0,0 { posiciona o objeto lblcodigo para as

txtfrase.textwidth { retorna o tamanho da string do objeto

frmcliente.hide { esconde, mais permanece na memória

É uma ação reconhecida por um formulário ou por um controle, o agente

1.6 Formulários e Controles Básicos

Algumas Propriedades para Formulários

backcolor Þ cor do fundo

Alguns Métodos para Formulários

Alguns Eventos para Formulários

Obs. : Para obter mais informações, clique no formulário e tecle <F1>.

Mostra uma informação estática ( um rótulo).

Exemplo : Fornecer instruções ao usuário.

Alguns Eventos (mais usados)

Obs. : Você pode utilizar o textbox em conjunto com o controle

multiline Þ mais de uma linha

move Þ move o objeto

change Þ qualquer alteração no campo

visible Þ visível ou não

Exemplo : A cada ‘ t ‘ segundos você pode verificar se foi realizada a

File List Box

Apresenta uma caixa de listagem de itens. Seu ícone no toolbox

O Objetivo desta prática é fazer com que o aluno se familiarize com o

Dentro do seu aplicativo. Inclua no formulário :

1 textbox propriedades Þ multiline = true

1 timer propriedadesÞ interval = 1000(ms),

1 label propriedades Þ caption = <apagar>

Na seção General (geral) inclua o seguinte código:

Public tempo as date

No procedimento sub form_load() inclua:

No procedimento timer_timer inclua:

lbltime.caption = format(now-tempo, “long time”)

Execute sua aplicação.

Para vermos como o controle FileListBox funciona, vamos fazer o

Crie um objeto FileListBox em um novo formulário e dê a ele o Nome =

Private Sub Form_Click ()

Dim nome As String, I As Integer, Msg As String ' Declarando variaveis.

File1.Pattern = "Arquivo.*" ' Setando a forma geral do nome do arquivo

For I = 1 To 8 ' oito vezes.