1.
O Visual Basic é uma linguagem de
programação orientada a objetos criada
pela Microsoft e distribuída com o Visual
Studio .NET.
Curso Básico Visual Basic
Ana Isabel Rodrigues
+351 91 505 55 74 / clico@clico.pt

2.
1
Índice
1. Introdução............................................................................................................................. 3
1.1 O que é o Visual Basic?.................................................................................................. 3
1.2 O IDE do Visual Basic? Que é?....................................................................................... 3
1.3 Barra de Menus............................................................................................................. 4
1.4 Barra de Ferramentas.................................................................................................... 4
Solution Explorer................................................................................................................... 4
Properties.............................................................................................................................. 4
Form ...................................................................................................................................... 4
2. Iniciação ao Visual Basic....................................................................................................... 6
2.1 Iniciar, Guardar e Fechar Projectos............................................................................... 6
2.2 Palavras Reservadas:..................................................................................................... 7
2.3 O “Debugging”?............................................................................................................. 9
Quickwatch.......................................................................................................................... 10
A janela Locals..................................................................................................................... 11
A janela Immediate ............................................................................................................. 11
2.4 A Ajuda do Visual Basic ............................................................................................... 12
2.5 Criação de Módulos e Procedimentos ........................................................................ 12
3. Operadores de Programação: ............................................................................................ 13
3.1 Operadores Aritméticos:............................................................................................. 13
3.2 Operadores Relacionais: ............................................................................................. 13
3.3 Operadores Logicos:.................................................................................................... 14
3.4 Operadores de atribuição: .......................................................................................... 14
3.5 Funções Pré-Definidas................................................................................................. 15
3.6 Precedência e Associatividade:................................................................................... 17
4. Fundamentos de Programação........................................................................................... 18
4.1 Variaveis...................................................................................................................... 18
4.2 Formulas:..................................................................................................................... 20
4.3 .NET Framework.......................................................................................................... 21
4.4 Estruturas de Controlo................................................................................................ 22
4.5 Mecanismos de Passagem de parâmetros/valores .................................................... 25
5. Estrutura de Dados.............................................................................................................. 26
5.1 Vectores: ..................................................................................................................... 26

3.
2
5.2 Matrizes/Arrays:.......................................................................................................... 28
5.3 Enumerações:.............................................................................................................. 29
6. Windows Forms................................................................................................................... 31
6.1 Design de forms e Controlos....................................................................................... 31
6.3 Eventos de Formulários e Controlos:.......................................................................... 32
7. Acesso e Gestão de Base de Dados:.................................................................................... 33
7.1 Criar Base de Dados .................................................................................................... 33
7.2 Ligação Base de Dados:............................................................................................... 33
7.3 Consultar, Inserir, Actualizar Dados............................................................................ 36

4.
3
1. Introdução
1.1 O que é o Visual Basic?
O Visual Basic é uma linguagem de programação orientada a objetos criada pela
Microsoft e distribuída com o Visual Studio .NET. O Visual Basic.NET é um produto tão
diferente do antigo Visual Basic 6.0, que não pode ser considerado uma versão seguinte,
tendo como característica marcante o uso de assistentes para a criação do código.
Da mesma maneira que o Java precisa de uma máquina Virtual para funcionar, os
aplicativos .NET necessitam da .NET Framework instalada
1.2 O IDE do Visual Basic? Que é?
O IDE é o Ambiente de Desenvolvimento Integrado (Integrated Development
Environment), que torna mais fácil a criação de programas para o Microsoft Windows.
O IDE contém várias ferramentas que ajudam a projectar os aplicativos, escrever, editar
e depurar(debugging) o código dos mesmos.
A Microsoft disponibiliza as seguintes ferramentas de desenvolvimento para Visual
Basic:
• Visual Studio (varias versões, Visual Basic .Net 2002 ate ao actual 2017 RC)
• Visual Basic Express (VBE)
• Visual Web Developer

5.
4
O ambiente de desenvolvimento (IDE) activo:
1.3 Barra de Menus
Comandos em barras de ferramentas, como por exemplo:
File (ficheiro), View (View), Project…
1.4 Barra de Ferramentas
Contém uma ou mais barras de menus, é onde se encontram os controlos que podem
ser usados na aplicação. A maioria dos controlos que se encontram na barra de
ferramentas, encontra-se organizada alfabeticamente, contudo também pode ser
organizado a gosto do programador.
Solution Explorer
Onde se pode ver todos os arquivos existentes dentro do projecto.
Properties
Onde se pode ver todas as propriedades do objecto, métodos e eventos que podem ser
usados por ele.
Form
Onde se pode ver como o formulário vai ficar, onde se pode organizar os controlos,
aspecto do formulário.
Barra de
Ferramentas
Barra de
Menus
Formulário
Activo
Propriedades
do objecto
Solution
Explorer

