1. Visual Studio.Net
Autor:
Paulo Cesar Macedo

2. Apostila de VISUAL STUDIO .NET
1 - Introdução ao Visual Basic .NET .....................................................................................................3
1.1 – Hardware necessário para instalação ........................................................................................3
1.2 – Conceitos para o desenvolvimento de aplicativos Microsoft ...................................................4
2 - Estudo da Linguagem Visual Basic .NET ........................................................................................8
2.0 – Arquivos gerados pelo Visual Basic .NET ...............................................................................8
2.1 - Nova Estrutura do programa escrito em VB .Net....................................................................10
2.2 – Atribuir nomes aos elementos do seu programa .....................................................................11
2.3 – Utilizando quebra de linha e combinação de código ..............................................................11
2.4 – Caracteres especiais no VB .Net .............................................................................................12
2.5 – Criar comentários no Código ..................................................................................................12
2.6 – Limitações do Visual Basic .NET...........................................................................................13
2.7 - Compilação Condicional .........................................................................................................13
2.7.1 – Criando Constantes de declaração Condicional...............................................................14
2.7.2 – Ocultando ou expandindo o código .................................................................................14
2.8 – Técnicas de codificação e programação .................................................................................14
2.9 – Declarando Elementos ............................................................................................................20
2.10 – Tipos de Dados .....................................................................................................................27
2.10.1 – Estruturas de dados ........................................................................................................37
2.10.2 – Matrizes (Arrays) ...........................................................................................................38
2.11 – Objetos ..................................................................................................................................44
2.12 – Strings ...................................................................................................................................46
2.13 - Constantes e Enumerações ....................................................................................................49
2.14 – Operadores ............................................................................................................................52
2.15 – Procedures (Procedimentos) .................................................................................................62
2.16 - Collection (Coleções) ............................................................................................................73
2.17 - Estruturas de Controle de Fluxo ............................................................................................76
2.18 - Visual Basic .NET e a programação orientada a objeto ........................................................84
2.18.1 – Early bound e Late bound ..............................................................................................85
2.18.2 – Palavra chave New e liberando recursos do Sistema.....................................................86
2.18.3 – Trabalhando com Grupos de Objetos ............................................................................87
2.18.4 - Obtendo informações de uma classe ..............................................................................88
2.18.5 - Classes ............................................................................................................................89
2.18.6 – Propriedades, Campos e Métodos de uma Classe..........................................................98
2.18.7 – Eventos e Delegar ........................................................................................................103
2.18.8 – Interfaces no VB .NET ................................................................................................110
2.18.9 – Herança (Inherits) ........................................................................................................112
2.18.10 – Construtores e Destrutores na hierarquia de classes ..................................................118
2.18.11 – Polimorfismo..............................................................................................................120
2.18.12 – Criando um hierarquia de heranças............................................................................122
2.19 – Operações com Componentes COM...................................................................................123
2.20 – Multithreading.....................................................................................................................125
2.21 – Drivers, Pastas e Arquivos ..................................................................................................129
2.21.1 - A classe System.IO.......................................................................................................129
2.21.2 – Acessando arquivos com as funções internas do VB...................................................130
2.21.3 – Acessando arquivos com FileSystemObject................................................................138
2.22 – Manipulando exceções (Exception) ....................................................................................141
2.22.1 – Manipulador estruturado de exceções..........................................................................141
2.22.2 – Manipulador de exceções não estruturado ...................................................................143
3 – Visão Geral da Tecnologia .NET Framework .............................................................................146
3.1 – Infraestrutura NET ................................................................................................................146
2

3. 1 - Introdução ao Visual Basic .NET
A Microsoft lançou as versões mais significativas do Visual Basic, conforme abaixo :
• Visual Basic 1 – Facilitou a criação de aplicativos DESKTOP para Windows.
• Visual Basic 4 – Incluiu a nova tecnologia COM2 que permitia a criação de controles OCX,
arquivos DLL e servidores EXE para Windows.
• Visual Basic .NET – Incorpora uma nova Tecnologia denominada .NET Framework,
especialmente criada para Internet, Aplicativos Servidores, Componentes e XML.
O pacote Visual Studio .NET substitui e aposenta o Visual Studio 6.0 e anteriores, assim como o
Visual Basic .NET substitui e aposenta o VB 6.0, 5.0 e 4.0. O VB .NET faz parte do pacote Visual
Studio .NET.
Agora, o Visual Basic 7.0 ou Visual Basic .NET (pronuncia-se DOT NET) pode ser usado para criar
qualquer aplicativo Windows Cliente, Servidor, Internet, não precisando usar nenhuma outra
ferramenta.
O Visual Basic só trabalha com a Tecnologia .NET e de agora em diante qualquer aplicativo criado
com o Visual Basic .NET é GERENCIADA e não mais interpretada ou nativa (VB 6.0), além disso,
utiliza novos recursos de desenvolvimento procedentes do C++.
O Visual Basic é uma ferramenta denominada pela Microsoft de RAD – Rapid Application
Development que possibilita a criação de aplicativos rapidamente sem preocupar-se com os detalhes
da programação Windows, é portanto uma ferramenta de alta produtividade.
O Visual Basic é a combinação de três componentes :
Visual – É o componente que é usado para criar a Interface Gráfica de Usuário (GUI), assim você
usa os objetos pré-construídos para criar a sua tela. Se não fosse por intermédio desse componente,
você seria obrigado a digitar linhas e mais linhas de código para “desenhar” uma simples janela,
além de utilizar as centenas de funções API do Windows. O ambiente visual é conhecido como IDE
(integrated Development Enviroment) que possui um kit de ferramentas para o desenvolvimento.
Basic – É a linguagem Basic criada em 1964, adicionado de Métodos, Funções, Comandos,
Propriedades e Eventos. Tudo isso foi herdado do Ambiente gráfico do Windows.
Plataforma .NET – É um conjunto de centenas de classes e objetos pré-construídos pela Microsoft
para serem utilizados na codificação do aplicativo, além disso possui vários arquivos distribuídos a
serem compilados junto com o aplicativo.
O VS vem originalmente em 4 versões Academic, Professional, Enterprise Developer e Enterprise
Architect, sendo que a última é a versão mais completa.
1.1 – Hardware necessário para instalação
O Visual Studio .Net não pode ser instalado em sistemas operacionais Windows 95, 98, Me. Além
disso para instalar as ferramentas de desenvolvimento Web é necessário o Windows 2000 Server ou
NT com o IIS (Internet Information Service) instalado na máquina.
Hardware necessário para cada versão do VS .NET :
Hardware Enterprise Architect Enterprise Professional Academic
3

4. Developer
Processador Pentium II-, 450 MHz Mesmo Mesmo Mesmo
Recomendado: Pentium III -
600MHz
RAM Windows 2000 Professional — Mesmo Mesmo mesmo
96 MB; Windows 2000 Server
— 192 MB; Windows NT4.0
Workstation — 64 MB;
Windows NT 4.0 Server — 160
MB; Windows XP Professional
— 160 MB
Recomendado: 128 MB - 2000
Professional, 256 MB - 2000
Server, 96 MB - Workstation,
and 192 MB - NT 4.0 Server,
192 MB - XP Professional
Espaço em Disco 500 MB no drive do sistema, 3 Mesmo Mesmo mesmo
GB drive de instalação
Sistema Windows® 2000, Windows Mesmo Mesmo mesmo
Operacional XP, ou Windows NT 4.0
CD-ROM ou Recomendado Recomendado Recomendado Recomendado
DVD-ROM
Video 800 x 600, 256 cores Mesmo Mesmo mesmo
Recomendado: High Color 16-
bit
Mouse Qualquer Mesmo Mesmo mesmo
Para melhor o desempenho do VS .NET desligue o antivírus na instalação; desfragmente o disco
rígido; faça um upgrade da memória.
Para melhorar a velocidade na inicialização do VS .Net feche a janela de propriedades da IDE; feche
a janela Start Up da IDE; feche a janela Dynamic Help. Observação desmarque a opção de abrir estas
janelas automaticamente.
1.2 – Conceitos para o desenvolvimento de aplicativos Microsoft
Este capítulo foi incluído para explicar o significado de alguns termos que a Microsoft utiliza na
documentação oficial, e no treinamento para a certificação.
Para desenvolver aplicativos Windows, a Microsoft utiliza a Modelagem de Aplicativos Enterprise
(EAM - Entreprise Application Model) que envolve seis etapas :
• O Modelo de Desenvolvimento – Processo de desenvolvimento do software.
• O Modelo de Negócios – Define o objetivo do software.
• O Modelo do Usuário – Refere-se a interface, documentação, treinamento, suporte e
configuração ao usuário.
• O Modelo Lógico – Define a estrutura lógica e a modelagem dos objetos e serviços do
software.
• O Modelo Tecnológico – Define a reutilização dos componentes do software, do sistema, do
gerenciamento dos recursos.
4

5. • O Modelo Físico – É o produto final que engloba os componentes, a distribuição e a
interconecção.
Para o programador VB a fase mais importante das descritas acima é o Modelo de Deesenvolvimento
(Model Development) que é o intermediário entre o Modelo de Negócios e os Modelos do Usuário,
Lógico e Tecnológico.
1 - O Modelo de desenvolvimento
O modelo de desenvolvimento envolve três etapas :
• Desenho Conceitual (Conceptual Design) – Trata o sistema do ponto de vista do usuário.
• Desenho Lógico (Logical Design) – Identifica os objetos e serviços do negócio.
• Desenho Físico (Physical Design) – Implementa o desenho lógico incluindo as soluções
específicas de hardware e software.
O Desenho Conceitual irá considerar o perfil do usuário, isto é quem é o usuário e como ele irá
trabalhar com o sistema, além disso o perfil do usuário engloba sua função ou cargo.
O desenho conceitual também deve considerar o cenário atual em uso, isto é quantos usuários
utilizam o sistema atual e as situações de uso.
E finalmente o desenho conceitual deve considerar o cenário proposto para o uso, isto é quantos
usuários deverão utilizar o novo sistema e as situações de uso.
2 – O Desenho Lógico
Para criar o desenho lógico é preciso seguir os passos abaixo :
1. Identificar os objetos e serviços do negócio
2. Definir a interface
3. Identificar as dependências do objeto
4. Validar o desenho lógico
5. Revisar e refinar o desenho lógico
Uma entidade que representa os modelos lógicos ou físicos é chamado de business object (Objeto
de Negócio, ou Objeto comercial), isto é representar as situações ou funções de uma empresa em
um objeto no sistema. Um business object pode retratar :
• Contas
• Clientes
• Vendas
• Faturas
O desenvolvimento do software irá implementar esses objetos para criar seus membros tais como
propriedades e métodos para interagirem com outros objetos. Para identificar um business object é
necessário determinar os nomes dos cenários em uso e os verbos dos cenários em uso.
Os nomes dos cenários podem ser determinados pelos diversos departamentos ou seções que irão
utilizar o aplicativo, e serve como base para identificar os verbos para compor o objeto.
Os verbos podem ser indicados pelos termos Possui ou Tem; Usa; Contém ou Guarda ou Consiste;
É um exemplo de ou É um.
5

6. 3 – O Desenho Físico
Para criar o desenho Físico a partir do Desenho Lógico é preciso seguir estes passos :
• Definir o tipo de serviço aos componentes – Cria os componentes a partir dos objetos lógicos
já definidos e determina se cada objeto é um usuário, um negócio ou um objeto de serviços de
dados.
• Distribuir o componente na rede – Definir o local do componente na rede.
• Refinar a distribuição dos componentes – Agrupar os componentes de acordo com as
necessidades do sistema.
• Definir os membros do componente – Define o relacionamento entre os componentes.
• Validar o desenho físico – Certificar que cada componente corresponde ao serviço no objeto
lógico.
Um desenho lógico bem efetuado vai ter um impacto positivo na criação do desenho Físico. A forma
de medir o impacto do desenho lógico no desenho físico é observar se as considerações abaixo
podem ser alcançadas.
• Performance (Desempenho)
• Maintainability (Manutenciabilidade)
• Extensibility (Extensibilidade)
• Scalability (Escalabilidade)
• Availability (Disponibilidade)
• Security (Segurança)
Performance
A performance (desempenho) é a velocidade e a eficiência que o sistema executa as tarefas. O
desempenho tem que ser considerado pelo ponto de vista dos recursos do sistema, isto é o total de
recursos que o sistema utiliza para executar a tarefa. E do ponto de vista do usuário, isto é o tempo
gasto que o sistema utiliza para executar a tarefa.
Entretanto é necessário ter um ponto de equilíbrio entre o desempenho e outras considerações em
relação ao software, pois o código que incrementa a performance pode afetar outros aspectos do
sistema.
Maintainability
O sistema que permite uma boa manutenção, isto é revisão do código fonte pelos programadores, é
aquele que evita um longo trabalho de revisão e a participação de usuários no processo.
O sistema pode centralizar todos os componentes em um único lugar de forma a substituir o
componente debilitado pelo componente corrigido. Outro caso seria dividir os componentes em
pequenos pedaços de forma a isolar o problema em áreas específicas
O ideal é dividir os componentes em pequenos pedaços de código e centralizá-los em um único
lugar, assim um sistema cliente servidor pode centralizar os pedaços dos componentes no servidor e
permitir que a manutenção seja feita no próprio servidor sem a participação do usuário no processo.
Extensibility
6

7. Extensibilidade é a capacidade de integrar outros aplicativos ao sistema. Para alcançar a
extensibilidade pode-se utilizar as regras abaixo :
• Dividir os serviços do sistema em pequenos componentes que possuem membros e executem
tarefas específicas que possam ser reutilizáveis por outros sistemas.
• Criar componentes COM ou .NET que podem ser sempre utilizados em outras plataformas.
• Se o sistema for WEB utilize os serviços do IIS Internet Information Service para enviar
informações ao Browser dos usuários.
Scalability
A escalabilidade é a capacidade que um sistema possui de mudar de um ambiente de pouca utilização
para um ambiente de intensa utilização do sistema sem afetar suas funcionalidades. O ambiente de
intensa utilização pode envolver :
• Aumento do número de usuários
• Aumento do tráfico do sistema na rede
• Serviços que utilizem os dados do aplicativo
Assim a escalabilidade também está ligada a performance do sistema, entretanto a escalabilidade é
mais especializada que a performance pois trata de técnicas que ajudam na melhoria do desempenho
de redes, distribuição de dados, servidores de dados, camadas de dados e etc.
Availability
Um sistema deve estar disponível na maior parte do tempo possível e na maioria dos lugares em que
for acessado. Para que um sistema esteja sempre disponível é necessário observar a natureza do
sistema e outros fatores tais como :
• Área local
• Rede
• Internet
• INtranet
Security
A segurança de um aplicativo está voltado a formas de evitar acessos externos e total controle da
administração do sistema. Para melhor segurança o sistema deve estar centralizado em um único
lugar para melhor administração e evitar acessos externos.
7

8. 2 - Estudo da Linguagem Visual Basic .NET
2.0 – Arquivos gerados pelo Visual Basic .NET
Quando iniciado um projeto em VB, o sistema cria os arquivos com extensão .vb, além de outros que
podem ser incluídos no projeto tais como arquivos ASP que tem a extensão .aspx; arquivos XML
com extensão .xml; arquivos HTML com extensão .html e outros. Assim não há distinção de
arquivos de classes, janelas, controles e etc, pois todos terão a partir de agora a extensão .vb.
Item do projeto Extensão Descrição
Janela .vb Janela para aplicativos Desktop.
Classe .vb Arquivo de código para classes
Modulo (Visual Basic) .vb Arquivo que agrupa funções
Component Class .vb Uma classe de componentes.
User Control .vb Controle para aplicativos
Data Form Wizard .vb (.aspx para Uma janela de dados
projetos WEB.)
DataSet .xsd Arquivo DataSet para criar esquemas XML
Arquivo XML .xml Arquivo XML
Esquema XML .xsd Arquivo para criar Esquemas de documentos XML.
Code File .vb Arquivo de código
Custom Control .vb Classe para criar controles para aplicativos Windows.
Página HTML .htm Página HTML que inclui código.
Inherited Form .vb Janela baseada em outra janela existente.
Web Custom Control .vb Classe para criar um controle servidor ASP.NET.
Inherited User Control .vb Novo controle baseado em um controle existente.
Windows Service .vb Classe para criar Serviços Windows.
COM Class .vb Classe baseada em componente COM
Transactional .vb Classe para usar componentes transacionais.
Component
Arquivo texto .txt Arquivo de texto
Frameset .htm Arquivo HTML que possui várias páginas HTML.
Arquivo XSLT .xslt Arquivo usado para transformar documentos XML
StyleSheet .css Arquivo estilo planilha para definições HTML
Installer Class .vb Classe para ser chamada em processos de instalação.
Crystal Report .rpt Um relatório Crystal Report
Arquivo Bitmap .bmp Arquivo bitmap.
Arquivo de Cursor .cur Cursor padrão
Icone .ico Ícone padrão
Arquivo Assembly .resx Arquivo usado para armazenar recursos para o aplicativo
Resource
Arquivo Assembly .vb Arquivo que contém informações do Assembly.
Information
Arquivo Application .config Arquivo usado para configurações do aplicativo.
Configuration
8

9. Arquivo JScript .js Arquivo contendo código JScript
Arquivo VBScript .vbs Arquivo contendo código VBScript
Windows Script Host .wsf Arquivo que contém Script que é executado como um
aplicativo Windows.
Arquivos de um projeto WEB
Arquivos Extensão Descrição
Janela Web 2 arquivos: .aspx Uma janela WEB.
.vb
Web Service 2 arquivos: .asmx Componente que troca mensagens usando os protocolos
.vb padrões HTTP, XML, XSD, SOAP e WSDL.
Class .vb Arquivo de classe.
Modulo (Visual Basic) .vb Arquivo que agrupa funções
Component Class .vb Classe de componentes
Data Form Wizard .aspx (.vb para Uma janela de dados para aplicativos WEB.
projetos locais)
DataSet .xsd Arquivo para esquemas XML usando DAtaSet
Web User Control .ascx Controle servidor ASP.NET
Página HTML .htm Página HTML que inclui código
Frameset .htm Um pagina HTMP que inclui várias páginas HTML.
Style Sheet .css Arquivo estilo planilha usado para definições HTML
Arquivo XML .xml Arquivo XML .
Esquema XML .xsd Arquivo esquema para documentos XML.
Arquivo XSLT .xslt Arquivo usado para transformar documetnos XML
Web Custom Control .vb Controle ASP.NET server.
Arquivo de código .vb Arquivo de código
Dynamic Discovery .vsdisco Arquivo baseado em XML usado para descobrir o caminho
Document do servidor WEB.
Static Discovery .disco Arquivo de mecanismo de procura para servidores XML
WEB.
Global Application .asax Arquivo para manipular eventos ASP.NET
Class
Web Configuration .config Arquivo de configuração para aplicativos WEB
Texto .txt Arquivo de texto
Installer Class .vb Classe chamada em processos de instalação..
Crystal Report .rpt Arquivo Crystal Report
Bitmap .bmp Imagem Bitmap
Cursor .cur Cursor Padrão
Icon File .ico Ícone padrão
Assembly Resource .resx Arquivo de recursos utilizado pelo aplicativo
File
Assembly Information .vb Informações gerais do assembly
File
JScript File .js Código JScript
VBScript File .vbs Código VBScript
Windows Script Host .wsf Arquivo para Windows scripting..
9

10. Em versões anteriores do VB, as janelas tinham extensões .frm, os controles tinham extensões .ctr, as
classes tinham a extensão .cls.
Ainda hoje, os arquivos do Vb podem ser abertos por qualquer programa de texto e podem ser
alterados diretamente sem usar o Ambiente de Desenvolvimento do Visual Studio.
2.1 - Nova Estrutura do programa escrito em VB .Net
A nova estrutura do programa deve seguir essas etapas:
1. Utilize os comandos Option para verificar os erros de lógica e de sintaxe.
2. Utilize o comando Imports para acessar os recursos da tecnologia .NET Framework.
3. O procedimento Main ( ) será o ponto inicial do programa, ou seja o código que será
executado em primeiro lugar.
4. Utilize os comandos Class, Module ou NameSpace se for criar objetos para o programa.
5. Utilize comandos de compilação condicional #if .. #else... se necessário.
Exemplo 1 :
' Programa escrito em Visual Basic .
Option Explicit
Module Olá
Sub Main( )
MsgBox("Olá Mundo!") ' Exibe a Mensagem na tela.
End Sub
End Module
A primeira linha funciona como comentário. O Comando Option obriga declarar todas as variáveis
antes de utilizá-las no programa.
No exemplo acima, no módulo “Olá” está o procedimento Sub Main ( ) que vai controlar a execução
do processo e exibir a mensagem “Olá Mundo” na tela do computador.
Quando criamos um programa em VB escolhendo Windows Application na janela de opções, o
Visual Studio .NET cria um projeto contendo referências e uma classe chamada sempre de form1.vb.
Exemplo 2 :
Public Class Form1
Inherits System.Windows.Forms.Form
‘ O código abaixo foi criado automaticamente pelo Visual Basic
#Region " Windows Forms Designer generated code "
Public Sub New()
MyBase.New()
' This call is required by the Windows Forms Designer.
InitializeComponent()
' Add any initialization after the InitializeComponent() call.
End Sub
' Form overrides dispose to clean up the component list.
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
If Not (components Is Nothing) Then
10