6.
5
Por defeito, um novo projecto Visual Basic, abre os Forms com uma janela limpa, sem
grelha, muitos programadores acham o actual Layout (sem linhas) mais confortável e
visualmente mais fácil, outros acham o modo de ver do formulário apresentando a
grelha mais simples.
Fica ao critério de cada um o modo como pretende a visualização do seu IDE.
Para alterar o modo de visualização do Layout do Form, selecciona-se na Barra de
Menus, a opção Ferramentas(Tools) e depois Opções (Options), onde depois surge o
seguinte ecrãn:
Na opção Windows Forms Designer, expande-se a mesma e selecciona-se General, onde
do lado direito temos a opção de Layout Mode por predefinição em SnapLines e
escolhemos SnapToGrid.
Deslizamos a nossa barra ate
encontramos a opção Windows
Form Designer

7.
6
Após seleccionar OK, fecha-se o programa Visual Studio e torna-se a abrir o projecto,
isto porquê?
As definições de Layout são carregadas com o projecto, como inicialmente foi aberto no
modo de Layout SnapLines foi assim que ele carregou, ao mudar para o SnapToGrid, o
IDE só vai conseguir carregar correctamente as definições no proximo reinicio.
2. Iniciação ao Visual Basic
2.1 Iniciar, Guardar e Fechar Projectos
Para iniciar um projecto, selecciona-se File, New e depois Project, onde é aberta
seguinte janela:
2) Dá-se o nome
ao projecto
1) Selecciona-se Visual
Basic, expande
Windows e escolhe
Windows Forms
Application
3) Ok para criar o
projecto

8.
7
Surge então o projecto para ser trabalhado/construido.
A medida que se for trabalhando no projecto, deve-se guardar o mesmo, para isso
selecciona-se a opção File, depois Save(nome do projecto), para aparecer esta opção
antes de guardar, selecciona no Solution Explorer(*) o projecto, pode também utilizar-
se a sequencia de teclas CTRL+S (save) o que facilita tempo de trabalho.
Para Fechar o project, utiliza-se o File, Close Solution ou se pretender sair do programa
no File e depois Exit, aqui também se pode utilizar as teclas de atalho ALT+F4.
2.2 Palavras Reservadas:
No Visual Studio .Net, seja que o tipo de linguagem de programação que se utilize,
existem palavras reservadas.
Mas que significa isto?
Significa que não é possivel usa-las para elementos de programação, como variaveis ou
procedimentos. Pode-se no entanto evitar a restição usando colchetes [ ], o que não é
recomendado, pois pode tornar o código elegivel e pode levar a erros dificeis de
encontrar.

9.
8
Vejamos algumas palavras reservadas:
AddHandler AddressOf Alias And
AndAlso As Booleano ByRef
Byte ByVal Call Case
Catch CBool CByte CChar
CDate CDbl CDec Char
CInt Dim Each Else
ElseIF End Endif Erro
Goto If() IsNot Loop
Set Then True When
While With Xor Or

10.
9
2.3 O “Debugging”?
O Visual Basic sempre ofereceu um depurador “debugging” para auxiliar o programador
na tarefa de depuração.
O depurador é um recurso que podemos usar para verificar o código durante a sua
execução.
Enquanto o programa esta a rodar, podemos usar o depurador para ver o conteúdo das
variáveis , acompanhar passo a passo a execução de cada linha código , parar o
processamento numa determinada linha de código e desviar o processamento de linhas
de código. Sem duvida, sem o depurador a vida como programador seria muito mais
difícil e sujeita a erros.
Para parar o processamento numa determinada linha de código, usa-se os Pontos de
Interrupção (BreakPoint).
Antes de executar o programa escolhe-se a linha onde se quer que a execução do
programa pare, basta clicar com o rato sobre a mesma ou posicionar o cursor na linha e
tecla F9, ao correr o programa quando a linha for chamada o programa congela,
mantendo todas as condições de execução, variáveis de memória, etc
 Se quiser continuar a execução linha a linha pressione a tecla F8 e o programa será
executado sequencialmente exibindo cada linha executada.
 Se quiser continuar a executar a partir da linha do breakpoint pressione F5 ou selecione
a opção Continue do menu Debug.
 Para desactivar o breakpoint selecione a opção Disable Breakpoint no menu Debug.
 Para remover o breakpoint basta clicar com o botão direito do rato sobre o breakpoint
e selecionar a opção: Disable Breakpoint
EndIf, GoSub, Variant e Wend são mantidas como palavras-
chave reservadas, embora não sejam mais usadas no Visual Basic.

11.
10
 Para remover todos os breakpoints selecione a opção Clear All BreakPoints do
menu Debug.
 Para saltar uma ou mais linhas de código posicione na linha a partir da qual quer
continuar a execução se clique com o botão direito do rato seleccionando -Set Next
Statement.
 Para executar uma rotina inteira de uma vez seleccione a opção Step Over no