11. components.Dispose()
End If
End If
MyBase.Dispose(disposing)
End Sub
No exemplo acima, O VS .net criou o protótipo central para ser modificado, contendo uma janela
Form1 que possui o código inicial da janela Sub New que é o construtor da janela onde é colocado o
código de inicialização da janela que substitui o antigo evento Initialize do VB 6.0.
Resumindo, quando a janela é carregada na tela, o primeiro procedimento a ser executado será o
código dentro de Sub New, também conhecido como Construtor (proveniente da linguagem C++).
InitializeComponent( ) é criado automaticamente pelo VStudio e substitui o antigo arquivo .frm que
era criado pelo VB 6, onde continha todo as propriedades e códigos fonte da janela em formato de
Texto.
Resumindo, InitializeComponent( ) grava todas os controles, textos, figuras e outras coisas que
forem feitas na janela.
O comando inherits na primeira linha do exemplo acima herda todas as características de uma janela
normal. Assim pode-se alterar suas propriedades na janela de propriedades do VB.
Resumindo, para criar uma janela é preciso acionar a classe Windows Form da tecnologia .NET
Framework.
2.2 – Atribuir nomes aos elementos do seu programa
Quando for nomear (dar nome as variáveis, objetos ou classes) os elementos do seu programa a
Microsoft recomenda usar as seguintes técnicas.
• Começar cada Nome com letra maiúscula , Exemplo : ConvertaPrimeiraLetra.
• Quando nomear uma função ou método inicie com a ação que ela executa. Exemplo :
CarregarFiltro; IniciarProcura; FecharJanela.
• Quando nomear uma Classe ou uma propriedade da classe inicie com o nome a que se refere
a classe . Exemplo : CarroAcessórios; EmpregadosSalário; ArquivosNome.
• Quando nomear uma Interface (Interface) no seu programa, inicie com a letra I maiúscula
seguida da ação ou comportamento dessa interface. Exemplo : IPersistente; IAleatório.
• Quando nomear eventos para sua classe, inicie com a palavra “Event” ou “Evento”. Exemplo:
EventoFechar; EventoAbrir.
• Se for usar um evento que foi disparado no momento da ação ou depois da ação, utilize os
verbos no presente ou passado. Exemplo : EventoFechar; EventoFechou; EventoAbrir;
EventoAbriu.
• Para nomes muito grandes utilize abreviações. Exemplo : HTML (abreviação de Hyper Text
Marquet Language).
• Não use nomes idênticos no mesmo módulo ou procedimento, o ideal é utilizar nomes
completamente diferentes em todo o programa.
2.3 – Utilizando quebra de linha e combinação de código
11

12. No momento da codificação os comandos estiverem extensos demais, pode-se quebrar a linha em
diversas partes sem gerar erros de execução. Utilize o “Caracter de continuação de Linha” ( _ ) após
um espaço simples, em seguida continuar a escrever o código em outra linha.. Exemplo :
Data1.RecordSource = _
"SELECT * FROM Titles, Publishers" _
& "WHERE Publishers.PubId = Titles.PubID" _
& "AND Publishers.State = 'CA'"
Assim, a linha de código fica mais fácil de ler na tela do seu computador, entretanto existe uma
limitação para o número de linhas.
Para combinar muitas linhas de código em uma única linha utilize dois pontos ( : ). Exemplo :
Text1.Text = "Olá" : Vermelho = 255 : Text1.BackColor = Vermelho
2.4 – Caracteres especiais no VB .Net
Alguns caracteres possuem significados diferentes na linguagem, veja a seguir :
1. Parênteses : Use parênteses para criar um procedimento ou função. Exemplo : Sub Main ( ).
2. Separadores ( : ) : Os dois pontos ( : ) são usados para separar blocos de
código na mesma linha. Exemplo : Text1.Text = "Olá" : Vermelho = 255 :
Text1.BackColor = Vermelho
3. Concatenação : Para combinar duas variáveis Strings, utilize o operador de concatenação &.
Exemplo :
Var1 = "10.01"
Var2 = 11
Result = Var1 + Var2 ' Result = 21.01
Result = Var1 & Var2 ' Result = 10.0111
Não use o operador “ + “ para concatenar duas string, pois pode gerar erros. Observe os
resultados do exemplo acima.
4. Operador de acesso ( . ) : O ponto é utilizado para acessar funções, métodos ou propriedades
de uma classe ou objeto. Exemplo : MyForm.Text = "This is my form"
5. Operador de acesso ( ! ) : A exclamação também é utilizada para acessar métodos ou
propriedades somente de algumas classes ou estruturas. Exemplo :
RS.Fields!CustomerID.Value = txtCustomerID.Text
6. Caracter de declaração de tipos de dados ( ! ) : O ponto de exclamação também pode ser
utilizado para declarar variáveis do tipo Single. Exemplo : Var = 1234578!
2.5 – Criar comentários no Código
Para cada linha de código, pode-se criar um comentário explicando o significado do procedimento,
este tipo de linha é ignorado pelo compilador. Utilize o símbolo de comentário ( ‘ ) para ativar o
comentário. Exemplo :
' Este é um comentário no início do código
Text1.Text = "Hi!" ' Este é um comentário na mesma linha do código
12

13. A Microsoft recomenda criar comentários para cada seção de código dessa forma :
1. Propósito : Inclua esse tópico no comentário, para identificar qual a descrição ou tarefa do
código em questão.
2. Requisitos : Inclua esse tópico no comentário, para identificar quais variáveis, objetos,
classes e outros elementos utilizados no código em questão.
3. Efeito : Inclua esse tópico para identificar quais variáveis, objetos, classes e outros elementos
que serão afetados pelo código em questão.
4. Argumentos : Inc.ua esse tópico para explicar os argumentos exigidos pelo código em
questão.
5. Retorno : Inclua esse tópico para identificar o valor de retorno desse código em questão.
Não se pode quebrar linhas em comentário, utilizando o caracter ( _ ). Pode-se utilizar o comando
REM para ativar comentários, entretanto esse procedimento requer mais espaço em memória que o
símbolo ( ‘ ), portanto utilize o símbolo somente.
2.6 – Limitações do Visual Basic .NET
As versões anteriores do VB tinham várias limitações no código, veja abaixo :
• Número de variáveis usadas no mesmo código.
• Número de funções usadas no mesmo código.
• Número de arquivos abertos no mesmo código.
• Número de janelas abertas no mesmo código.
• Dentre outras...
No VB .NET existem limitações físicas, segundo a Microsoft, mas são tão altas que não há chances
de serem atingidas pelo desenvolvedor, a ponto de não serem nem documentadas oficialmente.
2.7 - Compilação Condicional
Quando se executa um programa, o compilador inicia a leitura do código fonte indistintamente até o
final. Entretanto esse comportamento pode ser alterado utilizando a Compilação Condicional.
A compilação condicional faz com que o compilador execute certos blocos de código enquanto
outros são ignorados. É útil quando se deseja usar comandos para certos tipos de Sistemas
operacionais em uso, ou utilizar dicionários para uma língua de um país, etc..
Para aplicar esse recurso use o comando de diretiva # if ... #Then ... # Else . Além disso pode-se criar
uma constante a nível de compilação usando o comando de diretiva #Const . Exemplo :
‘Cria uma compilação para a versão de um programa de língua Francesa ou Alemã, note
‘que FrenchVersion e GermanVersion são constantes predefinidas pelo VB.
#If FrenchVersion Then
' <código para a lingua francesa>.
#ElseIf GermanVersion Then
' <código para a lingua alemã>.
#Else
' <código para outras versões>.
#End If
13

14. 2.7.1 – Criando Constantes de declaração Condicional
Constantes são variáveis que não podem ser alteradas. As constantes de declaração condicional são
variáveis que não podem ser alteradas e também não podem ser acessadas pelo código geral.
Pode-se criar constantes com caixa de diálogos de propriedades, por linha de comando ou por
comandos em código. Para criar constantes condicionais por comandos em código, utilize #Const.
Exemplo :
#Const MeuPaís = "BRASIL"
#Const Versão = "8.0.0012"
#Const NúmeroPadrão = 36
2.7.2 – Ocultando ou expandindo o código
No VB .NET há um recurso que permite ocultar ou expandir o código escrito no Editor de Códigos, é
semelhante ao Windows Explorer ao visualizar os diretórios e subdiretórios do sistema. Quando um
diretório possui subdiretórios, o sistema exibe um sinal de mais ( + ) ao lado do nome do diretório
corrente, informando que há outros elementos nele. Basta clicar sobre o ( + ) para visualizar os outros
elementos.
Assim funciona esse recurso, que pode ser aplicado usando a diretiva #Region. Exemplo :
#Region "O código dentro de Region é ocultado clicando sobre #Region"
Private components As System.ComponentModel.Container
Dim WithEvents Form1 As System.Windows.Forms.Form
Private Sub InitializeComponent()
components = New System.ComponentModel.Container
Me.Text = "Form1"
End Sub
#End Region
Esse recurso torna fácil ler e administrar o código fonte do desenvolvedor. Note que não é possível
usar esse recurso quando criar Funções, e qualquer código ocultado ou expandido é lido
normalmente pelo compilador.
2.8 – Técnicas de codificação e programação
É necessário utilizar técnicas para aumentar a produtividade do programador Visual Basic .NET,
além de solucionar grande parte dos bugs dos programas. Além disso utilizando essas técnicas
consolidadas de programação, permite criar códigos de alta qualidade e permite seguir as regras de
criação de software das grandes companhias.
Quando for nomear elementos, utilize as seguintes técnicas :
Rotinas ou Procedimentos
• Quando criar rotinas ou procedimentos, evite usar nomes confusos que não contribuem para
explicar o significado do procedimento. Como por exemplo : Sub AnalizeIsto ( ).
• Quando criar classes, evite citar nomes redundantes para as propriedades, métodos ou
funções dessa classe. Como por Exemplo : Livro.LivroTítulo use : Livro.Título
14

15. • Quando Nomear um método ou Função, dê o nome da ação respectiva. Exemplo :
CalculeRaízQuadrada( ) . Com todas as iniciais em maiúsculas.
Variáveis
• Quando nomear variáveis que armazenarão dados calculados, finalize o nome com a
identificação do cálculo utilizado. Como por exemplo : intSoma, intDiferença, intMax,
intMin, pode-se utilizar até o nome de funções do VB para criar os nomes. intSum,
intAvg, intIndex, etc...
• Use nomes complementares quando forem necessários na mesma operação, tais como Início
/ Fim, Mín / Max, Aberto / Fechado. Exemplo : intInício, intFim, intMín, intMax.
• Para nomear variáveis utilize o primeira palavra em minúsculas e as restantes em
maiúsculas. Exemplo : documentoFormatoIndexado., ou utilize a notação húngara *.
• Para variáveis do tipo Boolean pode utilizar a palavra É, Esta ( Is) para designar se a variável
está na condição True ou False. Exemplo : ArquivoEstáAberto, ou FileIsOpen
• Muitos programadores utilizam a palavra Flag para nomear suas variáveis, entretanto é
preferível substituir a palavra Flag por outro nome que descreva melhor a variável. Exemplo:
ao invés de documentoFlag , use documentoFormatoIndexado.
• Para variáveis utilizadas em loops, dê nomes simples como i, j, x, etc...
• Utilize sempre constantes nomeadas para efetuar loops e outras condições de teste. Como
por exemplo : ao invés de For i = 1 to 7 utilize For i = 1 to intContadorIndexado,
onde intContadorIndexado é uma constante nomeada de valor 7.
* Uma notação especialmente popular é a notação húngara. Ela costuma ser usada na programação
em Windows e no OS/2. No caso da notação húngara, pode-se antecer uma variável String com “str”,
uma variável Integer com “int” , um ponteiro como “p”, funções com “fn”, handles com “h” e assim
por diante. A regra é compor o nome da variável utilizando a abreviação das primeiras letras do
controle, tipo de dados ou uma combinação de suas primeiras letras com um nome de identificação
individual.
A notação húngara foi desenvolvida por um programador da Microsoft chamado Charles Simonyi.
Nos velhos tempos da Microsoft, Charles ficou famoso por dar rasantes de helicópteros nos
piqueniques da empresa.
Tipo do Controle Prefixo Exemplo
3D Panel pnl pnlGroup
ADO Data ado adoBiblio
Animated button ani aniMailBox
Check box chk chkReadOnly
Combo box, drop-down list box cbo cboEnglish
Command button cmd cmdExit
Common dialog dlg dlgFileOpen
Communications com comFax
Controles ctr ctrCurrent
Data dat datBiblio
15

16. Data-bound combo box dbcbo dbcboLanguage
Data-bound grid dbgrd dbgrdQueryResult
Data-bound list box dblst dblstJobType
Data combo dbc dbcAuthor
Data grid dgd dgdTitles
Data list dbl dblPublisher
Data repeater drp drpLocation
Date picker dtp dtpPublished
Directory list box dir dirSource
Drive list box drv drvTarget
File list box fil filSource
Flat scroll bar fsb fsbMove
Form frm frmEntry
Frame fra fraLanguage
Gauge gau gauStatus
Graph gra graRevenue
Grid grd grdPrices
Hierarchical flexgrid flex flexOrders
Horizontal scroll bar hsb hsbVolume
Image img imgIcon
Image combo imgcbo imgcboProduct
ImageList ils ilsAllIcons
Label lbl lblHelpMessage
Lightweight check box lwchk lwchkArchive
Lightweight combo box lwcbo lwcboGerman
Lightweight command button lwcmd lwcmdRemove
Lightweight frame lwfra lwfraSaveOptions
Lightweight horizontal scroll bar lwhsb lwhsbVolume
Lightweight list box lwlst lwlstCostCenters
Lightweight option button lwopt lwoptIncomeLevel
Lightweight text box lwtxt lwoptStreet
16

17. Lightweight vertical scroll bar lwvsb lwvsbYear
Line lin linVertical
List box lst lstPolicyCodes
ListView lvw lvwHeadings
MAPI message mpm mpmSentMessage
MAPI session mps mpsSession
MCI mci mciVideo
Menu mnu mnuFileOpen
Month view mvw mvwPeriod
MS Chart ch chSalesbyRegion
MS Flex grid msg msgClients
MS Tab mst mstFirst
OLE container ole oleWorksheet
Option button opt optGender
Picture box pic picVGA
Picture clip clp clpToolbar
ProgressBar prg prgLoadFile
Remote Data rd rdTitles
RichTextBox rtf rtfReport
Shape shp shpCircle
Slider sld sldScale
Spin spn spnPages
StatusBar sta staDateTime
SysInfo sys sysMonitor
TabStrip tab tabOptions
Text box txt txtLastName
Timer tmr tmrAlarm
Toolbar tlb tlbActions
TreeView tre treOrganization
UpDown upd updDirection
Vertical scroll bar vsb vsbRate
17

18. Lista de nomes de Menus onde a regra é criar um prefino Mnu + Nome do Menu utilizado :
Menu Nome do Menu
File Open mnuFileOpen
File Send Email mnuFileSendEmail
File Send Fax mnuFileSendFax
Format Character mnuFormatCharacter
Help Contents mnuHelpContents
A Microsoft recomenda utilizar uma codificação modular, isto significa que se deve utilizar
variáveis, constantes, controles agrupados dentro de um procedimento que execute uma tarefa única
em um formulário simples. Por exemplo, para acionar uma caixa de diálogo Abrir, devemos colocar
todas as variáveis, controles e flags necessários agrupados em um único botão ou menu “Abrir” que
execute a tarefa de acionar essa Caixa de diálogo, uma vez terminado a execução da tarefa todas as
variáveis e controles são finalizados.
Lista de sugestão de escopo de variáveis (esses prefixos eram muito utilizados em versões anteriores
do Visual Basic, entretanto com a nova formulação da linguagem, essa terminologia quase não se usa
mais) :
Escopo Prefixo Exemplo
Global g gstrUserName
Module-level m mblnCalcInProgress
Local to procedure Nenhum dblVelocity
Para se formar um nome de constante adequadamente, a regra é utilizar o prefixo do escopo acima +
o prefixo do tipo de dados + as letras iniciais maiúsculas do significado/propósito da constante,
exemplo:
gintIdadeDoAluno ‘ Variável global , do tipo de dados inteiro , Idade do aluno
(g + int + Idade Do Aluno)
mstrNomeDoAluno ‘Variável a nível de módulo, do tipo string, Nome do Aluno
(m + str + Nome Do Aluno)
Use os seguintes prefixos para indicar o tipo de dados da variável (esses prefixos eram muito
utilizados em versões anteriores do Visual Basic, entretanto com a nova formulação da linguagem,
essa terminologia quase não se usa mais):
Tipo de Dado Prefixo Exemplo
Boolean bln blnFound
Byte byt bytRasterData
18

19. Collection object col colWidgets
Decimal dec decRevenue
Date (Time) dtm dtmStart
Double dbl dblTolerance
Error err errOrderNum
Integer int intQuantity
Long lng lngDistance
Object obj objCurrent
Single sng sngAverage
String str strFName
Compound-defined type cdt cdtEmployee
Os nomes de variáveis de tipos definidos pelo usuário (tipos de dados compostos) podem ser
definidos com o prefixo “cdt” , assim cdt + nome da variável / combinação das tres primeiras letras ,
exemplo :
cdtCli‘Uma variável do tipo de dados composto , Cliente
( cdt + Cli)
Tabelas
• Quando nomear tabelas use nomes sempre no singular. Exemplo : ao invés de tabela Alunos
use tabela Aluno.
• Quando nomear campos em tabelas, evite repetir o nome da tabela no Campo. Exemplo : ao
invés do nome do Campo AlunoEndereço utilize o nome Endereço.
• Não utilize o Tipo de Dados do campo para compor o seu nome.
Microsoft SQL Server
• Evite o nome com abreviações, somente use abreviações quando tiver um significado
consistente.
• Quando nomear funções no SQL Server utilize a descrição do valor retornado. Exemplo :
RetorneNomeJanelaAtual( ) .
• Os nomes de arquivos, pastas, procedimentos armazenados devem descrever o seu propósito.
• Evite reutilizar nomes de funções para variáveis ou vice-versa. Exemplo : Função com nome
ProcessarArquivo( ) Variável com nome IProcessarArquivo.
• Evite utilizar homônimos ou palavras com mesmo fonema . Exemplo Rigth e Write.
• Certifique-se que não há erros quando soletrar palavras. Pois algumas palavras possuem
significados diferentes em certas regiões do Globo. Exemplo Check e Cheque não tem o
mesmo significado, Color e Colour não tem o mesmo significado.
• Evite usar marcações especiais quando nomear elementos , tais como $ , %. (utilizadas para
string e inteiros repectivamente).
Comentários
• Quando modificar o código fonte, coloque sempre a data da última modificação.
• No início de cada rotina, coloque os comentários no formato Propósito, Descrição,
Parâmetros, etc.. .( Ver item 3.5).
19

20. • Evite criar comentários no final de linha, pois fica mais difícil de ler. Se for imperativo,
coloque com uma tabulação padrão para todos os comentários desse tipo.
• Evite asteriscos e outros caracteres para criar o comentário, utilize somente espaços.
• Apague qualquer comentário improdutivo no código.
• Utilize palavras completas no Comentário, evite portanto abreviações e símbolos outros.
• Crie comentário para todo o código não óbvio.
• Explique o que consiste o loop e outros blocos de código.
Formato
• Utilize sempre o mesmo tipo de formatação para o código escrito. Isso inclui o tamanho da
letra, o tipo da letra, o espaçamento da letra, a cor da letra, etc..
• Utilize sempre parênteses , chaves e outros, para agrupar conjuntos de códigos para a mesma
finalidade. Exempo if (x >5 and x<10) then ...
• Crie uma tabulação padrão que torne consistente o código para cada bloco dentro de
procedimentos, loops, funções e etc...
• Evite combinar muitas linhas de código em uma linha única , utilizando o separador ( : ).
Exemplo : x = 350 : intContador = 4 : ArquivoEstáAberto = true
• Quando escrever comandos em SQL, utilize letras maiúsculas para palavras chaves SQL e
somente iniciais maiúsculas para Tabelas, colunas e Visões.
• Divida um código complexo em pedaços menores, podendo ser em módulos ou arquivos
separados
• Coloque a Cláusula SQL separados das linhas de comando para facilitar a leitura e edição do
código. Exemplo :
SELECT FirstName, LastName
FROM Customers
WHERE State = 'WA'
2.9 – Declarando Elementos
A linguagem utiliza alguns tipos de instruções tais como :
Palavras-Chaves (KeyWords) – São palavras reservadas da linguagem para construir uma estrutura
de comandos, e não podem ser usadas individualmente.
Comandos (Statements) – São instruções completas que fazem sentido ao compilador e podem
conter palavras chaves, operadores, constantes, expressões. Os comandos são divididos em duas
categorias :
1. Comandos de declaração – Usados para nomear variáveis, constantes, matrizes, definir
procedimentos e objetos.
2. Comandos de execução – Usados para executar uma ação, e englobam todos os comandos
de loop, comandos de decisão e todos os comandos que utilizam operadores matemático ou
condicionais.
Expressões – São séries de elementos que representam valores, separados por operadores que
resultam em outro valor. Utilizam de operadores de comparação para comparar dois valores; utilizam
operadores matemáticos para efetuar operações entre dois ou mais valores; utilizam de elementos
Booleanos para fazer comparações e parênteses para alterar a ordem de cálculos.
A Microsoft não reconheceu os Comandos de atribuição como uma terceira categoria, mas incluiu
na documentação como todos aqueles que utilizam operadores de atribuição.
20