menu Debug.
Examinando variáveis
Durante a depuração pode-se inspecionar o conteúdo de uma variável de memória de
forma automática, basta posicionar o cursor do rato sobre a variável para visualizar o
seu valor atual.
Quickwatch
Pode-se visualizar o valor de uma variável e também alterar o seu valor usando a
opção QuickWatch do menu Debug. Para usar este recurso deve-se indicar no código o
que se deseja inspecionar.
As etapas são as seguintes:
1. Marque um ponto de interrupção no código.
2. Execute a aplicação
3. Quando a linha de interrupção for atingida marque a variável que deseja visualizar
e tecle SHIFT+F9 ou selecione QuickWatch do menu debug.
Se selecionarmos a opção - Add Watch - a variável selecionada vai ser exibida na
janela Watch. Pode-se incluir desta forma mais de uma variável na janela Watch para
visualizar seu conteúdo durante a execução do código.

12.
11
• Name - a variável selecionada
• Value - O valor actual da variável
• Type - O tipo de dados da variável
Para alterar o valor de uma variável basta seleccionar a variável, ativar o QuickWatch e
alterar o seu valor. Lembre-se sempre que a sua alteração será processada pela
aplicação e que qualquer modificação só terá efeito se a fizermos antes da execução do
código onde a variável é alterada.
A janela Locals
Para ver o conteúdo das variáveis locais declaradas na rotina actual, basta selecionar a
janela Locals no menu Debug.
A janela Immediate
Esta janela permite que se altere o comportamento do programa , interagindo
directamente com ele e realizando testes para verificar a execução do código.
Pode-se efetuar operações usando as variáveis de memória do nosso código ou
executando novos comandos que não existam no código.
Para ativar a janela no menu Debug selecione Windows.

13.
12
2.4 A Ajuda do Visual Basic
O Visual Basic possui um sistema de ajuda (help) bastante útil, que permite entre outras
coisas:
 aceder a manuais da linguagem;
 ver exemplos de código e copiá-los para janelas de código do utilizador,
modificando-os, se necessário;
 obter ajuda por tópicos ou por palavra-chave;
 obter ajuda sensível ao contexto, seleccionando um objecto ou uma palavra-
reservada no écran e clicando em F1.
2.5 Criação de Módulos e Procedimentos
Os módulos servem para armezenar códigos de procedimentos e funções.
Os procedimentos são usualmente criados nos módulos, mas também podem ser
criados nos Forms.
Um procedimento é constituido por um cabeçalho e pelo código respectivo.
Sintaxe para a criação de procedimentos:
[Public|Private] [Static] Sub nome[(lista_argumentos)]
[ instruções]
[Exit Sub]
[ instruções]
End Sub
Sintaxe para a criação de funções:
[Public|Private] [Static] Function nome[(lista_argumentos)] [As tipo]
[ instruções]
[nome=expressão]

14.
13
[Exit Function]
[ instruções]
[nome=expressão]
End Function
A diferença entre procedimentos e funções, é que as funções devolvem,
obrigatoriamente, um valor.
3. Operadores de Programação:
3.1 Operadores Aritméticos:
Os operadores aritméticos são a soma, subtração,
multiplicação e divisão. Em algoritmos eles também são
simples e têm a mesma simbologia em todas as linguagens de
programação ( +, -, * e / ). Além desses mais simples, dois
outros operadores aritméticos não recebem muita atenção e
pode ser que você não os conheca, eles são o div e o mod, que
resultam, respectivamente, o quociente (a parte inteira do
resultado da divisão) e o resto da divisão.
3.2 Operadores Relacionais:
Operadores relacionais são utilizados para comparar
valores, o resultado de uma expressão relacional é um
valor booleano (VERDADEIRO ou FALSO).
Os operadores relacionais são: igual, diferente, maior,
menor, maior ou igual, menor ou igual.

15.
14
3.3 Operadores Logicos:
O resultado de um operador lógico é Verdadeiro ou
Falso /True or False).
Os 3 operadores lógicos são:
NOT (negação)
AND (e)
OR (ou)
NOT – Negação de uma única expressão (operador unário)
Exemplo: Supondo que answ = “Y”
Not ( answ = “y”) dá Verdadeiro
AND - Combina duas expressões (operador binário)
Cada expressão deve ser verdadeira para a expressão resultante ser verdadeira.
Exemplo: Supondo que answ = “Y”
(answ = “Y”) And (answ = “y”) dá Falso
OR - Combina duas expressões; uma das expressões (ou ambas as expressões) deve ser
verdadeira para a expressão resultante ser verdadeira.
Exemplo: Supondo que answ = “Y”
(answ = “Y”) Or (answ = “y”) dá Verdadeiro
3.4 Operadores de atribuição:
Operador Descrição Exemplo
= Simples operador de atribuição, atribui valores
de operandos lado direito para o lado
esquerdo operando
C = A + B valor irá atribuir
de A + B para C
+ = Adicionar e operador de atribuição, Acrescenta
operando direito ao operando esquerdo e
atribui o resultado ao operando esquerdo
C + = A é equivalente a C =
C + A

16.
15
- = Subtrair E operador de atribuição, ele subtrai
operando desde o operando da esquerda e
atribui o resultado ao operando esquerdo
C - = A é equivalente a C =
C - A
* = Multiplicar e operador de atribuição, Ele
multiplica operando direito com o operando da
esquerda e atribui o resultado ao operando
esquerdo
C * = A é equivalente a C =
C * A
/ = Dividir e operador de atribuição, ele divide
operando esquerdo com o operando direito e
atribui o resultado ao operando à esquerda
(flutuante divisão ponto)
C / = A é equivalente a C =
C / A
= Dividir e operador de atribuição, ele divide
operando esquerdo com o operando direito e
atribui o resultado ao operando esquerdo
(divisão Integer)
C = A é equivalente a C =
C A
= ^ Exponenciação e operador de atribuição. Ela
levanta o operando esquerdo para o poder do
operando direito e atribui o resultado ao
operando esquerdo
C ^ = A é equivalente a C =
C ^ A
& = Concatena uma expressão de cadeia a uma
variável String ou propriedade e atribui o
resultado à variável ou propriedade.
Str1 & = Str2 é o mesmo
que
Str1 = str1 & Str2
3.5 Funções Pré-Definidas
Existem várias funções já pre-definidas no Visual Basic, veja-se algumas mais usadas:
Função InputBox:
Esta função permite apresentar uma mensagem ao utilizador, recolhendo ao mesmo
tempo uma string contendo a sua resposta. Assim, ao contrário da função MsgBox (ver
a seguir), esta função produz um resultado do tipo String e não do tipo Integer.

17.
16
Esta função cria um objecto composto, uma Input Box, que consiste numa caixa de texto
e numa label dentro de uma pequena janela.
A sintaxe da função InputBox é a seguinte:
Variável = InputBox ( Mensagem, Título, String_de_Defeito, xpos, ypos )
...em que:
Mensagem - É o texto da mensagem a mostrar na janela.
Título - É o texto a apresentar na barra de títulos da janela.
String_de_Defeito - Este parâmetro é opcional e representa a string que aparece por
defeito na caixa de texto da Input Box.
xpos e ypos - São parâmetros opcionais que indicam a localização horizontal e vertical,
respectivamente, da Input Box no ecrã.
Se não forem indicados a janela aparece no centro do ecrã.
Função MessageBox:
A função MsgBox permite criar caixas de diálogo temporário vulgarmente designadas
por Caixas de Mensagem, contendo um pedaço de texto, um ou mais botões de
comando e, opcionalmente, um ícone ilustrativo da finalidade da caixa de mensagem.
Como o próprio nome indica, a utilidade destas caixas de mensagem consiste em
permitir que o programa transmita alguma informação ao utilizador de forma sucinta.

18.
17
A sintaxe da função MsgBox é a seguinte:
Variável = MsgBox ( Mensagem, Características, Título )
...em que:
Mensagem - É o texto da mensagem a mostrar na janela.
Características - Valor numérico que especifica quais os botões, qual o ícone e qual o
botão por defeito (botão com focus) devem aparecer na janela.
Título - É o texto a apresentar na barra de títulos da janela.
3.6 Precedência e Associatividade:
Regras de Precedência
1.Operadores em expressões contidas entre parênteses
2.Exponenciação
3.Unário positivo e negativo
4.Multiplicação e Divisão Ponto Flutuante
5.Divisão Inteira
6.Operação de módulo
7.Operações de adição e subtração
Operadores Operação Ordem de Evolução (precedência)
() Parenteses Avaliados primeiro. Se os parenteses
estiverem aninhados, a expressão
no par mais interno será avaliada
primeiro. Se houverem vários pares
de parenteses no mesmo nível (não
aninhados), eles serão avaliados da
esquerda para a direita.
^ Exponenciação Avaliados em segundo lugar. Se
houverem vários desses operadores,
eles serão avaliados da esquerda
para a direita.
+, - Operadores de Sinal Avaliados em terceiro lugar. Se
houverem vários destes operadores,