21. Para declarar elementos para uso no código utiliza-se Comandos de declaração ou Palavras-Chaves.
O elemento declarado fica retido na memória do computador sendo gerenciado diretamente pela
tecnologia .NET Framework.
Os elementos declarados no código podem ser constantes, variáveis, objetos, classes, enumerações,
estruturas, propriedades, métodos, funções, eventos, interfaces, delegates (delegar).
O VB ignora letras maiúsculas e minúsculas quando se referir a elementos declarados, portanto pode-
se usar MinhaVariável quanto minhavariável.
Quando se declara elementos, o processo envolve as seguintes considerações :
1. Variáveis – É o espaço reservado dentro da memória do computador, para ser usado no
programa.
2. Comandos de Declaração – São comandos do VB que declaram elementos na memória.
3. Tipo de Dados – É o tipo de dados fundamental que o elemento deverá pertencer.
4. Vida útil (LifeTime) – É o período de execução que o elemento está disponível para ser
usado.
5. Escopo – É a extensão que o elemento deve atingir, sem ser declarado novamente.
6. Acessibilidade – É a forma que o código deve fazer uso do elemento.
7. Nomes Ambíguos – Quando dois elementos têm o mesmo nome, e como o VB resolve este
problema.
1 – Variáveis
Uma variável é um espaço reservado dentro da memória para armazenar valores desconhecidos.
Diferentemente de um ponteiro que representa o local onde ela está endereçada.
Para usar variáveis é necessário aplicar os Comandos de Declaração, utilizando as técnicas de
codificação e programação já explicadas acima. Observe que quando se declara uma variável , o
compilador reserva um espaço na memória para o valor, mas não a cria explicitamente. Para criar
explicitamente uma variável, é preciso declarar a variável e atribuir um valor.
O comando Option Explicit obriga que todas as variáveis sejam declaradas antes do uso.
2 – Comandos de Declaração
Os comandos de declaração são Dim e Const. As palavras chaves (Keywords) são Private, Public,
Shared, Protected, Friend e Static. Exemplo :
Private I As Integer
Dim Amount As Double
Static YourName As String
Public BillsPaid As Decimal
Const Modulus As Single = 4.17825 ‘Esse valor não pode ser alterado.
Public I, J, K As Integer ' Declara três variáveis inteiras.
Dim FirstName, MiddleName, LastName As String ' Declara três variáveis string.
Private S, SArray() As Short ' Uma variável Shor e uma variável de matriz.
Friend B1, B2 As Byte, C1, C2 As Char ' Duas variáveis Byte e duas variáveis Char.
O comando Dim é semelhante as palavras chaves Private e Public. E pode ser usado em
procedimentos, módulos, classes , blocos e estruturas, mas só podem ser acessadas no código que
foram declaradas. A diferença entre Private, Public e Dim é que as duas primeiras permitem ou não
21

22. que essa variável fique disponível a outros blocos de código, portanto são também chamados de
Modificadores de Acesso.
Alguns autores até recomendam não usar o Comando Dim por se tratar de um declarador pouco
expressivo.
A palavra chave Private é um modificador de acesso e declara variáveis em todos os blocos de
código, e assim como o comando Dim, só podem ser acessadas no código que foram declaradas. E
não podem ser acessadas por outros blocos de código.
A palavra chave Public é um modificador de acesso e declara variáveis em todos os blocos de
código, e diferentemente de Dim e Private, permitem que outros códigos exteriores utilizem a
variável.
A palavra chave Shared é um modificador de acesso que declara variáveis em classes, e permitem
que outros códigos acessem essa variável sem fazer uma referência a classe.
A palavra chave Static é um modificador de acesso e declara variáveis em todos os blocos de código
, exceto Classes e Módulos. Variáveis declaradas com Static retém o último valor na memória
mesmo quando o procedimento em que foi declarado é encerrado.
O Comando Const declara variáveis que não podem ser alteradas, e são utilizadas em todos os blocos
de código, entretanto a variável constante fica disponível somente ao código em que foi declarada.
A palavra chave Protected declara variáveis somente dentro de Classes. Variáveis declaradas com
protected só podem ser acessadas dentro da classe que a declarou ou de classes derivadas.
A palavra chave Friend declara variáveis em todos os blocos de código, exceto procedimentos.
Variáveis declaradas com Friend podem ser acessadas por todo o programa.
3 – Tipos de Dados
Para organizar como as variáveis gravam informações na memória, foram criados tipos de dados
elementares, que podem ser numéricos ou caracteres.
Os tipos de dados numéricos podem ser integrais (números inteiros) e não integrais (números
decimais fracionários). Os números inteiros são mais rápidos em processamento que os não
integrais.
Para cada tipo de Dados há uma faixa máxima de informações que podem ser gravados, além disso
certos tipos de dados podem ser sinalizados ou não sinalizados, isto significa que a faixa de
informações podem variar de números negativos até números positivos.
Tipo de Dados Common language Tamanho em Faixa
runtime Bytes
Boolean System.Boolean 2 bytes True ou False
Byte System.Byte 1 byte 0 à 255 (não sinalizado).
Char System.Char 2 bytes 0 à 65535 (não sinalizado).
Date System.DateTime 8 bytes 0:00:00 de 1 Janeiro, 0001 à 11:59:59 da noite de 31
Dezembro, 9999.
Decimal System.Decimal 16 bytes 0 à +/-79,228,162,514,264,337,593,543,950,335 sem
virgula;
0 à +/-7.9228162514264337593543950335 com 28
dígitos depois da vírgula; o número mais próximo do
zero é
22

23. +/-0.0000000000000000000000000001 (+/-1E-28).
Double System.Double 8 bytes -1.79769313486231570E+308 à
(double-ponto -4.94065645841246544E-324 negativos; e
flutuante) 4.94065645841246544E-324 à
1.79769313486231570E+308 positivos.
Integer System.Int32 4 bytes -2,147,483,648 à 2,147,483,647.
Long System.Int64 8 bytes -9,223,372,036,854,775,808 à
(long integer) 9,223,372,036,854,775,807.
Object System.Object (classe) 4 bytes Qualquer tipo de dados..
Short System.Int16 2 bytes -32,768 à 32,767.
Single System.Single 4 bytes -3.4028235E+38 à -1.401298E-45 negativos; e
(single-ponto 1.401298E-45 à 3.4028235E+38 positivos.
flutuante)
String System.String (class) Depende do 0 até 2 bilhões de caracteres Unicode.
sistema
User-Defined (herda de Depende do Determinado pela faixa de cada tipo de dados usado na
Type System.ValueType) sistema estrutura
(estrutura)
O VB .NET manipula os tipos de dados elementares de duas formas :
• Tipo Valor – Quando a variável grava os dados dentro da memória. Assim enquadram-se
todos os tipos de dados numéricos, Boolean, Char, Date, Estruturas e Enumerações.
• Tipo Referência – Quando o sistema aponta para um endereço de memória onde está os
dados. Assim enquadram-se os tipos de dados String, Matrizes, Classes e Forms (Janelas).
A partir do VB .NET cada tipo de dado listado acima, é implementado como uma estrutura e Classe
da tecnologia .NET Framework. Isto significa que cada tipo de dado tem suas próprias funções e
métodos internos.
Basta verificar na coluna Common language runtime (CLR) qual classe pertence o tipo de dado
elementar.
Exemplo :
Dim strTeste as string
Dim intTeste2 as System.Int32
strTeste.Trim ( )
intTeste2.ToString ( )
No Exemplo acima, foi declarado uma variável do tipo String, e foi invocada a função Trim que
remove os espaços em seu conteúdo. Em seguida a variável intTeste2 foi declarada como um tipo de
dados Inteiro da classe .NET Framework, invocando a função ToString que converte os dados para
string.
Outra forma de declarar variáveis, é forçar a variável para tornar-se de um tipo utilizando os
“caracteres de tipo”. Veja a tabela abaixo:
Caracter de tipo Tipo de Dado Exemplo
% Integer Dim L%
& Long Public M&
@ Decimal Const W@ = 37.5
! Single Dim Q!
23

24. # Double Static X#
$ String Private V$ = "Secret"
Caracter de tipo Tipo de Dado Exemplo
S Short I = 347S
I Integer J = 347I
L Long K = 347L
D Decimal H = 347D
F Single Y = 347F
R Double Z = 347R
C Char Q = "."C
4 – Vida Útil (LifeTime)
Vida útil é o período em que a variável mantém o valor na memória. Dependendo como foi declarada
a variável, sua vida útil é igual ao período de tempo que o aplicativo estiver em execução.
Por outro lado, uma variável declarada dentro de um bloco de código, sua vida útil é igual ao tempo
que o procedimento estiver em execução. Assim quando o procedimento termina, a variável finda
sua vida útil e a memória é limpa e fica disponível novamente ao Sistema Operacional.
Quando uma variável é declarada com a palavra chave Shared, sua vida útil é extendida até quando
o aplicativo estiver em uso.
Quando uma variável é declarada com a palavra chave Static, sua vida útil é extendida entre
procedimentos que estiver em uso.
5 – Escopo
O Escopo de uma variável é a seção de um aplicativo que pode ver e manipular uma variável. Deste
modo, uma variável declarada em um procedimento, só pode ser manipulada nesse procedimento, as
outras seções ou blocos de código não podem ver nem manipular essa variável.
O Escopo tem esses níveis :
Escopo de Bloco – A variável fica disponível somente no bloco de código em que foi declarada.
Escopo de Procedimento – A variável fica disponível somente no procedimento que foi declarada.
Escopo de Módulo – A variável fica disponível para todo o código do módulo, classe ou estrutura
que foi declarada.
Escopo de EspaçoNomeado (NameSpace) – A variável fica disponível para todo o código desse
Espaço Nomeado.
6 – Acessibilidade
Acessibilidade é a permissão que uma variável poderá ser acessada ou manipulada. Para definir sua
acessibilidade usa-se as palavras chaves : Public, Private, Friend, Protected, Protected Friend.
Pode-se criar uma variável com escopo de Módulo, mas declarada com private, e nenhum outro
bloco de código poderá ver e manipular essa variável.
7 – Nomes Ambíguos
Quando se declara elementos, o Compilador do VB procura a referência a este nome na declaração.
Se houver mais de um elemento com o mesmo nome, o Compilador utiliza o elemento que estiver no
mesmo Escopo. Exemplo :
24