19.
18
eles serão avaliados da esquerda
para a direita.
*, / Multiplicação e Divisão Avaliados em quarto lugar. Se
houverem vários destes operadores,
eles serão avaliados da esquerda
para a direita.
Divisão Inteira Avaliados em quinto lugar. Se
houverem vários destes operadores,
eles serão avaliados da esquerda
para a direita.
Mod Modulo Avaliados em sexto lugar. Se
houverem vários destes operadores,
eles serão avaliados da esquerda
para a direita.
+, - Adição e Subtracção Últimos a serem avaliados. Se
houverem vários destes operadores,
eles serão avaliados da esquerda
para a direita.
4. Fundamentos de Programação
4.1 Variaveis
O conceito de variável é fundamental em qualquer linguagem de programação.
Pode-se dizer que variável é um lugar que usamos para armazenar uma informação que
pode sofrer alterações durante a execução de um programa. Cada variável que usamos
é identificada por um nome e por um tipo.
Se você precisar realizar cálculos que envolvam somente valores inteiros deverá
procurar usar uma variável do tipo Integer , você pode usar uma variável do tipo Long ,
Single e Double mas com isto irá gastar mais memória.
Pode-se criar três tipos básicos de variáveis no Visual Basic, tais como:
Variáveis simples - usadas para guardar valores simples como números e
strings(alfanuméricas).

20.
19
As variáveis simples guardam números e strings, neste caso podemos ter números
pequenos e números maiores , com o intuito de economizar memória podemos dividir
estas variáveis nos seguintes grupos de tipos :
 Inteiros
 Decimais
 Strings e caracteres
 Outras (data , Boolean)
Os inteiros são valores numéricos que não possuem casas decimais e são muito usadas
em qualquer programa Visual Basic. Não gastam muita memória do computador e
tornam o processamento e os cálculos mais rápidos.
Variáveis complexas - usadas para guardar valores mais complexos , vectores e tipos
definidos pelo utilizador.
Variáveis objeto - usadas para guardar variáveis de objecto.
Podemos ver a seguir, variáveis do tipo inteiro:
Tipo de
Dados
Tamanho
em Bytes
Intervalo
Byte 1 0 até 255
Short 2 -32768 até 32767
Integer 4 -2.147.483.648 até 2.147.483.647
Long 8 -9,223,372,036,854,775,808 até
9,223,372,036,854,775,807.
Numeros com casas decimais:
Tipo de
Dados
Tamanho
em Bytes
Intervalo
Single 4 -3.402823x 10^38 ate 1.401298 x 10^-45
(negativos) e
1.401298x10^-45 até 3.402823x10^38
(positivos)
Double 8 -1.79769313486231570E+308 até -
4.94065645841246544E-324 (negativos)
4.94065645841246544E-324 até
1.79769313486231570E+308 (positivos)
Strings e Caracteres
Para tratar de caracteres, palavras, texto, usamos as seguintes variaveis do tipo:
Tipo
de
Dados
Tamanho
em Bytes
Intervalo
Char 2 0 até 65535 (sem sinal).

21.
20
String Depende da
plataforma
até 2 bilhões de caracteres
Outros tipos de variáveis:
Tipo de
Dados
Tamanho
em Bytes
Intervalo
Boolean 2 True ou False
Date 8 01/01/100 até 31/12/9999
A maneira mais simples de usar uma variável é usar a palavra chave Dim (dimension)
seguida pelo nome da variável , a palavra chave AS e o tipo da variável.
Exemplo: Dim vbFormacao as String
4.2 Formulas:
Existem no Visual Basic inúmeras fórmulas para diversas utilizações, muitas delas que
nem sabemos da sua existência nem sabemos para que serve. Existem fórmulas para
quase tudo!
Mostra-se algumas formulas:
INT()
Finalidade: Retorna a parte inteira de um número.
Sintaxe: Int(Número)
Obs.: Número – Qualquer expressão numérica válida. Se número contém Null, o valor
de retorno será Null também.
Exemplo:
Rnd()
Finalidade: Retorna um número aleatório (random).
Sintaxe: Rnd[(Número)]
Obs.: Número – Qualquer expressão numérica válida. Esta função retorna um valor
menor que 1 e maior ou igual a zero.

22.
21
Exemplo:
4.3 .NET Framework
Microsoft .Net Framework é uma plataforma que fornece ferramentas e tecnologias de
que necessita para criar aplicações em rede, bem como serviços Web distribuídos e
aplicações Web. O Framework .Net fornece o tempo de compilação necessário e a base
de tempo de execução para criar e executar qualquer linguagem que esteja em
conformidade com a Common Language Specification (CLS).
Os dois principais componentes do .NET Framework são Common Language Runtime
(CLR) e .Net Framework Biblioteca de classes (FCL).
1. Common Language Runtime (CLR):
A parte principal do .NET Framework, que desenvolve a base da arquitetura, é Common
Language Runtime (CLR). CLR actua como uma ponte que é usada para manipular código
na execução. É a parte central do .NET Framework e é responsável pelo gerenciamento
de memória e pelo gerenciamento de threads. Desta forma, o Common Language
Runtime (CLR) no .NET Framework reforça a segurança e também fornecer precisão de
código que é essencial para fornecer segurança. Portanto, o gerenciamento de código
no momento da execução é o papel principal do Common Language Runtime (CLR) no
.NET Framework. Dois tipos de códigos estão disponíveis no Common Language Runtime
(CLR) no .NET Framework:
 Código gerenciado : código que direciona o Common Language Runtime (CLR)