25. Module Mod1
Public Sub Perform() ' A palavra Chave Public permite acesso de outros procedimentos.
' ...
End Module
Module Mod2
Public Sub Perform() ' Pode ser diferente do cálculo executado em Perform( ) do Mod1.
' ...
Perform() ' Chama somente Perform( ) do Mod2 que é o modulo ativo (mesmo escopo).
Mod1.Perform() ' Chama Perfomr( ) do Mod1.
End Module
Module Mod3
' ...
Mod1.Perform() ' Chama Perform( ) do Mod1.
Perform() ' Chama Perform( ) que é um nome ambíguo e portanto gera um erro.
End Module
O Exemplo acima usa 3 Módulos, Mod1, Mod2 e Mod3. O módulo Mod1 possui um procedimento
declarado como Público chamado Perform( ) e portanto está disponível para acesso por outros
procedimentos. O módulo Mod2 possui outro procedimento declarado como Público também
chamado Perform( ), também disponível para acesso por todos os outros procedimentos. E
finalmente o módulo Mod3 que não possui nenhum procedimento declarado.
Note que tanto Mod1 quanto Mod2 têm um mesmo nome de procedimento Perform( ) (Nome
ambíguo). Quando Mod2 chama esse procedimento, o compilador procura o elemento declarado no
mesmo Escopo, isto é Perform( ) declarado no módulo ativo Mod2. Em seguida, quando Mod2
utiliza Perform( ) declarado em Mod1, utiliza uma descrição mais completa do lugar, informando ao
compilador onde deverá procurar a referência do elemento. Neste caso houve uma qualificação do
nome, e portanto não gera erros de execução.
Quando Mod3 utiliza Perform( ) declarado em Mod1, utiliza uma descrição mais completa do lugar
onde o compilador deverá procurar a referência do elemento.
Quando Mod3 utiliza Perform( ) sem qualificar seu nome, o compilador encontra o procedimento em
Mod1 e Mod2 portanto não sabe qual utilizar, gerando erro de execução.
Ao utilizar procedimentos ou funções de Classes ou Estruturas, é obrigatório qualificar o nome além
de fazer referência à classe ou estrutura. Exemplo :
Dim DemoClass As Class1 = New Class1()
DemoClass.SomeSub( )
No Exemplo acima, foi criado uma variável de referência a classe Class1, em seguida invocou-se o
método SomeSub( ). Não é permitido usar Class1.SomeSub( ) diretamente, pois nesse caso gera
erros de execução.
25

26. No VB .NET há formas de tratar elementos ambíguos, utilizando a técnica de ocultar elementos,
também conhecido como Shadow. Com Shadow um elemento fica ocultado de outro elemento com
mesmo nome além de não ficar disponível.
Há duas formas de usar a técnica de ocultar elementos.
1. Shadowing através do Escopo – No penúltimo exemplo, o procedimento Perform( ) de
Mod2, ocultou o procedimento Perform( ) de Mod1, pois o compilador obedeceu a regra de
Escopo.
Outro Exemplo :
Module Mod3
Public Num As Integer ' Variável a nível de módulo.
Sub Show()
Dim Num As Integer ' Variável Local
Num = 2 'Variável Local agora tem o valor 2.
MsgBox(CStr(Mod3.Num)) ' Exibe o número 0.
End Sub
Sub UseModuleLevelNum()
Num = 1 ' Atribui 1 à Mod3.Num
' ...
Show() ' Chama Show, que exibe o valor da Variável de módulo Num, que agora é 1
End Sub
End Module
No exemplo acima, Mod3 tem uma variável a nível de módulo Num, e dois procedimentos
Show( ) e UseModuleLevelNum( ). No procedimento Show( ) foi declarada uma variável
local ambígua a Num.
Quando o procedimento Show( ) é acionado, o compilador usa a variável local declarada
dentro deste procedimento, ou seja no mesmo escopo do procedimento ativo, portanto a
variável local oculta (shadows) a variável de módulo. Portanto, no exemplo acima, para fazer
referência a variável em shadow é preciso qualificar o seu nome, como Mod3.Num em
MsgBox(CStr(Mod3.Num)).
Quando o procedimento UseModuleLevelNum( ) é acionado, o compilador usa a variável a
nível de módulo, pois não há nomes ambíguos dentro desse procedimento.
2. Shadowing através de Herança – Quando uma classe é derivada de outra, pode-se ocultar
(Shadow) o elemento ambíguo existente na classe básica, utilizando a palavra chave
Shadow. Não se deve confundir Shadow (Ocultar) com Override (Substituir), que será
discutido mais tarde.
Exemplo :
Public Class BaseCls
Public Z As Integer = 100 ' Elemento a ser ocultado (Shadowed).
End Class
Public Class DervCls
Inherits BaseCls
Public Shadows Z As String = "*" ' O Elemento para ocultar o anterior
End Class
Public Class UseClasses
Dim BObj As BaseCls = New DervCls() ' DervCls deriva de BaseCls.
26

27. Dim DObj As DervCls = New DervCls() ' Acessa através da classe derivada.
Public Sub ShowZ()
MsgBox("Classe básica: " & BObj.Z) ' exibe o número 100.
MsgBox("Classe derivada: " & DObj.Z) ' exibe a string "*".
End Sub
End Class
No exemplo acima, há três classes : BaseCLS que é classe básica e DervCLS que é a classe
derivada, e finalmente a Classe UseClasses que utiliza as duas primeiras. A classe básica
possui uma variável numérica pública Z que pode ser acessada por todos os códigos que
utilizam essa classe. A Classe Derivada possui outra variável Z string mas configurada com a
palavra chave Shadows que oculta a variável numérica da classe básica.
UseClasses faz referência as duas classes básica e derivada que muda o valor de cada
variável. Note que a referência de BObj é BaseCls por isso a variável numérica é utilizada
pelo compilador, enquanto que DObj, a variável string é utilizada pelo compilador.
No caso de DObj, o elemento String ocultou (Shadowed) o elemento numérico.
2.10 – Tipos de Dados
Esta seção tem por objetivo estudar os tipos de dados fundamentais e apresentar um novo tipo de
dado composto, além de outros recursos de programação aplicados aos tipos de dados.
O VB .NET, por default, obriga a declaração de todos os elementos antes de usá-los no código.
Exemplo :
Dim MinhaVariável as string
Se não for declarado o elemento no código, o compilador acusa o problema e gera erro. Este tipo de
recurso chama-se Declaração Explícita. Para desligar esse recurso utiliza-se o comando Option
Explicit Off.
Toda vez que o compilador encontrar a declaração Option Explicit Off, qualquer variável não
declarada em código irá ser considerada do tipo Object, entretanto esse tipo de comportamento do
compilador gera potenciais erros de execução além de gerar um aplicativo de desempenho ruim.
É recomendável utilizar em todos os códigos fontes o comando Option Explicit On para obrigar o
compilador varrer todas as variáveis não declaradas.
Quando todas as variáveis são declaradas com o tipo de dados em Option Explicit On, diz-se que os
elementos são Altamente tipificados (Strong Typing), que além de aumentar a velocidade do
aplicativo, se beneficia dos recursos do editor de códigos do Visual Studio, como por exemplo :
• IntteliSense – É um recurso que exibe as propriedades e métodos de um classe,
simultaneamente enquanto se digita no editor.
• Verificação de sintaxe – O compilador verifica a sintaxe do código escrito simultaneamente
enquanto se digita no editor.
1 – Usando tipos de dados Short
27

28. As variáveis do tipo Short podem guardar valores de 16 bits (2 bytes). É o menor tipo de dados
numérico disponível.
As normas aplicadas ao tipo de dados Integer logo abaixo, se aplicam ao tipo de dados Short.
Exemplo :
Dim MeuNúmero as short
Dim NossoNúmero as int16
MeuNúmero = 32767
NossoNúmero = 32768 ‘O VB exibe uma mensagem “NaM Não é um nùmero”
No exemplo acima há duas variáveis declaradas do tipo Short (int16 é a mesma coisa que Short), a
primeira variável recebeu o valor máximo de armazenamento, enquanto que a segunda recebeu um
valor superior a capacidade de armazenamento. O VB acusa o erro exibindo uma mensagem de erro
na compilação “Existem erros, deseja continuar?“.
2 – Usando tipos de dados Integer
Qualquer tipo de dados numérico exige maior processamento do sistema , assim é necessário definir
o tipo adequadamente antes de usar. O tipo Integer armazena dados em 16-bit (2 byte) dentro da
faixa especificada acima, podendo ser utilizada para criar um enumerador (veja posteriormente).
A atribuição de um valor a variável é simples, utilizando apenas o operador de atribuição ( = ) e
nunca utilize separadores de milhares. Qualquer caractere diferente de número não será aceito pelo
VB, gerando erro de Type Mismatch.
VariávelInteger = 1234
Qualquer valor digitado entre aspas ( “ “ ) é uma string por definição, entretanto o VB ativa uma
interpretação correta para o tipo de dados da variável. Veja abaixo :
VariávelInteger = “1234”
O VB não se incomoda com aspas, já que a variável é do tipo numérica, podendo até efetuar
operações matemáticas corretamente, entretanto se houvesse um caractere diferente de número, o
sistema geraria um erro de Type Mismatch. Como no exemplo :
VariávelInteger = “1234A” ‘Tipo Integer não suporta caracteres diferentes de número
Pode-se utilizar um separador de precedência “( ) “ para atribuir o valor numérico a uma variável
integer sem alterar a interpretação do VB. Exemplo :
VariávelInteger = (1234)
Embora o parênteses não seja um caractere numérico, ele possui um significado de ativar a
precedência de primeiro plano em cálculos do compilador, pois desta forma não interfere na
interpretação do compilador VB. Entretanto quando se combina aspas + parênteses na atribuição de
um valor numérico, o resultado é ligeiramente diferente :
VariávelInteger = “(1234)”
Msgbox VariávelInteger
28