no .NET Framework
 Código não gerenciado: código que não direciona diretamente o Common
Language Runtime (CLR) no .NET Framework
2. Biblioteca de Classes de Framework (FCL):

23.
22
A Framework Class Library (FCL) no .NET Framework também é uma parte principal do
.NET Framework. A biblioteca de classes inclui as classes reutilizáveis (tipos) que são
baseadas na orientação do objeto. Esta parte é altamente imperativa ao desenvolver
aplicações. Os aplicativos podem ser desenvolvidos usando a interface de linha de
comando (CLI) ou a interface gráfica do utilizador (GUI). Várias plataformas incluem
formulários Windows, Web Forms e ASP.NET. Os serviços XML baseados na Web
também são usados para desenvolver aplicativos.
A sincronização principal é necessária ao escrever um código. Um código escrito em CLS
deve sincronizar com aquele escrito em outro idioma baseado em CLS.
4.4 Estruturas de Controlo
Num programa, os mecanismos usados para controlar qual a instrução que vai ser
executada a seguir, são designados por estruturas de controlo de fluxo, uma vez que
controlam o fluxo da execução do programa.
Em Visual Basic, podem-se identificar duas classes de estruturas de controlo, temos:
 Estruturas condicionais ou de decisão
o If…then
o If…Then…Else
o Select Case
 Estruturas repetitivas
o Do…Loop
o For…Next
o For Each…Next
As estruturas condicionais, permitem a execução de determinados blocos de código
fonte, segundo um conjunto de condições que se verificam ou não.

24.
23
Estrutura If…Then
Estrutura If…Then…Else
Estrutura Select…Case
Formato:
If condição then instruçao
Formato Alternativo:
If condição then
[bloco de instruções]
End If
Formato:
If condição then
[bloco de instruções]
Else
[bloco de instruções]
End If
Formato Alternativo:
If condição then
[bloco de instruções]
ElseIf condição 1 then
[bloco de instruções]
Else
[bloco de instruções]
End If
Formato:
Select Case expressão
Case valor1
[bloco de instruções]
Case valor2
[bloco de instruções]
.
.
Case Else
[bloco de instruções]
End Select

25.
24
Estruturas repetitivas ou Ciclos:
Estrutura Do…While
Estrutura Do…Until
Estrutura For…Next
Estrutura For Each…Next
Esta estrutura tem um uso semelhante a estrutura For…Next, mas usado para percorrer
vectores ou colecções de objectos. É especialmente util se não se souber o tamanho da
colecção.
Formato 1:
Do While condição
[bloco de instruções]
Loop
Formato 2:
Do
[bloco de instruções]
Loop While condição
Executa o ciclo zero ou mais vezes Garante a execução do ciclo pelo
menos uma vez
Formato 1:
Do
[bloco de instruções]
Loop Until condição
Formato 2:
Do Until condição
[bloco de instruções]
Loop
Garante a execução do ciclo pelo
menos uma vez
Executa o ciclo zero ou mais vezes
Formato:
For contador=inicio To fim [incremento]
[blobo de instruções]
Next [contador]
O incremento pode ser positivo(apenas se
inicio <=fim) ou negativo (apenas se
inicio>=fim)

26.
25
4.5 Mecanismos de Passagem de parâmetros/valores
Os valores/parâmetros podem ser passados por valor (BVal) ou por referência (ByRef).
Quando passar por valor?
 Se o elemento de código de chamada que é subjacente ao argumento é um
elemento não modificável, declare o parâmetro correspondente ByVal.
Nenhum código pode alterar o valor de um elemento não modificável.
 Se o elemento é subjacente modificável, mas você não deseja que o
procedimento para poder alterar seu valor, declare o parâmetro ByVal.
Somente o código de chamada pode alterar o valor de um elemento modificável
passado por valor.
Quando passar por referência?
 Se o procedimento possui uma necessidade genuína de modificar o elemento
subjacente no código de chamada, declare o parâmetro correspondente ByRef.
 Se a execução correta de código depende do procedimento que alterar o
elemento subjacente no código de chamada, declare o parâmetro ByRef. Se
você a passagem por valor, ou se o código de chamada substitui ByRef que passa
pelo mecanismo incluindo o argumento entre parênteses, a chamada de
procedimento pode produzir resultados inesperados.
ByVal ou ByRef?
Qual é a utilidade de enviar uma variável por referência ao invés de enviar por valor?
Quando passamos uma variável por valor, seja qual for o código executado na Sub ou
na Function, o conteúdo da variável depois da execução permanecerá o mesmo, isto é,
nada que for feito dentro da rotina vai alterar a variável na origem.
Quando passamos uma variável por referência, como estamos passando na verdade o
endereço da variável, toda alteração que for realizada nesta variável, o conteúdo do
endereço de memória passado por referência será modificado. Seria como se
criássemos uma imagem de nossa variável, que qualquer alteração em qualquer dos
pontos, irá refletir no outro.

27.
26
5. Estrutura de Dados
É um ramo da computação, que estuda os diversos mecanismos da organização de
dados para atender aos diferentes requisitos de processamento.
Uma estrutura de dados, pode ser dividida em 2 pilares fundamentais, Dados e Estrutura
5.1 Vectores:
É uma estrutura de dados mais simples e das mais utilizadas. Os vectores podem ser
unidimensionais ou bidimensionais.
As suas principais características são:
 Adição e pesquisa de novos elementos de forma aleatória
 Acesso aos elementos através de índices
 Possuem tamanho finito de elementos
 Carregam dados de tipos específicos
 Indexação com inicio em 0 (zero)
 Unidimensionais (apenas linha)
 Bidimensionais, linhas e colunas (formato matriz)
Pilha:
Dados:
Elemento que possui valor
agregado e que pode ser utilizado
para solucionar problemas
computacionais.
Os dados, possuem tipos
especificos.
Estrutura:
É um elemento estrutural
responsável por carregar as
informações dentro de uma
estrutura de software.
Dados:
Inteiro (int)
Texto (string)
Caracter (char)
Ponto Flutuante (float)
Ponto Flutuante (double)
Estrutura:
Vectores Multidimensionais
Pilhas
Filas
Listas

28.
27
É uma estrutura de dados, amplamente utilizada e que implementa a ideia de
pilhas de elementos.
Tem como características:
 LIFO – (Last In First Out)
 Permite a adição e remoção de elementos
 O elemento a ser removido é sempre o mais novo
 Simula a ideia de pilhas de elementos
 Para que o acesso de um elemento da pilha ocorra, os demais acima
devem ser removidos.
Lista:
É uma estrutura de dados, também bastante utilizada e que implementa a ideia
de lista de elementos
 FIFO – (First In First Out)
 Permite a adição e remoção de elementos
 O elemento a ser removido é sempre o primeiro a entrar
 As operações de entrada e saída, sempre ocorrem nas extremidades.
Outras estruturas:
 Arvore
 Arvores binarias
 Pilhas, Listas e Filas Dinâmicas
 Grafo
 Tabelas Hashing
 Etc…
As estruturas de dados, são muito utilizadas em aplicações de nível mais baixo, tais
como:
 Implementação de estrutura de bases de dados
 Compiladores e interpretadores
 Editores de Texto
 Etc…

29.
28
5.2 Matrizes/Arrays:
Um array (matriz) é uma lista de valores onde todos os valores no grupo são
referenciados pelo nome da matriz e o índice atribuído ao valor específico na matriz.
Um valor individual de um array é chamado elemento. Os arrays são criados na
memória do computador e por isto possui um bom desempenho no seu tratamento.
Cada elemento possui um número relacionado que é utilizado como índice da
matriz.
Existem mais de uma maneira de declarar um vetor unidimensional em Visual Basic,
seguem alguns exemplos:
Dim Vetor(4) As Integer
Define um array com 5 elementos iniciados com zero
Dim Vetor As Integer = new Integer(4) {}
Define um array com 5 elementos iniciados com zero
Dim Vetor() As Integer = {1, 2, 3, 4, 5}
Define um array com 5 elementos e atribui valores a cada elemento
Podemos considerar uma matriz como sendo uma tabela rectangular de números reais
(ou complexos) dispostos em m linhas e n colunas. Diz-se então que a matriz tem ordem
m x n (lê-se: ordem m por n)
Exemplos:
A = ( 1 0 2 -4 5) Um a linha e cinco colunas ( matriz de ordem 1 por 5 ou 1 x 5)
B é uma matriz de quatro linhas e uma coluna, portanto de ordem 4 x 1.
Notas:
1) se m = n , então dizemos que a matriz é quadrada de ordem n.

30.
29
Exemplo:
A matriz X é uma matriz quadrada de ordem 3x3 , dita simplesmente de ordem 3 .
5.3 Enumerações:
A enumeração é um novo recurso disponível a partir do VB 5.0 que fornece uma forma
conveniente de tratar um conjunto relacionado de constantes e de associar os valores
destas constantes com os nomes atribuídos a elas.
Um tipo enumerado é declarado usando a instrução Enum. A declaração Enum declara
uma enumeração e define os valores de seus membros. A declaração enum pode ser
utilizado no módulo, classe, estrutura, procedimento ou nível de bloco.
Por exemplo,
Enum Colors
red = 1
orange = 2
yellow = 3
green = 4
azure = 5
blue = 6
violet = 7
End Enum