29. No exemplo acima, a VariávelInteger terá um valo negativo –1234 exibido na caixa de mensagem
Msgbox. A combinação de aspas e parênteses “( )” troca o sinal de um valor numérico positivo,
transformando-o em negativo. Essa funcionalidade foi inserida neste contexto como simples
curiosidade.
Conclui-se que um parênteses e aspas podem criar uma interpretação diferente no compilador do VB
quando atribuirmos valores a variáveis Integer, portanto devemos nos ater sempre as formas mais
simples e corretas de programação, não devemos portanto “inventar” coisas novas para o sistema
“descobrir” e que poderá levar a resultados imprevisíveis.
Uma variável do tipo Integer, quando não devidamente inicializada com um valor atribuído, tem
como Default o valor zero (0) , assim por exemplo, se um desenvolvedor esquecesse de atribuir um
valor a uma variável Integer, esse valor seria Zero (0) devido a natureza do tipo de dados Integer,
assim é completamente diferente de uma variável String vazia “”.
Exemplo :
Dim MeuInteiro as int32 ‘Mesma coisa que Integer
Dim NossoInteiro as integer
MeuInteiro = 1234
NossoInteiro = 1234
3 – Usando tipos de dados Long
Os tipos de dados Long são armazenados em 32–bits (4 byte), que irremediavelmente necessitam de
mais memória do sistema. Todas as observações referentes ao tipo de dados integer, se aplicam ao
tipo de dados Long, com uma ressalva na capacidade de faixa de dados que este suporta.
Exemplo :
Dim MeuLong As Int64
MeuLong = 10
MsgBox(MeuLong.MaxValue)
MsgBox(MeuLong)
No exemplo acima, foi declarado uma variável do tipo Long (ou Int64) atribuindo o valor 10. Em
seguida foi utilizada uma função interna dessa classe que retorna o valor máximo de armazenamento
desse tipo de dados.
Observe que todos os tipos de dados possuem funções específicas, pois fazem parte de classes da
tecnologia .NET Framework.
4 – Usando tipos de dados Double e Single
Os tipos de dados Double armazenam informações em 64-bits (8 byte) e são especialmente utilizados
para cálculos precisos com números decimais. Os tipo de dados Single armazenam informações em
32-bits (4-bite). Todas as observações referentes ao tipo de dados integer se aplicam aos dados
Double e Single
VariávelDouble = 12.123456789 ‘O grande benefício deste tipo de dados são as casas decimais e
29

30. ‘sua precisão nos cálculos.
Note porém que o VB somente aceita o separador decimal ponto ( . ) ao invés da vírgula, veja
explicações no tipo de dados Decimal logo mais adiante.
5 – Usando tipos de dados Byte
O tipo de dados Byte armazenam informações em 8-bit (1-byte), e são utilizados para conter dados
binários. Pode-se observar que o tipo de dados Byte é também referenciado em banco de dados, onde
é semelhante ao tipo de dados SmallInt em SGBD SQL Server.
Como um exemplo de utilização de dados binários é copiar o conteúdo de um campo de dados no
formato de imagem binária (*.bmp, *.jpg, etc) para outro campo de dados :
Dim MinhaFoto as Byte
MinhaFoto = recordset.Fields(“Foto”).value
No fragmento de código acima, a variável MinhaFoto foi declarada explicitamente como Byte, e foi
atribuída a ela, o campo “Foto” de um objeto de banco de dados Recordset. Assim o conteúdo
binário dessa foto foi armazenada no tipo de dados Byte, que pode ser transferida para outro campo
do banco de dados.
O tipo de dados Byte quando não devidamente inicializado pelo desenvolvedor, terá sempre como
valor Default o zero (0).
6 – Usando o tipo de dados Boolean
Um tipo de dados Boolean armazena dois valores possíveis : Verdadeiro (-1) ou Falso (0) em
números de 16-bit (2-byte). O tipo de dados Booleano contém informações do tipo yes/no, on/off,
true/false. O valor padrão de uma variável do tipo de dados Boolean é sempre false (falso).
Os valores True e False são constantes pré-definidas no VB, que por outro lado poderiam ser
referenciadas como –1 e 0 respectivamente. O uso do tipo Boolean é tipico para operações de
comparação ou como retorno de funções específicas :
VariávelBoolean = ( 1 = 2)
A VariávelBoolean no exemplo acima, terá como resultado o valor 0 (False), decorrente de uma
comparação 1 = 2. Se a expressão de comparação fosse 2 = 2 , o valor de VariávelBoolean seria –1
(True).
Um outro exemplo de comparação entre strings para uso em tipos de dados boolean, confirma a
hipótese de que strings devem ser idênticas na sua construção, onde os caracteres maíusculos e
minúsculos fazem a diferença, neste caso específico de comparação :
VariávelBoolean = ( “Campo” = “CAmpo”)
Os dois elementos são strings semelhantes, entretanto não são idênticas, pois “CA” maiúsculo faz a
distinção com “Ca” , assim o resultado de VariávelBoolean será False.
As propriedades dos objetos, onde é informado true ou false (como por exemplo Enabled) são do tipo
Boolean. Como já foi dito , uma variável Boolean não inicializada com a atribuição , terá como
Padrão o valor False.
30

31. 7 – Usando o tipo de dados Date
Os tipos de dados Date armazenam valores em números 64-bit (8-byte). Quando outros tipos de
dados são transformados para o tipo de dados Date, os números representados a esquerda do valor
decimal é a data, e os números representados a direita do valor decimal é o horário.
Há duas regras para atribuição de datas :
O sinal # ativa o reconhecimento de datas no VB.
Sempre digite datas no formato mm/dd/aa para certificar-se que o sistema interpretará corretamente
os dados, em qualquer região.
Exemplo :
VariávelDate = #12/30/2002# ‘ data no formato mm/dd/aa
Portanto é necessário incluir o sinal # de forma a evitar uma interpretação indevida pelo compilador,
no caso de uma data em string “12/30/2001” o compilador não seria capaz de executar operações
com datas. Exemplo :
VariávelDate1= “12/30/2001”
VariávelDate2 =“11/30/2001”
MsgBox VariávelDate1 – VariávelDate2
O compilador do VB não gera mensagens de erro no caso do exemplo acima, mesmo que as
expressões não estejam devidamente configuradas com o sinal #, entretanto no momento de efetuar
operações com datas, o erro é iminente (Type mismatch).
O exemplo acima seria corretamente configurado quando transformássemos as expressões em datas,
e o resultado final seria 1 mese de diferença entre as datas. Agora o compilador interpreta exatamente
as expressões como datas, permitindo a execução de operações.
VariávelDate1= #12/30/2001#
VariávelDate2 =#11/30/2001#
MsgBox VariávelDate1 – VariávelDate2
O tipo de dados Date também pode receber uma função intrínseca de data do VB, de forma a retornar
como resultado a data e o horário do sistema :
VariávelDate = Now ‘Função Now que retorna a data e hora atual do sistema
Msgbox VariávelDate
O resultado obtido na caixa de Mensagem será : 23/11/2001 18:46:13 como exemplo da construção
acima.
Para um cálculo envolvendo dias, bastaria acrescentar ou subtrair da expressão data um inteiro
simples, como mostrado abaixo :
VariávelDate = #12/01/2001#
Msgbox (VariávelDate –1 )
31

32. A mensagem final seria 01/11/2001, pois foi subtraído 1 dia da data originalmente atribuída a
VariávelDate. Deve-se observar, entretanto que para efetuar operações com datas mais eficiente, usa-
se as funções intrínsecas de datas do VB.
Note sempre que o formato atribuído é mm/dd/aa, caso essa regra não for obedecida, o VB trata de
corrigir o erro, invertendo a ordem das datas automaticamente. Entretanto, não se pode esperar um
bom resultado como por exemplo o dia 01/02/2001, o resultado final seria 02/01/2001 ao invés de
01/02/2001.
O VB foi concebido em língua Inglesa/U.S. , que considera as datas no formato mm/dd/aa,
descartando qualquer possibilidade de formatação diferente, portanto trate sempre de usar essas
regras daqui para frente, de modo a evitar confusões em cálculos e atribuições.
O tipo de dados Date quando não devidamente inicializado pelo desenvolvedor, isto é não for
atribuído um valor de data, terá como valor Default 00:00:00.
8 – Usando o tipo de dados Decimal
Os tipos de dados Decimal são armazenados em números de 128-bit (12-byte) inteiros a potência de
10, que representa o número de casas decimais. Esse tipo de dados, trabalha com números de grande
precisão.
Exemplo :
Dim a As Decimal = 328.558
Dim b As Decimal = 12.4051
Dim c As Decimal
c=a*b
MsgBox(c)
9 – Usando o tipo de dados Object
O tipo de dados Object armazena endereços de 32-bit (4-byte) dos objetos em referência. Esse tipo
de dados é suficientemente flexível para fazer referência a qualquer tipo de objeto reconhecido pelo
sistema. Essa definição de armazenar endereços assemelha-se a um conceito de ponteiros em C++,
guardando suas proporções. Exemplo :
Dim objDb As Object
Set objDb = OpenDatabase("c:Vb5Biblio.mdb")
A variável objDb foi declarada explicitamente como um objeto de banco de dados. Note, que a
declaração foi explicitamente genérica com object, de forma a piorar o desempenho do sistema,
como regra geral tente sempre declarar objetos como Classes a que pertencem ( discussão em
capítulos posteriores), uma forma de pesquisar a classe a que pertence o objeto é o Object Browser.
As variáveis do tipo Object podem ser tratadas do Tipo Valor ou do Tipo Referência já estudadas
anteriormente.
O Valor Nothing é usado para desassociar um objeto a variável. É recomendado desassociar (limpar
da memória) todas as variáveis Object que não forem mais utilizadas no programa. Exemplo :
Dim brush As System.Drawing.Brush
brush = New System.Drawing.Brush(bmap)
......
brush = Nothing
32