31.
30
O exemplo a seguir demonstra declaração e uso da variável Enumerar Colors:
Module constantsNenum
Enum Colors
red = 1
orange = 2
yellow = 3
green = 4
azure = 5
blue = 6
violet = 7
End Enum
Sub Main()
Console.WriteLine("The Color Red is : " & Colors.red)
Console.WriteLine("The Color Yellow is : " & Colors.yellow)
Console.WriteLine("The Color Blue is : " & Colors.blue)
Console.WriteLine("The Color Green is : " & Colors.green)
Console.ReadKey()
End Sub
End Module
Quando o código acima é compilado e executado, ele produz o seguinte resultado:
The Color Red is: 1
The Color Yellow is: 3
The Color Blue is: 6
The Color Green is: 4

32.
31
6. Windows Forms
6.1 Design de forms e Controlos
O design de formulários e dos respectivos controlos, é efectuado no Forms, quando se
opta pelo Windows Form é aberto um primeiro formulário em branco, formulário esse
que se começa a desenha com os controlos pretendidos.
A posição exata dos controles no formulário é uma prioridade alta para muitos
aplicativos. O Windows Forms Designer fornece várias ferramentas de layout para fazer
isso, uma das mais importantes é o recurso SnapLine ou SnapToGrid.
As linhas de ajuste facilitam a alinhar os controles, para uma maior nítida e profissional
aparência.
Os controlos a adicionar, encontramos na Caixa de
Ferramentas (ToolBox)
Nesta ToolBox encontramos os diferentes controlos
existentes, pode-se adicionar caixas de texto, botões de
comando, ou seja, botões que ao selecionar irão fazer algo que
se mande, entre outros controlos.

33.
32
6.2 Propriedades:
As propriedades, sejam dos controlos, sejam do
formulário, vamos encontrar no Properties no
lado direito.
Dependendo do controlo selecionado vamos ter
propriedades diferente e alguns comuns a todos.
Por exemplo, num Controlo de Texto (TextBox),
encontra-se propriedades como Font, onde se
seleciona o tipo de fonte a usar na caixa de texto,
Text Align, referefe-se ao alinhamento do texto,
Enable, se o caixa de texto esta ou não activa,
Multiline, se pretendemos que a caixa de texto
tenha mais que uma linha para ser escrita, entre
outras…
Cada controlo tem as suas propriedades, algumas
são iguais outras são características.
Nas propriedades de um Form, por exemplo,
podemos por exemplo mudar o Nome do
Formulário (Form= a aparecer, a cor de fundo do
mesmo, entre outros a explorar.
6.3 Eventos de Formulários e Controlos:
Tanto no formulário (Form) como nos controlos pode-se aplicar eventos.
Eventos são ordens que o utilizador dá para que quando aquele formulário abra, feche
ou inicialize faça, ou o controlo quando selecionado faça.
Pode-se por exemplo colocar um evento num botão que quando carregado
simplesmente feche a aplicação ou que quando selecionado faça uma pesquisa, ou abra
outro formulário.

34.
33
7. Acesso e Gestão de Base de Dados:
Com o Visual Basic assim como em outras linguagens de programação, pode-se fazer o
acesso a bases de dados. Este acesso pode ser feito de diferente modos, através de
bases de dados em Access (Microsoft Access), por ODBC (em que se pode ligar daods de
Excel ou Access) , por SQL Server, entre outros.
7.1 Criar Base de Dados
A base pode ser criada conforme dito atras em diferentes formatos, neste caso será
criada em Microsoft Access.
É criada uma base de dados de Endereços.
O acesso é feito pela barra de ferramenta, na TAB Data Sources e é escolhido o modelo
de base de dados (DataSet).
Para realizar a ligação com a base de dados pode-se usar a tecnologia ADO .NET da
plataforma .NET.
Criar uma ligação com uma fonte de dados significa usar o componente apropriado e
fornecer informações ao componente para que ele possa encontrar a base de dados e
poder aceder a informações a partir dela.
7.2 Ligação Base de Dados:

35.
34
Depois de escolher Database, seleciona-se NEXT e em New Connection no ecran
seguinte, seleciona-se o caminho da base de dados, depois NEXT outra vez.

36.
35
Salva-se a ligação, e a seguir tem-se as tabelas existentes na base de dados. Escolhe a
que pretende visualizar e seleciona Finish.
Após isto, tem-se acesso a tabela em questão. No formulário, pode-se aceder aos dados
ou desenhando as caixas de texto, combobox, listbox o que for necessário, ou de uma
forma mais simples, pode-se no DataSource, selecionar a tabela e depois arrastar os
campos pretendidos

37.
36
7.3 Consultar, Inserir, Actualizar Dados
Com o método de arrastar os campos pretendidos, passa-se a poder consultar a base
de dados, ao correr a aplicação (STAR) ou F5, tem-se acesso ao Formulário e a
informação…
O método de consulta, inserção e actualização da base de dados, faz-se pelo controlo
que é adicionado quando adicionados os campos.