33. No exemplo acima, foi utilizado uma variável de objeto que faz referência a um classe da tecnologia
.NET Framework para criar um instrumento de desenho, em seguida após o uso, foi desassociado a
variável do objeto, liberando a memória ao sistema.
10 – Usando o tipo de dados Char
O tipo de dados Char aceita somente caracteres Unicode 2 bytes (16 bit). Pode usar métodos como
IsDigit e IsPunctuation em variáveis desse tipo para determinar sua classificação.
Se o comando de verificação Option Strict estiver ligado, é preciso anexar o caracter Literal para que
o compilador identifique o tipo de variável corretamente. Exemplo
Option Strict On
' ...
Dim CharVar As Char
CharVar = "@" ' Não pode converter String em Char com Option Strict On.
CharVar = "@"C 'Assim pode
11 – Usando tipos de dados String
O tipo de dados String armazenam caracteres alfanuméricos e símbolos padrões de código ASCII ( 0
até 255) que representam todos os caracteres existentes, entretanto há de se mencionar que nem todos
os caracteres dentro dessa faixa são suportados pelo Windows. Há somente um tipo de strings :
• Os strings de tamanho variável (variable-length) que diminui ou cresce a medida que os
dados são adicionados a variável.
Para atribuirmos valores em strings, basta colocarmos esse valor entre aspas “ “ , para ativar a
interpretação do VB para tipos de dados string. Assim :
VariávelString = “Carro”
No caso de uma abstenção no uso de aspas, o VB não interpreta a expressão como string, desde que
ela não ultrapasse uma palavra simples :
VariávelString = Carro ‘O VB não interpreta essa expressão como string
VariávelString = Carro Azul ‘O VB não interpreta como string, mas como uma linha de comando
No exemplo acima, a primeira atribuição não ocorre porque o VB não interpreta a expressão como
uma string válida, assim a VariávelString terá string vazio “”. No último exemplo, o VB interpretou a
expressão como uma linha de comando de código ao compilador, e não como uma expressão String,
neste caso o VB gera uma mensagem de erro em execução ( Esperado final do comando !) , pois a
expressão não é uma palavra simples.
O VB tem uma sensibilidade especial para caracteres numéricos, de forma que não há necessidade de
utilizar-se de aspas para sua atribuição , conforme o exemplo :
VariávelString = 1234
Ou
Variável String = “1234”
Logicamente, não haverá maneira de efetuar qualquer operação matemática, o que pode ser feito é
uma concatenação de variáveis, com resultado de 12341234 (use sempre o operador & , veja em
33

34. capítulo posterior). Por outro lado, se fosse atribuído uma expressão 1234B sem aspas, o caractere
não numérico geraria um erro de execução.
De qualquer forma , é sempre necessário utilizar aspas “ “ para atribuirmos strings a variáveis string,
como uma forma correta de programação, mesmo que seja expressões com números.
Se uma variável String não for inicializada, isto é, se o desenvolvedor não atribuir nenhuma
expressão a ela, o seu valor será vazio “”.
12 – Infinity (Infinito) e outros tipos de dados
No VB .NET há dois tipos de dados não numéricos mas que são produzidos por cálculos numéricos.
• Infinity – Qualquer cálculo que gera números infinitos. Por exemplo dividir um inteiro por
zero.
• NaN – Not a Number (Não é um Número). É qualquer resultado que não corresponde a
valores numéricos.
Exemplo1 :
Dim dblVar As Double = 999
Dim infVar as Double
infVar = dblVar / 0
msgbox (InfVar)
No exemplo acima, não há formas de dividir números inteiros por zero, portanto o resultado da tela
em msgbox é “+Infinito”. Observe que não há um tipo específico de dados que represente Infinity,
portanto é um recurso da linguagem do que propriamente um tipo de dados.
Exemplo2 :
Dim var1, var2 As Double
Dim result As Double
var1 = 0
var2 = 0
result = var1 / var2
MsgBox(result)
No exemplo2, o resultado da divisão de 0 / 0 não é um número, portanto o resultado exibido em
msgbox é “NaN (Não é um Número)”. Assim como Infinity, NaN não é representado por nenhum
tipo de dados específico, mas como um recurso da linguagem.
Pode-se usar as funções IsInfinity e IsNaN para testar o resultado de cálculos matemáticos.
Exemplo:
Dim var1, var2 As Double
Dim result As Double
var1 = 0
var2 = 0
result = var1 / var2
If result.IsInfinity(result) Then
If result.IsPositiveInfinity(result) Then
34

35. MsgBox(“Encontrei um número muito grande. Não posso continuar”)
Else
MsgBox(“Encontrei um número muito pequeno. Não posso continuar”)
End If
Else
If result.IsNaN(result) Then
MsgBox(“Erro no cálculo”)
Else
MsgBox(“O resultado é “ & result.ToString)
End If
End If
13 – Conversões entre tipos de dados
Conversão é um processo que muda um tipo de valor de uma variável para outro tipo de valor. O
comportamento do compilador VB pode mudar quando a opção Option Strict estive ligada ou
desligada, por isso justifica-se estudar esse assunto.
Há dois tipos de conversão no VB :
• Conversão Widening - Conversão com alargamento significa converter um valor de um tipo
de dados de pequena faixa para um tipo de dados de grande faixa de atuação. Assim pode-se
mudar de um tipo de dados integer para um tipo de dados long.
• Conversão Narrowing – Conversão com estreitamento significa converter um valor de um
tipo de dados de grande faixa para um tipo de dados de pequena faixa de atuação. Só pode
converter um tipo de dados long para integer, se o valor máximo da variável long for
suportado pelo tipo de integer, caso contrário gera erro de overflow.
Exemplo 1 de uma conversão do tipo Widening :
Dim meuLongo As Long
Dim meuInteiro As Short
meuInteiro = 32767
meuLongo = meuInteiro
MsgBox(meuLongo) ‘ retorna 32767
Exemplo 2 de conversão Narrowing :
Dim meuLongo As Long
Dim meuInteiro As Short
meuLongo = 32767
meuInteiro = meuLongo
MsgBox(meuInteiro) ‘ retorna 32767
No exemplo 1 ocorreu uma conversão que alargou um valor de uma variável inteira para um valor
long. Enquanto que no exemplo 2 ocorreu um estreitamento de um valor de uma variável long para
um valor inteiro.
35

36. No exemplo 1 o compilador efetuou um conversão implícita, alargando um tipo de dados inteiro
para long sem qualquer interferência do desenvolvedor. No exemplo 2 o compilador também efetuou
uma conversão implícita estreitando um tipo de dados long para integer, pois a opção Option Strict
estava desligada (Option Strict Off).
O compilador efetua uma conversão explícita, quando o desenvolvedor usa comandos de Conversão
de modo a forçar uma conversão de um tipo de dados para outro, esse tipo de conversão é também
conhecida como Casting. Exemplo
Dim meuInteiro as short
Dim MeuLongo as long
meuInteiro = CInt(MeuLongo)
Uma conversão do tipo Narrowing explícita, isto é converter um valor maior para menor com uma
função de conversão do VB, pode gerar perdas nos dados. Uma conversão do tipo Widening
explícita, isto é converter um valor menor para maior com uma função de conversão do VB, pode
gerar perdas no arredondamento decimal de valores no caso de converter um dados do tipo Long
para um Decimal. Pois o tipo Decimal aceita grande quantidade de números após a vírgula enquanto
que Long não aceita números decimais.
A conversão de qualquer tipo de dados string para um tipo de dados numéricos é sempre do tipo
Narrowing. O operador de concatenação ( & ) também funciona como conversor implícito. Exemplo:
Dim meu as integer = 1
Dim nosso as string
Nosso = “Número “ & meu ‘além de concatenar duas variáveis
‘o operador & também funciona como conversor implícito
A função Val do VB .NET pode ser utilizado para conversão de strings. A função varre toda a string
até encontrar um dígito diferente quando termina o processo convertendo somente os números
encontrados. Exemplo :
Dim m As Integer
m = Val ("142 kilômetros")
MsgBox(m) ‘exibe a mensagem 142
Resumindo : O compilador do VB .NET tem duas regras default:
1. Toda variável deve ser declarada antes do uso.
2. Toda conversão do tipo Narrowing deve ser efetuada com funções de conversão
apropriada.
Esse comportamento pode ser alterado desligando o controle de verificação Option Strict Off. Deste
modo todas as variáveis podem ser usadas sem declaração anterior e o tipo de conversão (Narrowing)
pode ser feito implicitamente, isto é sem funções de conversão.
A Microsoft recomenda sempre utilizar conversões explícitas usando as funções de conversão,
para criar um aplicativo de melhor desempenho. Além disso recomenda sempre utilizar o
comando Option Strict On.
36

37. O compilador do VB considera alguns valores como default, como por exemplo qualquer valor
numérico desde que não seja muito alto é considerado Integer; qualquer valor com dígitos
decimais é considerado como Double; qualquer valor muito extenso é considerado Long, e
finalmente qualquer valor com True ou False é considerado Boolean. Assim quando houver erro
em atribuição de valores a constantes ou variáveis, basta forçar o valor da variável utilizando os
comandos de tipo de dados. Exemplo :
Dim myDecimal as Decimal
myDecimal = 100000000000000000000 ' Erro de compilação.
No exemplo acima e conforme as definições acima, o valor 100000000000000000000 é considerado
Double (default) pelo compilador, e a variável myDecimal é do tipo Decimal. Mesmo que o tipo
Decimal suporte o valor acima descrito, ele não pode aceitar o tipo de dados Double (que é muito
maior), portanto o compilador gera um erro. A forma correta de utilização é :
Dim myDecimal as Decimal
myDecimal = 100000000000000000000D ' Ok.
14 – Sistema numérico no VB .NET
Muitos números usados em VB são decimais (base 10). Mas pode ocorrer o uso de números
hexadecimais (base 16) ou números octal (base 8). O Visual Basic representa nrs. Decimais com o
prefixo &H e octal com &O.
Decimal Octal Hexadecimal
9 &O11 &H9
15 &O17 &HF
16 &O20 &H10
20 &O24 &H14
255 &O377 &HFF
O computador pode trabalhar com qualquer número utilizado pelo sistema, entretanto o número
hexadecimal é utilizado em certas tarefas, como o sistema de cores, tela e principalmente as APIs do
Windows.
2.10.1 – Estruturas de dados
As estruturas de dados é uma forma de combinar diferentes tipos de dados para criar uma única
estrutura. Essa técnica é chamada de Tipo de Dados Compostos, pois permite criar tipos de dados
personalizados que eram conhecidos como User Defined Type UDT nas versões do VB 6.0.
Entretanto, como as estruturas permitem criar além de tipos de dados fundamentais, também
propriedades, métodos e eventos, as UDT foram aposentadas, e daqui por diante existirá somente as
Estruturas de Dados.
Para criar uma estrutura, inicie com o Comando Structure e finalize com End Structure. Dentro
desse bloco de código declare as variáveis normalmente. Exemplo :
37