Você está na página 1de 662

Aprenda Visual Basic .

NET
em Dias

Duncan Mackenzie
Kent Sharkey

Tradução:
Aldir José Coelho Correa da Silva

Revisão Técnica:
Marcos Jorge
Consultor Especialista na Platafonna .NET
Analista de Sistemas

PEARSON
Makron
Books

São Paulo

Brasil Argentina Colômbia Costa Rica Chile Espanha


Guatemala México Peru Porto Rico Venezuela
©2003 Pearson Education do Brasil
Título Original: Sams, Teach Yourself Visual Basic .NET in 21 Days
©2002 Sams Publishing
11! Edição em inglês Sams Teach Yourself Visual Basic .NET
in 21 Days publicada pela Pearson Education lnc.,
sob o selo Sams Publishing
Todos os direitos reservados
Diretor Editorial: José Martins Braga
Editora: Gisélia do Carmo Costa
Produtora Editorial: Marileide Gomes
Designer de Capa: Marcelo da Silva Françozo
(sobre o projeto original de Aren Howell)
Editoração Eletrônica: ERJ Composição Editorial e Artes Gráficas Ltda
Impressão: São Paulo - SP

Dados Internacionais de Catalogação na Publicação (CIP)


(Câmara Brasileira do Livro, SP, Brasil)

Mackenzie, Duncan
Aprenda Visual Basic .NET em 2 1 Dias I Duncan Mackenzie, Kent
Sharkey; tradução: Aldir José Coelho Correa da Silva; revisão
técnica: Marcos Jorge. -- São Paulo: Pearson Education do Brasil,
2003.

Titulo original: Sams teach yourself Visual Basic .NET in 21 days.


ISBN : 85.346.1450-4

1. BASIC (Linguagem de programação para computadores) 2. Mi-


crosoft Visual Basic 3. Microsoft Windows (Programa de computador)
1. Sharkey, Kent. li. Título.

02-4239 CDD-005-133


lndices para catálogo sistemático
1. Visual Basic.NET: Linguagem de programação:
Computadores: Processamento de dados 005.133

2003
Proibida a reprodução total ou parcial.
Os infratores serão punidos na forma da lei.
Direitos exclusivos para a língua portuguesa cedidos à
Pearson Education do Brasil,
uma empresa do grupo Pearson Education
Av. Ermano Marchetti, 1435
CEP 05038-001 - Lapa - São Paulo - SP
Tel. (11) 3613-1222 Fax: (1 1) 3611 -0444
e-mail: vendas@pearsoned.com
Dedicatória

De Duncan Mackenzie:
Enquanto trabalhava neste livro, quase tudo em ,ninha vida se modificou, ,nas em 6TJ·ande
parte, isso não estava relacionado com ele. Agora tenho um filho, Connor, me mudei para
outra região e estou co,n um novo trabalho na Microsoft. Gostaria de dedicar este livro a
,ninha esposa, Laura, que sempre apoiou a iniciativa de escrevê-lo, independente,nente de
quantos rneses ultrapassamos o prazo inicial, e a meu filho, que não tinha a niínilna idéia
de que este livro estava sendo escrito e ,nes,no assiln estava ,nuito feliz e solidário. Para
concluir, tenho de agradecer a Kent, porque ele escreveu metade do livro, e não acho que
eu teria sobrevivido se tivesse que fazê-lo sozinho.

De Kent Sharkey:
Em princípio, pretendia parecer inteligente e escrever u,n poema aqui, tnas esse lado de
meu cérebro está com problemas nestes últilnos dias. Portanto, eni vez disso, essa será uma
lista bastante típica de todas as pessoas que me ajudarani neste livro. Gostaria de agrade-
cer ao meu co-autor, Duncan. Obrigaclo pela oportunidade e por nunca aceitar u,n "não"
ou "Desisto" corno reposta. Obrigado a todos os editores que trabalharan1 no livro, princi-
palmente Sondra e Todd. Obrigado a Squirrel por tne tnanter são e salvo e a Cica por dei-
xar meu laptop aquecido e, às vezes, sem atividade. Por último, mas não nienos irnportante,
obrigado a Margaret por ,ne apoiar enquanto trabalhava nesta atividade, um novo trabalho
em u,n novo local. Agora tere,nos nova,nente essa coisa que cha,na,n de fim de semana!
Sobre os Autores
Duncan Mackenzie é profissional certificado MCSD, MCSE e MCT que trabalha para o grupo
MSDN (http://msdn. microsoft.com) da Microsoft etn Redmond, Washington. Ele é um pro-
gra,nador dinâ1nico do Visual Basic .NET que possui o aborrecido hábito de escrever a1iigos
ocasionais. Duncan também atua como instrutor de Visual Basice 1ninistra n1uitos cursos, que
abrange1n da progra1nação interrnediária à avançada do VB. Escreveu vários livros eco.laborou
em tantos outros sobre as tecnologias da Microsoft. E' ainda orador em 111uitas conferências que
enfoca,n o desenvolvimento da Microsoft.

Kent Sharkey é MCSD, MCSE, MCT e MCP+SB. No momento trabalha na Microsoft co1no
Instrutor Técnico no Grupo de Soluções .NET, em que sua ocupação atual é o .NET Framev.1ork
e o Visual Studio .NET. Antes de entrar para a Microsoft, Kent já possuía anos de experiência
co1no instrutor e consultor, concentrando-se e,n projetos e desenvolvimento de aplicativos corn
o uso do Visual Basic. Ele escreveu e colaborou em diversos livros, incluindo sobre MCSD e Vi-
sual Basic. Faz exposições regular1nente ern conferências de desenvolvedores dando ênfase ao
desenvolvimento da Microsoft.
Diga-nos o Que Você Acha!
Como leitor deste livro, você é nosso crítico e colaborador mais importante. Valoriza1nos sua
opinião e queren1os saber o que esta1nos fazendo correta1nente, o que poderíatnos fazer 1nelhor,
sobre quais áreas você gostaria de nos ver publicando e qualquer outra sugestão importante que
deseje passar para nós.

R.eceberemos com satisfação seus cornentários. Você pode enviar um fax, e-mail ou escrever di-
reta1nente, para que possatnos saber do que gostou ou não neste livro-assim co1no o que pode-
mos faze r para tornar nossos livros rneJhores.

Por favor, entenda que não pode1nos ajudá-lo com probletnas técnicos relacionados ao tópico
deste livro e que, devido ao grande vo.lume de correspondência que recebemos, talvez não possa-
mos responder a todas as 1nensagens.

Quando você escrever, ce1tifique-se de incluir o título e o autor deste livro, assim co1no seu
no,ne e nútnero de telefone ou fax. Examinare1nos seus comentários cuidadosamente e os com-
partilhare1nos com os autores e editores que trabalharam no livro.

Fax: (11) 3611 9686


Fone: (11) 3613 1213
Endereço Eletrônico: clientes@makron.com.br e livros_informatica@pearsoned .com.br
Endereço Postal: Pearson Education do Brasil
Rua E1níl io Goeldi, 747 - Lapa
São Paulo - SP/ 05065-1 1O
Aprenda Visual Basic.NET em 21 Dias
1 -
DIA 1 DIA2 DIA3 DIA 4 DIAS DIA 6 DIA 7
Introdução ao Aprenda sobre o Aprenda a criar e usar Aprenda a usar as Aprenda sobre as Aprenda a proteger Os objetos estão e111
Microsoft .NET. a1nbie11te de variáveis e funções de controle e opções de arquitetura seu código de erros e todos os locais da
CoDheça a evolução dese1Jvolvi1ne1Jto do procedirnentos ein iteração no Visua.1 disponíveis Da con10 encontrá-los platafonna .NET.
do Visual Basie .NET Visual Studio .NET e seus progra1nas do Basie .NET. Teste platafom1a .NET e antes dos usuários. Aprenda a trabalhar
acé o que ele é hoje. co1.no você pode Visual Basic .NET. laços, instruções r f e como você pode com eles para
usá-lo para criar 111uito 1nais. escolher urna delas dese1Jvolver sisten1as
aplicativos do Visual para seus sisten1as. por n1eio do Visual
Basic. Bas ic .NET.
- -
DIAS 'DIA 9 DIA 10 DIA 11 DIA 12 DIA 13 DIA 14
Aprenda sobre o Aprenda sobre os Aprenda a criar U1na introdução aos Use o espaço de Veja como o Server Dando continuidade
.NET Frarne\vork, a fomn1lários aplicativos para a bancos de dados e a nome System.Data Explorer torna fácil ao tema abordado no
base da platafonna \Vindows, a \Vorld W ide \.\1 eb atribuição deles em para se conectar, se beneficiar dos Dia 7, aprenda con10
.NET e do Visual tecnologia da usando o Visual seu aplicativo. consultar e atualizar recursos avançados os objetos podern
Basic .NET. plataforrna .NET que Basic .NET e os Aprenda sobre o bancos de dados pelo do Windows. alterar a organização
pennitirá a criação de formulários da Web. espaço de non1e seu código do \fisual e o projeto básico de
interfaces gráficas Systen1.Data da Basic .NET. seus siscemas por
poderosas ern seus platafonna .NET. 1neio da prograinação
aplicativos. orientada a objetos.

DIA 15 DIA 16 DIA 17 DIA 18 DIA 19 DIA20 DIA21 '

Crie seus objetos Aprofunde-se 1nais na Aprenda a acessar Quando a codificação O aplicativo não Aprenda sobre a Aprenda sobre o
completando-os con1 criação de aplicativos arquivos e figuras por estiver concluída, o estará concluído até XML e con10 você SOAP e os serviços
propriedades, corn os fonnulários 1neío das classes do trabalho ai.oda não que os usuários o pode usá-la e,n seus da Web. Veja con10
111étodos e eventos. Windo·ws. Aprenda a Visual Basic .NET e terá acabado. tenhan1 instalado, e prograrnas. eles possibilitan1 o
Aprenda a gerar e gerar n1enus e do .NET Frame1vork. Aprenda a você precisa funcionan1ento de seu
usar n10111agens da trabalhe co1n docu1nentar seu desenvolver o aplicativo na rede ou
biblioteca de classes. controles avançados. sisterna e outras progran1a de na Inte111et.
etapas de finalização instalação. Aprenda a
no desenvolvin1ento cnar esses progran1as
de aplicativos. por 111eio da
cecnologia do
Windo1vs Tnstaller.
Sumário

lntroduç.ão· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · XXI

SEMANA 1 Visão Geral 1

Dia 1 Bem-Vindo ao Visual Basic .NET 3


Compreendendo a Progra1nação de Computadores · · · · · · · · · · · · · · · · · · · · · · · · 3
A f unção dos Sisten1as Operacionais · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 4
O Papel das Linouaoens
::, ::, de Proora1nação·
::, . ··· ·························5
Por Que Escrever Programas de Co1nputador? · · · · · · · · · · · · · · · · · · · · · · · · · · · 8
Utn Breve Histórico sobre o Visual Basic · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 1O

O Qt1e E .NET? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 13
Servidores .NET · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 14
.NET Framework · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 14
Ser·viços .NET · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 15
Dispositivos .NET · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 16
Desenvolvendo seu Primeiro Aplicativo no Visual Basic .NET · · · · · · · · · · · · · · 17
Preparando-se para Codificar · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 17
Onde Está meu TDE? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 2 1
Uma Tarefa Si1nples · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 2 1
Escrevendo o Código · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 22
Rest1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 27
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 27
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 28
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 28
E.xercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 28
Dia 2 Trabalhando com o Visual Basic .NET 29
O IDE do Visual Studio · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 29
lniciando · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 30
A Janela Principal do ID.E do Visual Studio· · · · · · · · · · · · · · · · · · · · · · · · · · 32
Soluções e Projetos· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 50
Arquivos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 5·2
Criando Nosso Primeiro Aplicativo Windov. s · · · · · · · · · · · · · · · · · · · · · · · · · · 53
1

Crie o Projeto· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 54
Desenvolva a Interface com o Usuário· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 54
Executando o Projeto · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 55
Construindo o Projeto · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 56
Adicionando Seu Próprio Código · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 58
Rest.1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 60
X Aprenda Visual Basic .NET em 21 Dias

P& R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 60
Works.hop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 61
Teste······ · ·· ················ · ·· ·· ·· ·· ··· ······ ·· ·· ··· · ···61
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 61
Dia 3 Introdução à Programação com o Visual Basic .NET 63
Variáveis e Atribuição · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 64
O Que É uma Variável? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 64
Tipos de Variáveis Disponíveis· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 64
Variáveis Simples· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 65
Declarando Variáveis · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 69
A.rrays · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 70
Atribt1 ição · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 72
Consta.ntes · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 72
Algumas Sugestões para os Padrões de Nomeação · · · · · · · · · · · · · · · · · · · · · · · 73
Cálculos Simples · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 74
Usando Operadores · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 75
Funções Internas· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 75
Escrevendo Suas Próprias Rotinas · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 80
s·ub-Rotinas · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 80
F·unções · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 81
E-scopo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 81
Exemplo de Aplicativo: Ca.Iculando u,n Valor Futuro· ··· ·· ·· ·· ······· ·· · · 83
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 88
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 89
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 89
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 90
E.xercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 90
Dia 4 Controlando o Fluxo dos Programas 91
Totnando Decisões com as Instruções de Controle · · · · · · · · · · · · · · · · · · · · · · · 91
A Instrução I f · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 92
Estendendo a Instrução I f · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 95
Instruções I f em Seqüência na Mesn,a Linha · · · · · · · · · · · · · · · · · · · · · · · · 99
Expressões e Lógica Booleana· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 00
Operadores de Co1nparação · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 00
Operadores Lógicos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l Ol
Avaliação Abreviada· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 03
Lidando co1n Múltiplas Possibilidades: A Instrução Se 1ect Case· · · · · · · · · · · 104
Laços· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 105
For ... Next · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 106
A Variável do Contador · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 06
Especificando o Valor do Jncre,nento co,n o Uso de Step · · · · · · · · · · · · · · 108
Whi l e ••• End Whi le · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 109
Sumário

Laço Do · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 111
Condições de Saída· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·· · ···· l l3
Laços Infinitos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·· · ···· 114
hnplicações sobre o Desernpenho · · · · · · · · · · · · · · · · · · · · · · · · · ·· · ···· 115
Aplicativos Que Farão Uso de Seu Conhecimento Recém-Adquirido· · ·· · ···· 116
Leitura de um Arquivo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·· · ···· 117
Um Jogo SiJnples · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·· · ···· 119
Evitando Laços Con1plexos por Meio da Recursão · · · · · · · · · · · · · · · ·· · ·· ··
12 1
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 123
P&.R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 123
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 124
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 124
Ex.e1·cfcios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 125
Dia 5 Arquitetura dos Aplicativos na Plataforma .NET 127
O Que É a Arquitetura do Aplicativo?· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 127
Função do Arquiteto de Softwares · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 128
Que Partes de um Sistema São Consideradas Arquitetura do Aplicativo? · · · · 129
Arquiteturas Viáveis na Plataforma .NET· · · · · · · · · · · · · · · · · · · · · · · · · · · · · 133
Os Três Elementos de Qualquer Aplicativo · · · · · · · · · · · · · · · · · · · · · · · · · 133
Quantas Camadas? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 134
Windo\.vs DNA · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 34
Onde a Plataforma .NET Se Encaixa? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 135
Escolhendo uma Tecnologia de Cliente · · · · · · · · · · · · · · · · · · · · · · · · · · · · 136
Decidindo Que Arquitetura Usar · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 138
Fatores Essenciais Que Influenciarão Sua Decisão · · · · · · · · · · · · · · · · · · · · 139
Exernplos de Cenários· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 14 l
Resu. mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 145
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 145
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 146
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 146
Dia 6 O Que Fazer Quando Programas Bons Apresentam Problemas e para
Se Certificar de Que Isso Não Aconteça 147
Tratan1ento, de Exceções Estruturadas · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 48
O Que E o Tratamento de Exceções Estruturadas? · · · · · · · · · · · · · · · · · · · · 148
Erros e Exceções · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 148
O Bloco Try· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 149
A Seção Catch · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 149
Aninhando Blocos Try .. . End Try · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 155
A Seção Fi na 11y · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 15 6
Lançando Exceções · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 57
Dept1ran.do · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 157
A Fonte dos Erros················· · · ·· ········ · ··· · ··· · ··· · ·· 158
XII Aprenda Visual Basic .NET em 21 Dias

Aprendendo a Depurar con1 a Prática· ·· ·· · ··· · ··· · ··· · ·· ·· · ·· · ···· 159


Os Modos na Vida de um Progra1na · ·· ·· · ··· · ··· · ··· · ···· · ·· · ···· 162
Percorrendo Seu Código · · · · · · · · · · ·· ·· · ··· · ··· · ··· · ···· · ·· · ···· 165
Exa1n inando as Variáveis · · · · · · · · · ·· ·· · ··· · ··· · ··· · ···· · ·· · ···· 168
Outras Ferra1nentas para Depuração· · ·· ·· · ··· · ··· · ··· · ···· · ·· · ···· 172
Resu1no · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 173
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 173
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 174
Teste· ·· ··· ·· · ······· · ······· ··· · ·· ··· · ··· ·· ·· ·· ······· · ·· 174
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 174
Dia 7 Trabalhando com Objetos 177
Para Começar: O Que É u,n Objeto? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 177
Classes e Instâncias · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 178
Referências · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 178
Passando o Conceito para o Código· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 179
Propriedades· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 180
Propriedades ReadOn 1y e Wri teOn 1y · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 18 1
Criando a Instância de um Objeto · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 182
Encapsulando Códigos em Suas Classes· · · · · · · · · · · · · · · · · · · · · · · · · · · · 183
Tópicos Avançados· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 187
Sobreposição ·· · ··· ·· ·· ·· ······ ··· · ·· ··· · ···· · · ··· ······· · ·· 187
Hera11ça · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · l 89
A Base de Todas as Classes Básicas · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 194
Construtores· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 195
Espaços de Nome · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 197
Me,nbros e Objetos Compartilhados · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 199
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 199
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 200
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 200
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 201
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 20 l
SEMANA 1 Revisão 202

SEMANA 2 Visão Geral 203

Dia 8 Introdução ao .NET Framework 205



O Que E o .NET Framework? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 205
Classes Importantes do .NET Framework· · · · · · · · · · · · · · · · · · · · · · · · · · · · · 206
Console · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 206
Resultados Mais Simples· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 207
Envi ronment (An1biente) · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 212
Random· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 213
Sumário XIII I

Matl1 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 214
Classes de Conjuntos no .N ET Frame,vork· · · · · · · · · · · · · · · · · · · · · · · · · · 215
Encontrando o Que Precisa no .NET Framework · · · · · · · · · · · · · · · · · · · · · · · 219
As Regras da Busca · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 2 19
A Saga pela Classe Pe,feita · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 220
Resu1no · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 223
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 224
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 224
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 224
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 224
Dia 9 Desenvolvendo uma Interface com o Usuário com os Formulários Windows 225
Visão Geral dos Formulários Windo,vs · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 225
Criando um Aplicativo co,n Fonnulários Windows· · · · · · · · · · · · · · · ··· · · · · 227
Configurando o Projeto· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 227
Adicionando Controles ao Formulário · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 228
Notneando Seus Controles · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 229
Manipulação de Eventos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 229
'
Criando Vários Manipuladores de Eventos para tun Unico Evento · ··· · · · · 23 1
Encontrando Objetos e Eventos por Meio do Editor de Códigos · · · ··· · · · · 232
Múltiplos Eventos com um Manipulador · · · · · · · · · · · · · · · · · · · · ··· · · · · 233
Mais lnfonnações sobre os Controles· · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 233
Criando Grupos de Botões de Opção · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 234
Adicionando u1na Caixa de Seleção ao Exen1plo de Fi ler · · · · · · · ··· · · · · 236
Validação de Entradas· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 23 8
Usando a Classe MessageBox · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 241
Parâmetros · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 242
Obtendo Resultados · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 243
Controles Ocultos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · · · · 246
Timer· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 247
Not i f y I con · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 248
ErrorProvi der · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ··· · ···· ··· · · · · · 249
Controles das Caixas de Diálogo · · · · · · · · · · · · · ··· · ··· · ·· ·· ··· · · · · · 250
Construindo Suas Caixas de Diálogo · · · · · · · · · · · · ··· · ··· · ·· ·· ··· · · · · · 254
Criando a Caixa de Diálogo · · · · · · · · · · · · · · · · ··· · ··· · ·· ·· ··· · · · · · 255
Configurando o Resultado da Caixa de Diálogo · · ··· · ··· · ···· ··· · · · · · 256
Exibindo a Caixa de Diálogo· · · · · · · · · · · · · · · · ··· · ··· · ···· ··· · · · · · 257
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ··· · ·· ·· ··· · · · · · 259
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 259
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 260
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 260
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 260
XIV Aprenda Visual Basic .NET em 21 Dias

Dia 1O Construindo a Interface com o Usuário com os Formulários da Web 263


O Modelo de Progra111ação da Web · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 263
ASP.NET · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 265
Con10 a Criação de Progra1nas com Base na Web Difere da de Progra1nas co1n
Base no Windows · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 266
Usando os Controles-padrão dos Formulários da Web· · · · · · · · · · · · · · · · · · · · 268
Usando os Controles Avançados dos Formulários da Web · · · · · · · · · · · · · · · · 277
Usando os Controles Val idator · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 279
ResLt_
mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 283
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 283
Works-hop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 284
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 284
Exercício · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 284
Dia 11 Introdução aos Bancos de Dados 285
U1n Banco de Dados É a Solução para Todos os Problen1as Cotidianos· · · · · · · 285
A Decisão É Tomada · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 286
A Passagem para um Banco de Dados Real · · · · · · · · · · · · · · · · · · · · · · · · · 287
U1na I.ntTodução à SQL · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 288
Recuperando Registros co1n a Instrução SELECT· · · · · · · · · · · · · · · · · · · · · · 288
Adicionando Novos Registros · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 290
Alterando Registros · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 291
Re1novendo Registros Jndesejados · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 292
Para Onde Ir a Partir Daqui Abordando a SQL· · · · · · · · · · · · · · · · · · · · · · · 292
Proble1nas Comuns dos Bancos de Dados e Suas Soluções · · · · · · · · · · · · · · · · 293
Inconsistências de Atualização · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 293
Can1pos Multivalorados · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 297
Associações: Consultando Várias Tabelas de uma Só Vez · · · · · · · · · · · · · · 298
Relaciona,nentos Muitos-para-Muitos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 300
Integridade Referencial · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 300
Criando Chaves Pri,nárias · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 301
Criando o Banco de Dados de Exemplo· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 304
Access 2000 ou Access 2002· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 304
MSDE e SQL Server 2000 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 305
Testando a Configuração com System.Data · · · · · · · · · · · · · · · · · · · · · · · · · · 305
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 307
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 308
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 308
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 309
Ex.ercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 309
Dia 12 Acessando Dados com a Plataforma .NET 311
Uina Visão Geral do Acesso aos Dados na Platafonna .NET· · · · · · · · · · · · · · · 31 1
O ADO e o OLEDB · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 312
Sumário

ADO.NET··············································· · ·312
Tarefas-padrão dos Bancos de Dados · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 3 l 4
Conectando-se ao Banco de Dados · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 314
Executando uma Instrução SQL· · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 319
Recuperando Dados · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 321
Trabalhando com Data Sets · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 323
Inserindo Dados e,n u,n DataSet · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 323
Navegando pelos Dados · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 326
Editando Dados (Adicionar, Editar e Excluir)· · · · · · · · ··· · ···· ···· · · · · 329
Editando Registros · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 331
Atualizando o Banco de Dados · · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 334
Trabalhando com Múltiplas Tabelas · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 346
Visualizações · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 348
Vinculação de Dados · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 350
Vinculação de Dados con1 os Formulários Windo\.vs· · · ··· · ···· ···· · · · · 351
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 354
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 355
Workshop · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ···· ···· · · · · 355
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ··· · ·· ·· ···· · · · · 355
ExercJcios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 356
Dia 13 Usando o Server Explorer 357
O Que É o Server Explorer · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 357
O Que É um Serviço?· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 359
Examinando os Serviços · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 359
Ca,uinho a Ser Perco1Tido para Estabelecer u1ua Conexão com o Banco de Dados
· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 36 3
Trabalhando com os Serviços · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 364
Visualizando os Serviços· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 365
Conectando-se com Outro Servidor · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 366
Escrevendo Programas Que Usam os Serviços · · · · · · · · · · · · · · · · · · · · · · · · · 366
Escrevendo Códigos de Acesso a Dados con1 o Server Explorer · · · · · · · · · · 366
Rest1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 379
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 380
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 380
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 380
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 380
Dia 14 Introdução à Programação Orientada a Objetos 381
Visão Geral da Progra1nação Orientada a Objetos· · ··········· ·· · ·· · · · · · 381
Comparando a Programação Orientada a Objetos com a Linear· ·· · ·· · · · · · 382
Usando os Objetos na Organização do Código · · ··········· ·· · ·· · · · · · 384
Conceitos Importantes na POO · · · · · · · · · · · · · · · ··········· ·· · ·· · · · · · 385
Classes, Objetos e Instâncias· · · · · · · · · · · · · · · ··········· ·· · ·· · · · · · 385
XVI Aprenda Visual Basic .NET em 21 Dias

Propriedades· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 3 87
Métodos···· ·· · ······· · · ·· · ··· ··· ······ ·· ·· ·· ·· ··· ······ · ·· 388
Hera11ça · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 389
Construtores· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 393
Projetando um Aplicativo com o Uso da POO · · · · · · · · · · · · · · · · · · · · · · · · · 396
Identificando os Objetos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 397
Detenn inando as Propriedades e Métodos · · · · · · · · · · · · · · · · · · · · · · · · · · 398
Modelando Seus Objetos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 399
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 400
P&.R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 400
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 400
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 401
Ex.e1·cfcios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 40 l
SEMANA 2 Revisão 403

SEMANA 3 Visão Geral 405

Dia 15 Criando Objetos no Visual Basic .NET 407


Criando Objetos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 407
Declarando u1na Classe Nova no Visual Basic .NET · · · · · · · · · · · · · · · · · · 408
Hera11ça · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 408
Adicionando Propriedades· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 41 O
Usando Rotinas de Propriedade para Validar Dados· · · · · · · · · · · · · · · · · · · 41 3
Criando Métodos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 41 7
Adicionando Eventos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 423
Definindo e Usando Interfaces· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 425
Usando os Objetos Que Você Criou· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 434
Espaços de Nome· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 434
Criando e Usando uma DLL da Biblioteca· · · · · · · · · · · · · · · · · · · · · · · · · · 436
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 438
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 438
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 438
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 438
E·xercicios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 439
Dia 16 Formulários Windows Avançados 441
Menus · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 441
Adicionando uJn Menu a u1n Formu lário · · · · · · · · · · · · · · · · · · · · · · · · · · · 441
Os Teclados e os Menus · · · · · · · · · · · · · · · · · · · · ·· · ··· · ·· ·· ··· · ·· · · 444
Adicionando Código · · · · · · · · · · · · · · · · · · · · · · · ·· · ··· · ·· ·· ··· · ·· · · 445
Algu1nas Sugestões · · · · · · · · · · · · · · · · · · · · · · · · ·· · ··· · ·· ·· ··· · ·· · · 448
Programas de Interface de Documentos Múltiplos · · · ·· · ··· · ·· ·· ··· · ·· · · 449
O Que É uma Interface de Documentos Múltiplos? ·· · ··· · ·· ·· ··· · ·· · · 449
Sumário XVII I

Adicionando o Fonnulário-pai · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 450


A MDI e os Menus · ········ · ··· · ··· ······ ·· ·· ·· ·· ··· ······ ·· · 451
Controles Avançados dos Fonnulários Windo\vs · · · · · · · · · · · · · · · · · · · · · · · 458
Tree V'ie\\' · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 459
Li st Vi ew · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 462
Controles Sp 1i tter· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 463
Rest1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 470
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 471
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 471
Teste· ··· · ············ · ······· ·· ··········· · ·· ·· ······· ··· 471
E·xercfcios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 472
Dia 17 Usando o .NET Framework 473
Fluxos e Arquivos·
,
· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 473
O Que E um Stream? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 474
Arquivos e Diretórios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 474
Lendo um Arquivo de Texto· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 476
Gravando em um Arquivo de Texto· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 478
Desenhando con1 as Classes de Figuras · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 492
Exa1ninando as Classes de Figuras· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 492
Onde Posso Desenhar? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 498
Desenhando FornJas · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 503
Salvando Figuras · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 506
Rest1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 509
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 509
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 51 O
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 5 l O
E.xercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 510
Dia 18 Retoques Finais 511
Docu111entando Seu Aplicativo· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 511
Crie Soluções Mais Simples · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 512
Evitando Conjecturas ,
····································· · · · · 515
Não comente o Obvio, Só o Que For Confuso · · · · · · · · · · · · · · · · · · · · · · · 516
Docun1ente o Siste1na, e Não Apenas o Seu Código · · · · · · · · · · · · · · · · · · · 516
Mell1ores Práticas e Padrões de Codificação· · · · · · · · · · · · · · · · · · · · · · · · · · · 518
No1neação de Variáveis, Controles e Objetos · · · · · · · · · · · · · · · · · · · · · · · · 519
Blocos de Co1nentário · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 521
Usando o Controle do Código-fonte· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 522
Extraindo o Código· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 522
Armazenando o Código· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 526
Visualizando e Retomando Suas Alterações· · · · · · · · · · · · · · · · · · · · · · · · · 528
Considerações sobre Segurança no Uso do Visual Source Safe · · · · · · · · · · · 529
Res"t1mo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 529
XVIII Aprenda Visual Basic .NET em 21 Dias

P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 530
Works.hop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 530
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 530
Dia 19 Implantando Seu Aplicativo 531
Introdução à Implantação · · · · · · · ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 53 1
Criando uma Instalação Simples ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 533
Crie o Projeto e a Solução· · · · · ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 533
Arquivos de Configuração· · · · · ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 540
In1plantações de Múltiplos Projetos ··· · · ··· ···· · ··· · ··· · ·· ·· ···· · · · · 542
Rest1.mo · · · · · · · · · · · · · · · · · · · · ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 545
P&R · · · · · · · · · · · · · · · · · · · · · · ··· · · ··· ···· · ··· · ··· · ···· ···· · · · · 545
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 546
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 546
Exe1·cícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 546
Dia 20 Introdução à XML 547
O Que E' XML? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 547
Elementos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 551
Atributos · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 552
Esquemas·· ··· · ······· · ······· ·· ··· · ··· · ··· ·· ·· ·· ······· · ·· 553
Trabalhando co,n a XML · · · · · · · · · · · · · ·· ···· · ··· · ··· · · · · · · · · · · · · · 556
O Docu1uent Object Model · · · · · · · · · · ·· ···· · ··· · ··· · · · · · · · · · · · · · 556
Objetos de Leitura e de Gravação · · · · · ·· ···· · ··· · ··· · · · · · · · · · · · · · 559
Lendo XML · · · · · · · · · · · · · · · · · · · · · ·· ···· · ··· · ··· · · · · · · · · · · · · · 56 l
Gravando XML · · · · · · · · · · · · · · · · · · ·· ···· · ··· · ··· · · · · · · · · · · · · · 566
Resumo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 569
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 569
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 57 1
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 571
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 571
Dia 21 Criando Serviços Web com o Visual Basic .NET 573
O Que É um Serviço Web? · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 573
O Simple Object Access Protocol · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 575
O Protocolo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 575
Web Service Description Language (WSDL) ·· · · ··· · ··· · ···· ··· · · · · · 576
Discovery · · · · · · · · · · · · · · · · · · · · · · · · · · ·· · · ··· · ··· · ·· ·· ··· · · · · · 579
Criando un1 Serviço Web Simples · · · · · · · · · · ·· · · ··· · ··· · ···· ··· · · · · · 580
Criando o Projeto · · · · · · · · · · · · · · · · · · · · ·· · · ··· · ··· · ···· ··· · · · · · 581
Adicionando o Código · · · · · · · · · · · · · · · · ·· · · ··· · ··· · ·· ·· ··· · · · · · 584
Con1pilando o Serviço Web· · · · · · · · · · · · · ·· · · ··· · ··· · ·· ·· ··· · · · · · 585
Criando um Serviço Web Cliente · · · · · · · · ·· · · ··· · ··· · ·· ·· ··· · · · · · 587
Criando o Projeto · · · · · · · · · · · · · · · · · · · · ·· · · ··· · ··· · ···· ··· · · · · · 588
Adicionando o Código · · · · · · · · · · · · · · · · ·· · · ··· · ··· · ···· ··· · · · · · 589
Sumário

U111Serviço Web Mais Complexo · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 592


Criando o Serviço · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 592
Testando o Serviço Web· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 596
Criando o Cliente · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 597
Adicionando o Código · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 600
Resu1no · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 604
P&R · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 605
Workshop· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 605
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 605
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 605

SEMANA 3 Resumo 606

Apêndice A - Respostas dos Testes/Exercícios · 609


Respostas do Dia l · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 609
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 609
ExercJcios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 610
Respostas do Dia 2 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 61 l
Teste· ··· · ··· · ··· ·· ·· · ··· · ···· · ··· · ······· ·· ·· ·· ······· · ·· 611
Exercício · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 61 l
Respostas do Dia 3 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 611
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 61 1
Exe1·cícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 612
Respostas do Dia 4 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 613
T este· ·· ··· ·· · ······· · ··· · ··· ·· ·· ·· ········ · ·· ·· ······· ·· · 613
Exercício · · · · · · · · · ··· ·· ·· · ··· · ···· · ··· · ··· · ···· ·· ·· ··· · · · · · 614
Respostas do Dia 5 · · · · ··· ···· · ··· · ···· · ··· · ··· · ···· ·· ·· ··· · · · · · 615
Teste · · · · · · · · · · · · ··· ···· · ··· · ·· ·· · ··· · ··· · ···· ·· ·· ··· · · · · · 61 5
Respostas do Dia 6 · · · · ··· ···· · ··· · ···· · ··· · ··· · ···· ·· ·· ··· · · · · · 615
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 615
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 615
Respostas do Dia 7 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 617
Teste·· ··· · ·· ·· · ··· ··· · ···· ·· ······ ··· ·· ··· ····· ··· · ······ 617
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 6 1_7
Respostas do Dia 8 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 619
Teste····················································· 61 9
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 620
Respostas do Dia 9 · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 621
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 62 l
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 622
Respostas do Dia l O· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 623
Teste · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 623
Exercícios · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · 623
XX Aprenda Visual Basic .NET em 21 Dias

Respostas do Dia 11 • • • 627


Teste • • • 627
Exercícios • • • • 628
Respostas do Dia 12 • 629
Teste • • • • 629
Exercícios • • • • 630
Respostas do Dia 13 • • • • • • 630
Teste 630
Respostas do Dia 14 630
Teste • 630
Exercícios • • • • • • • • 630
Respostas do Dia 15 • • • • • • 631
Teste • 631
Exercícios 631
Respostas do Dia 16 • 633
Teste 633
Exercícios • 633
Respostas do Dia 17 • 638
Teste • • 638
Exercícios 638
Respostas do Dia 18 • • 639
Teste • • • • • 639
Respostas do Dia 19 • 640
Teste • • • • • • • • • • • 640
Exercícios • • 640
Respostas do Dia 20 • • 641
Teste 641
Exercícios • • • 641
Respostas do Dia 21 • 644
Teste 644

lndice 645
Introdução
Ben1-vindo a u1na lição estimulante e informativa de 21 dias sobre o Visual Basic .NET, a mais
nova encarnação da linguage1n de progra,nação mais popular do mundo. Este livro foi planejado
para fornecer a você uma introdução ao .NET Framework e ao Visual ·s asic .NET, e fazê-loco-
1neçar a progra,nar aplicativos reais o mais rápido possível.

Visão Geral
O .NET Framevvork é o conjunto básico de conceitos e tecnologia subjacente ao 1nais novo gru-
po de ferra1nentas de desenvolvi1nento da Microsoft e constituirá a base para a nova série de ser-
vidores, aplicativos e serviços co,n base na Web itnplantados ao redor do inundo. Con10 já é de
se esperar, a plataforma .NET não é algo que possa ser completatnente discutido em uma hora ou
1nesmo em 21 dias, portanto, este livro terá uma abordagem 1nais específica. Você precisará se
tornar produtivo rapida1nente e isso é o que conseguirá nos próximos 21 dias enquanto ler este li-
vro e trabalhar com os exercícios dele. Pelo fornecimento dos ele1nentos básicos da linguagem
do Visual Basic .NET e uma explicação suficiente do próprio .NET Fran1ework, você estará
pronto para já cotneçar a programar e preparado para continuar aprendendo ao progredir.
Desde o início, é importante observar um fato essencial sobre a plataforma .NET: a linguagem
que você usa é ,nenos relevante do que foi no passado. O Fra,nework (o conjunto de tecnologia
e1n que toda a plataforma .NET está baseada) é a própria plataforma .NET e também pode ser
acessado se1n proble1nas por qualquer linguage1n .NET (incluindo o Visual Basic, C#, C++ e ou-
tras). Essas são notícias excelentes tanto para os desenvolvedores novos do Visual Basic quanto
para os experientes. O Visual Basic não é 1nais u1na linguage1n de segunda classe, com certos re-
cursos avançados do siste1na operacional restritos apenas aos progra1nadores que usain C++.
Agora, qualquer sistema, independentemente do tipo, pode ser criado no Visual Basic.
Essa independência ta,nbém significa que você (ou sua e1npresa) está livre para escolher qual-
quer linguagem com a qual queira trabalhar. Dada essa opção, mui.tas pessoas, incluindo os auto-
res deste livro, irão adotar o Visual Basic .NET. Sua sintaxe e estilo fáceis de usar o tornara,n a
linguagem de progra1nação ,nais popular do mundo, .mesmo co1n as !.imitações que a versão an-
terior apresentava. Agora, co,n a platafonna .NET, nada irá i1npedi-la de ser usada en1 qualquer
projeto de todos os tipos de empresa.
Se você estiver interessado e1n aprender mais do que apenas o Visual Basic .NET - talvez a C#
possa ser bem interessante-, continuará tendo um bom ponto de partida. Este livro vai fornecer
urna abordagem de como usar o .N.ET Frarnework, conhecimento que pode ser transferido facil-
mente para qualquer linguage1n .NET.
Este livro foi planejado como uma série de lições, cada lnna representando algun1 conceito im-
portante no desenvolvi1nento de aplicativos (co,no o acesso a bancos de dados) ou u,n trecho es-
XXII Aprenda Visua l Basic .NET em 21 Dias

sencial com conhecilnento para tornar você produtivo (ouso do IDE, por exemplo). Essas lições
podem ser exa1ninadas e1n qualquer orde1n, mas se você for novo na atividade de progra1nação
em geral, então, será mais vantajoso seguir a partir do início, na primeira vez que o livro for usa-
do. A 1naioria das lições, 1nes1no a prin1eira, inclui algu1n exe1nplo de código e exercícios para os
quais será necessária a elaboração de mais u1n pouco de codificação. Para aproveitar ao máxi1no
o tempo gasto no livro, tente realizar todos esses exen1plos e exercícios. Nada aun1entará sua
compreensão desses tópicos mais rapidamente do que colocar a mão na 1nassa e codificar.

Quem Deve Ler Este Livro?


En1bora o objetivo principal deste livro sejam as pessoas iniciantes na atividade de programação
em geral e no Visual Basic .NET especificamente, ele será útil a uma variedade 111aior de leito-
res. Se você já for um progra1nador do Visual Basic, então, procure nos diversos tópicos do livro
algumas das ótilnas explicações e exemplos que envolvam os novos recursos. Será possível per-
ceber que há muitas diferenças no universo do Visual Basic 6.0, e o nível de abordagem forneci-
do neste livro deve ajudá-lo a fazer a transição.
Se você já for u1n programador experiente que não conhece o Visual Basic, poderá ficar tentado
a saltar ou ler de modo superficial grande parte das pri1neiras lições. Independentemente de seu
nível de habilidade, será bom examinar com detalhes a introdução (Dia 1) para compreender o
conceito geral da platafonna .NET e a abordage1n do IDE (Dia 2) para ganhar velocidade ao tra-
balhar com o Visual Studio .NET. Em seguida, poderá passar pelo resto do livro cotn seu próprio
ritmo, verificando por alto algun1as das seções que abordan1 conceitos gerais de progra1nação e
se dedicando aos capítulos que explicam corno o Visual Basic .NET realiza tarefas avançadas,
co1no a criação de objetos, o acesso a bancos de dados e a geração de aplicativos na Internet.

O Que Você Aprenderá


Este livro ensinará a você co1no criar vários tipos diferentes de aplicativos usando o Visual Basic
.NET, incluindo tanto os cliente/servidor quanto aqueles com base na Web. Quando passar pelos
tópicos sobre o Visual Basic .NET, ta1nbé1n aprenderá muito sobre o .NET Fra1nework e conhe-
cerá alguns servidores .NET, inclusive o SQL Server e o Internet Infonnation Services.
No que diz respeito ao projeto e à arquitetura, você aprenderá sobre os recursos orientados a ob-
jetos do Visual Basic .NET, como, por exemplo, a criação de classes e o uso de objetos, alén1 dos
princípios básicos da herança, sobreposição, anulação e outras funcionalidades avançadas forne-
cidas por esse tipo de programação.
Na etapa de desenvolvimento que envolve a interface ou saída, você aprenderá a criar aplicati-
vos ' Windows' por 1neio dos novos recursos de formulários do Visual Basic .NET, a construir
interfaces co1n base e1n páginas da Web usando formulários da Web e a gerar u1n serviço sin,ples
disponível na Web que poderá ser utilizado por qualquer linguagem ou platafonna de progra1na-
ção capaz de acessar a rede e compreender a XML.
Introdução XXIII I

Nosso objetivo é prepará-lo nos próximos 21 dias para que você possa criar tnuitos de seus pró-
prios aplicativos sirnples no Visual Basic .NET e trabalhar como parte da equipe que está desen-
volvendo wn grande aplicativo Windows ou com base na Web.

O Que Não Abordaremos


Apesar da discussão anterior sobre a independência da linguagem e a importância das tecnolo-
gias subjacentes, este é u1n livro que tem como prioridade o Visual Basic .NET. Como tal, não
abordaremos a C# ou qualquer outra linguagem .NET que não seja o Visual Basic. Mencionare-
mos a utilização de bancos de dados, como o SQL Server, 1uas você não precisará recorrer a li-
vros sobre ele para obter detalhes completos sobre como configurar e gerenciar seu servidor de
banco de dados.
Ta1nbé1n não pretende,nos abordar todo o Visual Basic .NET neste livro. Essa é u1na linguagem
portentosa, com .muitos recursos. Apenas para listar todos eles e a sintaxe usada para empre-
gá-los, precisaríamos faciltnente de um livro deste ta,nanho. Discutire1nos o Visual Basic .NET
com detalhes suficientes para que você se torne produtivo ao usá-lo e seja fornecido o conheci-
mento necessário para que comece a projetar aplicativos que se beneficiem dos novos recursos
da plataforma .NET.

Requisitos
Já que se trata de tun livro sobre o Visual Basic .NET, o requisito 1nais pren1ente é urn sistema
que execute o Visual Stud.io .NET, e que tenha no mínirno as especificações básicas a seguir:
• Siste1na operacional WindO\VS XP Professional, Windows 2000 (Datacenter Server,
Advanced Server, Server ou Professional) ou Windows NT 4.0 Server. O Visual Studio se
encarregará da instalação de qualquer pacote de serviços, arquivos atualizados de acesso a
dados e da versão 6 do Internet Explorer, todos sendo requisitos para o Visual Studio .N ET.
• 11ard\vare Pentiurn fl co1n 450 Mhz ou equivalente, 128 MB de RAM, placa de vídeo
con1 capacidade para resolução de 800 x 600 pixeis, 256 cores e no n1ínin10 1 GB de espa-
ço em disco rígido. Utna unidade de CD-ROM é necessária para instalação, mas você
pode colocar seus CDs em outra n1áquina e instalar por meio de u1na conexão LAN .
Além do Visual Studio, os exemplos deste livro requere1n a possibilidade de acesso a u1n servi-
dor Web que esteja na 1nesn1a rnáq uina do Visual Studio ou tenha o SDK do .NET Frame,~ ork 1

instalado nela. O melhor a fazer é se certificar de que sua máquina principal de desenvolvimento
tenha um servidor Web ern execução nela, como no Windows 2000 ou no Windows NT. Outro re-
quisito básico usado pelos exeinplos na última 1netade deste livro é o acesso a u1n banco de dados,
especificarnente o SQL Server 7.0 ou 2000. Se você não tiver o SQL Server, então poderá usar o
Microsoft Data Engine (MSDE), que funciona de 1naneira semelhante ao SQL Server completo.
Pode ser usado um banco de dados Access, se for esse o seu, mas será preciso alterar alguns dos
exemplos nas lições de acesso a bancos de dados para fazê-los funcionar se1n o SQL Server.
XXIV Aprenda Visua l Basic .NET em 21 Dias

Habilidades Que Você Precisa Ter


Este é u1n livro destinado a progra1nadores iniciantes, n1as algu1nas habilidades básicas são ne-
cessárias. Espera-se que você esteja familiarizado con1 o uso de co1nputadores co1n base em
Windows, incluindo o sistema operacional que estiver instalado para executar a platafom1a .NET.
Copiar arquivos, iJnprimir, abrir arquivos no Bloco de notas e habilidades de edição básica de texto
(recortar, copiar, colar) são todas necessárias, e não serão explicadas nas lições. Saber como co-
nectar sua 1náquina à Internet e navegar em sites da Web també1n são habilidades exigidas.
Alé1n desse conhecimento básico em co1nputadores, você não precisa ser u1n progra,nador ou
saber como construir bancos de dados. Qualquer conhecimento efetivo nessas áreas provavel-
1nente será útil, mas nossos exemplos e explicações fora1n elaborados para seren1 claros n1es1no
para alguém que nunca tenha tentado codificar antes.

O Site da Web
Este livro possui u,n site da Web associado a ele no endereço http://www.makron.com. br. Loca-
lize a página do livro no site, digitando seu título na caixa Pesquisa. Ao entrar na página do livro,
procure o link MATERIAL COMPLEMENTAR. Você pode fazer o download de todos os códi-
gos do livro e alguns links ou ,nateriais
,
comple1nentares que acha,nos ser úteis para o leitor com-
preender o Visual Studio .NET. E claro que é totahnente possível usar este livro e acompanhar
todos os exe1nplos, sem ser preciso visitar o site, mas em alguns dos exemplos 1nais longos, pode
ser 1nelhor economizar algu1n esforço en1 digitação fàzendo o do\.vnload dos arquivos que con-
tê1n os códigos.

Layout dos Capítulos


Vinte e um dias é un1 período longo, portanto, alé1n de dividir as lições em dias, organizamos o
livro em seções con1 duração de três semanas (ou pa1tes). Na primeira parte, nos dedicaren1os a in-
troduzi-lo nos conceitos gerais de programação e da platafonna .NET, e abordar a sintaxe e técni-
cas básicas para a criação de programas co1n o Visual Basic .NET. Na segunda parte nos
aprofundaremos no .NET Framework para fornecer u1na co1npreensão 1nais detalhada dessa base
essencial de toda a progra1nação e também discutiren1os os fundan1entos da criação de progra1nas
reais, co1no a maneira de gerar uma interface con1 o usuário (com fonnulários Windows e da Web)
e co1no trabalhar con1 bancos de dados. A última pa1te introduzirá alguns dos tópicos mais avança-
dos da programação .NET, incluindo a criação de seus próprios objetos, a implantação de seu apl i-
cativo nos computadores de outras pessoas e o trabalho com a XML e os serviços da Web. Como
fala1nos anterionnente, tente percorrer essas lições em orde1n, mas fique à vontade para saltar
adiante se houver tun tópico sobre o qual queira 1nuito ler 1nais no 1no1nento que desejar.
Introdução xxv

Retorno
Trabalhan1os duro para tornar este livro u1na ferratnenta útil de aprendizado da platafonna .NET
e u1na aquisição valiosa para sua biblioteca de desenvolvin1ento. Se você achar que devería1nos
ter gasto mais ou menos tempo em alguLn tópico específico ou tiver sugestões para melhorar o li-
vro, faça contato conosco (e1i entes@makron.com. br). Tentaremos incorporá-las e1n livros futu-
ros e, se for o caso, na próxi1na revisão deste 1nesmo vol.t11ne.

Convenções Usadas Neste Livro


Este livro usa várias convenções para ajudá-lo a priorizar e recorrer às informações que ele con-
tém:

As notas fornecem informações úteis em destaque, que você pode ler imediata-
NOTA mente ou retornar a elas sem perder o fluxo do tópico que estiver examinando.

As dicas realçam as informações que podem tornar sua programação no VB


DICA
mais eficaz.

Os alertas de cuidado concentram sua atenção em problemas ou efeitos cola-


ALERTA terais que podem ocorrer em situações específicas.

Faça •

Os quadros Faça/Não Faça enfatizam práticas ... e ruins que devem ser evitadas.
boas que você deve adotar ...

Novo TERMO Os ícones Novo Termo assinalan1 locais onde uma nova terminologia foi usada e defi-
nida pela primeira vez. Essa terminologia aparece destacada com un1a fonte em itálico.

CÓDIGO Os ícones Código são usados em exe1nplos de código que o usuário deve inserir.

ANÁLISE Os ícones Análise apontam para discussões co1n explicações sobre os exemplos de
códigos.

O código é apresentado em fonte monoespaçada.


SEMANA 1

Visão Geral
Durante esta parte, você aprenderá vários tópicos essenciais:
• O Visual Basic .NET e o conceito de programação (Dia 1).
• Configuração e uso do Visual Studio .NET para começar a escrever pro-
gran1as (Dia 2).
• A sintaxe e as técnicas de programação do Visual Basic para tipos de da-
dos, procedi1nentos e variáveis (Dia 3); o controle do fluxo dos programas
- laços e instruções condicionais (Dia 4); e o tratamento de erros (Dia 6).
• Organização e projeto de u1na solução no Visual Basic .NET (Dia 5).
• Conceitos importantes relacionados ao desenvolvilnento orientado a ob-
jetos con1 os quais você trabalhará por todo o livro (Dia 7).
Esta pa11e é importante. Ela define os fundamentos do conhecirnento básico nos
quais todos os outros conceitos de progran1ação do Visual Basic .NET se basea-
rão. O Dia I preparará você para co1neçar a explorar e aprender o Visual Basic,
por 1neio da introdução dos conceitos fundamentais de programação e da plata-
forma .NET, junto corn urn breve histórico do próprio Visual Basic. No Dia 2,
aprendere1nos a usar o ambiente de desenvolvi1nento com todos os recursos do
Visual Studio para criar projetos.
Nos Dias 3 e 4, você irá progran1ar com rnuitas informações sobre a sintaxe e
conceitos (incluindo variáveis, laços, instruções i f e mais) que farão parte de to-
dos os progra1nas do Visual Basic escritos desse ponto en1 diante.
No Dia 5, você conhecerá todos os tipos diferentes de projeto que poderá criar no
Visual Basic .NET e aprenderá a adaptá-los à arquitetura geral do sistema. Para
concluir, os Dias 6 e 7 retornam ao mundo prático da codificação em que apren-
dere1nos a lidar con1 erros e a usar objetos en1 progran1as.
Esta pa11e fornecerá as infonnações de que você precisa para prosseguir co1n a
leitura do livro, provendo todos os detalhes sobre os quais os outros capítulos se
desenvolverão.
SEMANA 1

DIA

Bem-Vindo ao Visual Basic .NET


Hoje, o introduzirei no universo da progra1nação do Visual Basic respondendo às perguntas
.
a seguir:
• O que é progra1nação e por que seria interessante aprendê-la?
• Co1no o Visual Basic se encaixa en1 tudo isso?
• O que é .NET?
Nos dias de hoje, o computador já é coisa trivial, e muitas pessoas que conheço passa1n o dia in-
teiro trabalhando co,n eles. Mas, mes,no assi,n, a pergunta 1nais comum é: "O que u,n progra-
mador de co1nputadores faz?". Essa pergunta tem sido feita tantas vezes, que na lição de hoje,
usarei um pouco do tempo discorrendo sobre o que é programar e por que você gostaria de fazer

ISSO.

Compreendendo a Programação de
Computadores
E1nbora falemos corn freqüência em computadores no que diz respeito ao hardware (é co1nurn
ouvir comentários co1no "Tenho u1n Pentiu1n III co1n 600 MHz e 256 MB de RAM", por exem-
plo), só isso não é o bastante. A CPU (Central Processing Unit ou unidade central de processa,..
1nento do co1nputador), por exen1plo, pode realizar 1nuitas tarefas i1nportantes como cálculos
matemáticos ou a transferênc.ia de dados entre várias pa1tes do sistema. Sozinho, no entanto, não
é capaz ne.m mesmo de ler um arquivo no disco rígido. Um progra,na de computador é um con-
4 Dia 1

junto de instruções para todos esses elementos de hardv.,are, em geral escrito para execução de
alguma tarefa que esse não poderia concluir sozinho. Todas as operações básicas que envolve,n
o uso de unidades de disco, me1nória, n1onitor e i1npressora são complexas. Um progra1na que ti-
vesse de interagir co1n essas operações gastaria a maior pa,te de seu tempo nelas, e só u1n peque-
no percentual seria e1npregado em sua finalidade real. Escrito no hardware, u,n progra1na para
calcular os pagamentos de u1na hipoteca provavehnente teria centenas ou ,nilhares de linhas
para gerenciar a exibição e outras questões, e apenas alguinas linbas para fazer o cálculo. Assim
a programação era fe ita no passado, se1n que fosse inuito produtivo porque 1nuito pouco te1npo
podia ser gasto na finalidade real do aplicativo. O que se precisava era de alguma maneira pela
qual todos esses detalhes fossetn manipulados para que os progra1nas pudessem se dedicar a suas
tarefas específicas.

A Função dos Sistemas Operacionais


Para fornecer essa ca,nada básica de funcionalidade nos equipamentos, os siste1nas operacionais
foram criados. Eles mesn1os são programas de computador, 1nas sua função é manipular todos os
detalhes de gerencia1nento de me1nória, entradas/saídas do disco (EIS) e outras tarefas de nível
i_nferior. Quando há um sistetna operacional (OS, Operating System) em u1n computador, outros
progra1nas pode1n ser escritos que não tenhain de lidar co1n todos os detalhes de nível inferior; se
os programas precisarem abrir um arquivo ou formatar u1n disquete, poderão solicitar ao siste1na
operacional que execute essa função para eles. Examinando isso graficainente (veja a Figura
1.1 ), você poderá visualizar as relações entre o hardware do computador e o sisten1a operacional,
ou desse co1n outros progra1nas, con10 várias carnadas de funcionalidade.

FIGURA 1.1 Aplicativo do Usuário (incluindo seus programas!)


O SÍsten1a operacional
se torna a inte,face
entre o equipa,nento
do con1p11tador e seu Sistema Operacional
progran1a, perrnitindo
que você evite códigos Drivers de Dispositivos Drivers de Dispositivos
específicos de
Componentes do Hardware
hard1vare.

Co,n frequência, os relaciona1nentos não são definidos co1n 1nuita clareza; u,n progra1na pode
precisar acessar o hardv,are diretamente (sem passar pelo sistema operacional) para usar um re-
curso dele ao qual o siste,na operacional não dê suporte ou para tentar melhorar o dese1npenho.
Isso dece1to foi o que aconteceu, no início, co,n um dos prilneiros sistemas operacionais de PCs,
no qual ,nuitos programas tinha,n de interagir direta,nente co,n o hardware. Essas li1nitações
significavain mais trabalho para as pessoas que quisesse,n escrever softv.,ares para PCs, já que
cada progra1na precisava 1nanipular suas próprias impressoras e outros detalhes. Ao 1nes1no tem-
po e,n que versões sucessivas dos sistemas operacionais fornecia1n um au,nento na fu ncionali-
Bem-Vi nd o ao Visua l Basic .NET

dade, se tornou mais fácil escrever progran1as para eles. Por fim, o Windows substituiu esses
sistemas. Uma das 1naiores 1nelhorias oferecidas pelo Windows é que o sistema operacional
agora provê recursos de interface de usuário para outros programas. No Windows, se un1 progra-
ma de computador precisar rnostrar u1na caixa de diálogo na tela (con10 a da Figura 1.2), ele ape-
nas solicita ao siste1na operacional para exibi-la e fornece a mensagen1 que a acompanhará. Para
acessar toda a funcionalidade que o sistema operacional provê, utn cot~unto de APis (Applicati-
on Progra1n1ning interfaces) é disponibilizado. .Essas APis representa1u a exposição de todos os
recursos do siste,na operacional e pode1n, portanto, ser usadas em seus progra1nas.

FIGURA 1.2
O Hlindo11 1s 111anipula a This is a dalog boxl
exibição de ele,nentos Part of a Graphlcal User Irxerface
de GU!s (Graphical
User lnte,jàces,
lnte,jaces gráficas co111
o usuário) co,110 esta
caixa de diálogo, o que
.faz parte dos se111iços
que ele .fornece aos
progra111as.

O resultado de todas essas n1elhorias é que cada programa ten1 de ,nanipular cada vez menos
operações genéricas do computador e pode, po1tanto, se dedicar a sua final idade real. Outro
grande beneficio da remoção de códigos específicos de hardware dos aplicativos é que, quando
ocorre1n alterações no hardware (i1npressoras e unidades novas de disco rígido, CPUs 1nais velo-
zes), o siste,na operacional pode ser atualizado para manipular o equipamento novo, mas os pro-
gra1nas executados nesse co1nputador não deve1n ser afetados.
O que isso significa para você como programador do Visual Basic? Be1n, significa que poderá
criar prograrnas de computador para realizar u1na tarefa específica setn ter de saber nada sobre
corno o Windows desenha as figuras no 1nonitor, emite docu1nentos na i1npressora ou salva ar-
quivos no disco rígido. Você se tornará produtivo rapidarnente, co1n a ajuda deste livro.

O Papel das Linguagens de Programação


Então, agora você sabe o que o sisten1a operacional fornece, mas e os progran1as propriamente
ditos - con10 são criados? Antes, neste capítulo, defini u1n programa de co1nputador como u1n
conjunto de instruções para o hardware. Já que o hardware só pode realizar operações relativa-
1nente fáceis, as instruções tan1bé1n devem ser simples. O resultado tina! do progran1a é u1n códi-
go que o hardware pode entender, chatnado co,n freqüência de linguagen1 de ,náquina ou código
nativo. As instruções, depois de carregadas na n1emória pelo sistema operacional, são compostas
de co1nandos co1no "transfira a rnemória de u1n local para outro" ou "execute uma função 1nate-
mática con1 os valores". Milhares desses comandos fonnatn u,n programa completo.
6 Dia 1

É possível escrever programas usando diretamente esse código nativo, com a criação de um ar-
quivo no disco rígido repleto de instruções, mas seria necessário 1nuito trabalho para produzir
até mes1no u1n progra1na 1nais simples. Para evitar todo esse esforço e per1nitir que os progrruna-
dores se dedique1n à fina lidade de seus progra1nas, linguagens de nível superior fora,n criadas.
Essas linguagens pennitetn que você use instruções 1nais avançadas e co1nplexas que são, então,
convertidas para as diversas instruções necessárias que sejan1 correspondentes às outras na lin-
guage1n de máquina. U1na única linba de uma linguage1n desse tipo provavebnente poderia se
transfonnar em dez instruções separadas na linguage1n de 1náquina.

Novo TERMO O processo de converter u1na linguagem de computador de alto nível e1n código de
máquina ou nativo é conhecido con10 compilação. Os progra1nas que fazem essa
conversão são cha1nados de co,npiladores.

Muitas dessas linguagens foram criadas con1 o passar dos anos. FORTRAN, COBOL, APL, Pas-
cal, C e BASIC são apenas alguns exe1nplos, mas centenas de li nguagens diferentes estão dispo-
níveis. Cada linguagem possui seu próprio conjunto de comandos e, co1n o tempo, novos
comandos são criados para simplificar ainda 1nais o esforço de progratnação. Assirn co1no os
computadores evoluíram progressiva1nente, o 1nes1no aconteceu às linguagens usadas para pro-
gramá-los, sendo adicionados novos recursos às existentes ou com a criação de novas lingua-
gens co1110 a C++ (que, co1110 você deve ter adivinJ1ado, foi baseada na C) e a JAVA. E,n geral,
os apritnorarnentos nas linguagens têm o objetivo de au1nentar a produtividade da programação,
pennitindo que o desenvolvedor crie o progra1na desejado da 1naneira 1nais fácil possível.

É simplista declarar que as linguagens de programação evoluem apenas para


NOTA tornar o desenvolvimento mais rápido. A velocidade no desenvolvimento é
apenas uma das motivações por trás das melhorias que ocorreram . Outros ob-
jetivos e resultados são a produção de aplicativos mais rápidos ou estáveis (com
menos fa lhas) ou até mesmo a criação de aplicativos mais fáceis de instalar.

Originahnente, a maioria das linguagens de programação era co1nposta de apenas um item, um


co,npilador. O programa era criado com o uso de u1n ed itor de texto, co,no o Bloco de notas, e o
compilador era executado, passando o no1ne do arquivo ou programa-fonte. E1n seguida, ele pro-
duziria o resultado final, um programa executável, pressupondo a inexistência de erros. O resul-
tado compilado era executado, testado para a verificação de erros e, então, você voltaria a seu
editor de texto para fazer alterações no código. Ele seria compilado mais uma vez, e o ciclo se re-
peti ria. Esse processo de desenvolviinento (veja a Figura 1.3) não era de u,na Linguagem especí-
fica; era un1a atividade comum para todos os programadores.
Bem-Vindo ao Visual Basic .NET 7

FIGURA 1.3 .......---, (Crie/Edite o Códig'V


Os co1T1piladores
converte1n o
cócligo-fonle de
linguagens ele alto nível
en1 instruções que o
e Encontre erros ) c__ c_o_m
_p_i_le_ _ )

co,nputador possa
co111preender.
e----- Execute )

Enq uanto as linguagens de prograinação evoluía1n, esse ciclo foi 1nelhorando também, resultan-
do no desenvolvimento de co1npiladores 1nais avançados e no conceito de um Ambiente Tntegra-
do de Desenvolvime11to (IDE, Integrated Development Environment). A finalidade de um IDE é
combinar os co1nponentes de edição, depuração e co1npilação do desenvolvin1ento de softwares
e.1n uma única interface para o progra1nador (veja a Figura 1.4). Apesar da interface única, a tec-
nologia real é 1nuito sen1elhante. Na 1naioria dos casos, o código ainda é co1npilado (veja a Nota
a seguir para mais informações) e o progra1nador ainda cria arquivos de texto, 1nas o ambiente de
trabalho é muito mais amigável.

•. Drf.UIDolM u _c ollC"dlon1, · M1croiofl VIUJ."11 Bm.lc,M 1 ( de~')n) · Col r-<ho~.vb fllrJ EI


FIGURA 1.4 fio E« !!low &<>Jott ~ 1),1,Jo Iods - t1ei>
O Visual Studio é un, 1~ • ~ • ~ 1i1 O J ~ f'., .. , : · • o:;. J ,1---,,----.. 0

rJj 11 ,

JDE que.fornece uma


inte,face única para
qualquer tipo de
•• • • •
' '
. . :; COlt<llOM.vb'
l,e:co1cctloou (O.CUIOot>E'H _Colct -)
- nodule co 11eet 1on,
3 1I •,....,
l@~b ..-1 .. · ':;;"!
-- !]
-
..:
/inguage,n, inclusive 1 3Ub llai n ()Q -
para o Visual Basic. - Sw, Pt' 1 ntSe:pa.ra.tor ()
Conso le. Vr 1.c..eL1ne ( "'•·===,...,·======= ===============-======• ======= .... ==='"'")
tnd Sul>

Sub Pou~e (J
conso1e . vr 1ceL1ne('"P~e9s I nt@r t.o cont.1nue .. . '")
Con.:,olC! . Rol\..dLi nc O
. Cnd Sub

.. .tnd 21od.ule . ,r•


• 1
"'f~ Ust • X
,I• ,1,I ~
Uno
Cldt-«. to oo:t • now t3

1- ~

-
Cdl (h
_J INS
8 Dia 1

NOTA
- Além das linguagens compiladas (em que o código-fonte deve ser processado
em um compilador antes que possa ser executado), existe um outro tipo cha-
mado linguagem interpretada. Nessas linguagens, o código-fonte não é com-
pilado. Em vez disso, um programa especial executa o código lendo o fonte e
processando o que for apropriado. Em geral, já que a análise (a leitura do fonte
à procura de comandos) tem de ocorrer sempre que o programa é executado,
as linguagens interpretadas são processadas mais lentamente do que as com-
piladas, nas quais a análise só ocorre uma vez, na hora da compilação. O Visual
Basic já foi uma linguagem interpretada, mas esse não é mais o caso.

A criação de lDEs gerou algu1na confusão entre quais serian1 os seus recursos e os da linguagem
a ser usada. Isso é realmente verdade no caso do Visual Basic, para o qual o IDE fornece muitos
recursos que permitem ao programador criar con1 facilidade u1na funcionalidade avançada.
Esses recursos quase se1npre geram o código do Visual Basic, e é ele que executa o trabalho.
Nesse caso, é o IDE que adiciona a funcionalidade, e não a linguagen1, 1nas ambos são em geral
vistos como o mesmo ele1nento. Hoje, quando for introduzido o conceito do Visual Studio .NET,
você verá que u1n fDE pode dar suporte a 1nuitas linguagens, e talvez seja i1nportante co1npreen-
der a diferença entre ele e sua linguagen1 subjacente.
Outro avanço i1npo1tante na história das linguagens de programação foi a criação das linguagens
'visuais', co1no o Visual Basic. Essas linguagens são cha1nadas 'visuais' porque permitem age-
ração de progra1nas que use1n u,na interface gráfica. O recurso ,nais co1num desse tipo de lin-
guagen1 é a possibilidade de inserir botões, texto e outros itens e,n un1a tela para construir u1n.a
interface co1n o usuário (veja a Figura 1.5). Mais u,na vez, na verdade, un1 código real freqüente-
mente é gerado, tuas o programador tem u1n trabalho muito mais agradável com a criação das
partes gráficas de seu aplicativo. Abordarei a posição ocupada pelo Visual Basic co1no lingua-
gen1 de progran1ação u1n. pouco n1ais adiante na lição de hoje.

Por Que Escrever Programas de


Computador?
Mencionei antes que a pergunta mais comun1 que ouço é: "O que faz tnn progrrunador de compu-
tadores?". Depois de ter explicado o conceito geral do trabalho, quase se1npre ouço a segunda
pergunta mais com un1, "Por que você iria querer fazer isso?". A resposta, "Porque é divertido es-
crever códigos", parece nunca satisfazer as pessoas. Portanto,já que começamos a aprender a es-
crever programas, vale a pena dedicar um pouco do tempo considerando o que ire1nos escrever e
A

por que.
Bem-Vindo ao Visual Basic .NET 9

·•. OrGUtOolNfT 4 _Collec:llom, • M1cro,ofi Vi,U<kl oa,lcMT ( de-,lqn) • r om, l.vb [Oew,gn]• l!!!lr;:J' E'J
FIGURA 1.5
As ferra111entas visuais --·
de desenvolvin1ento
per111iteni que você crie
inte1:faces grafica111ente
......---------- . ,
e, e111 seguida. gere o 1:
.. . .
..................
'
f
código necessário. i.. :: : butonl
..". '

. . . . .' . .
. ...."
.. : ...r ched:.BOll:1
'
''.
. ' .. .
....... .. .'' ..
' . ..
a... . ' ... ..... . . .'.'.' . . ...
. ..... ......... ............ .... . ........... ....... ..' .
.. .. ........' ..... ...' ..' .' .. . .. .. ............... .
.
.... .... ...' .... . .. .......... .. . .. .. .. .......' .' .. ..' . . . . ..
. . . . . ' . . . . . . . . . . . . . . . . . . . .......... .
.. . .. .. .' . . . ..." . .. . .. . . . . . . ... .:.J
--= 9 X

°" 1

A prirneira coisa a cornpreender sobre programação de cotnputadores é o tipo de programa que


será desenvolvido. Quando é solicitada a dar exemplos de aplicativos, a maioria das pessoas res-
ponde com programas como o Microsoft Word ou o Excel, algumas pode1n rnencionar jogos de
computador e muito poucas incluiria1n o próprio Windo\.vs na lista. Todos esses são definitiva-
mente aplicativos de computador e alguém ten, de programá-los, 1nas a categoria rnaior de pro-
gra1nas é a que quase nunca é ,nencionada. Os prograrnas mais co1nuns são os siste1nas que
vernos a toda hora. A menos que você esteja interessado em (ou obcecado por) programação, não
pensa cotn freqüência nos meses ou anos da vida do programador que são gastos no desenvolvi-
mento. Esses prograrnas, corno o sisterna de co1nputador na locadora próxi1na ou o programa
que o governo local usa para rastrear licenças de rnotorista, são desenvolvidos para urn único clien-
te ou urn pequeno nicho de mercado. Fora de seu universo de aplicação, não são tão diferentes de
soft\.vares prontos corno o Microsoft Word. No entanto, sua natureza individualizada significa
que há uma taxa 1nuito alta de trabalhos de progra1nação por cliente.
A função de u1n progra,nador abrange ,nuitos aspectos diferentes no desenvolvi1nento de soft-
\.Vares, principahnente no inundo do software personalizado. Mas o ciclo do desenvolvimento de
softwares (SDLC, Soft,~1are Develop1nent Life Cycle) contém várias outras etapas essenciais
(veja a Figura l.6).
Antes de a codificação cotneçar, deve-se saber à que o novo sistema é destinado, isto é, seus re-
quisitos. Essas infonnações deve,n se tornar u1na planta geral para o aplicativo de computador,
ou seja, o projeto. Poden1os dizer que essa planta é, em linhas gerais, tuna interpretação das ne-
cessidades do cliente na fonna de prutes de un, siste,na de computador, e mais tarde se tornará o
guia por meio do qual o programador trabalhará. O resultado desejado é um sisterna de cornputa-
dor que atenda às necessidades originalmente especificadas pelo usuário. Esse siste1na con,pleto
10 Dia 1

deve, então, ser distribuído para os usuários, com manutenção e aprimoramentos posteriores. Os
erros - proble,nas no sistema - deve,n ser corrigidos, e novos recursos adicionados.

FIGURA 1.6 Requisitos


O ciclo de vida de u,n
projeto de
desenvolvünento de
soft1vare passa por
várias etapas distintas. Correção de Erros
Projet o
e Manutenção

Distribuição Implementação

Esse ciclo é a vida e o trabalho do desenvolvedor de soft'vvares. Mas, para a maioria dos progra-
madores, o ,notivo pelo qual programam pode ser definido e1n tennos 1nais si1nples: eles escre-
vem códigos que fazem algo de útil. A finalidade efetiva da progra,nação é fazer o hardware do
con1putador realizar tarefas práticas; é isso que guia a 1naioria dos desenvolvedores de softwa-
res. Meu co-autor e eu n1antive1nos esse conceito e,n mente por todo o livro e nos certificamos de
que quase todos os progra1nas que mostran1os executasse u,na função de utilidade, alén1 de for-
necer a experiência para o aprendizado. É esse o objetivo real, criar aplicativos úteis, que conduz
muitas pessoas ao Visual Basic,já que ele é considerado por muitas delas como o ca,ninho n1ais
rápido para passar da idéia ao aplicativo.

Um Breve Histórico sobre o Visual Basic


A história do Visual Basic na verdade corneça corn a invenção do BASIC (Beginner's
All-purpose Sy,nbolic Tnstruction Code) em 1964, u1na linguage1n que é facihnente assitnilada e
usada por programadores iniciantes. Essa linguagern se tornou popular, e, durante os 15 anos se-
guintes, várias pessoas e empresas criaram compiladores e interpretadores para o BASIC.
En1 1975, quando a Microsoft era un1a empresa nova, u1na versão da linguage1n BASIC foi um
dos priineiros produtos que ela criou, e que se tornou um sucesso. O BASIC da Microsoft e seu
sucessor, o Quick BASIC (ou QBASIC, co1no também é conhecido), se transfonnara,n nas ver-
sões do BASIC rnais a1nplamente disponíveis nos PCs. Elas ainda possuem uma quantidade bas-
tante grande de usuários (se você estiver interessado, acesse o endereço http://www . qbas i e. com
para obter recursos e links sobre essa linguage1n). O Quick BASIC estava disponível para Win-
dows quando foi lançado, mas era necessário u1n trabalho considerável para codificar uma inter-
Bem-Vindo ao Visual Basic .NET

face co1n o estilo do \Vindows, de 1nodo que ele não era muito apropriado para codificação nesse
novo a1nbiente.
No entanto, a Microsoft apresentou um novo produto que combinava a linguagem popular e fácil
de aprender do BASIC co1n utn a1nbiente de desenvolvimento que permitia aos progra1nadores
criar graticamente a interface con1 o usuário para u1n progra1na. Esse produto, como você já deve
ter adivinhado, era o Visual Basic 1.0. No início, ele não foi adota.do, mas fornecia reahnente u,n
a1nbiente veloz para o desenvolvi1nento de interfaces gráficas co1n o usuário (GUls). O que pode
ser uma surpresa é que o Visual Basic, na verdade, con1eçou com uma versão em DOS, embora
tenha sido logo transferido para o Windo\.vs (veja a Figura l .7).

ex
FIGURA 1.7
A. pritneira versão do
Visual Basic para
Windou,s .fornecia ...... . .... .. .. ........ .. ............. ....... .. ...... .. ............. .. .. I v-r-1 v-co.ie I
...... ...................................................
. ..... .. .········
.................. ..... . ......·····
.. ... ... ············
' '

),,, ... . .....


.. . . ~ Glob... b.u O-
nntitos dos recursos O+- o t • • • • • ' • • • • • • • • • • . • • • • • • • • • • • • • • • • • • • • • • • • • • •••••••••••
essenciais co111uns en,
111=
fCII.
~
Ji'I. 1::::
~
. . . ·· :::
··· • • ::
. . :::::··:·: • . . ·:::::::
• • • • • • ...........
ffi!lffll •'1 .: ..: ::: . . Cowndl
. :::: ,
. . . • :::::::::
• • • . • • • .............. :::
. . . ::::::::::::·
• • • • • • • • • .... . ...........
• • • • • •••••. .
L;'J forml Ir• For.,..,

várias ferra,nentas m .. , . . . . . ... . :i;;,;;·:······1;


. . .::::;;;;;;;;
...........::::::;:;:;:;:::
...... ..... .... ........ .. .............. .
[!13 w ::: . :.::::· .. :. ·.:·:::. :::::::::::::;::::::::::::::::
. .. ............................ . ·· ·· -····-·· . .. · ····· ·-·····
atuais, e o n1ais
irnportante foi sua
"' 8 ........................................................ .
i ::: :::::::::::::::: : ::::: :::: :: :: : ::: :::::::; ::: : ::::: ::: ::::

forrna visual ele


~
L.J· l!!J
O
!...' .........................................................................................................................................................................................
••• •• •• • •••••·•
. . . • • • • . . • • • ••
,
.
•·••• •· ••••• •••••••· •••
••••• .• • ••. . •••••• •• •. .
·••••
•••••
.. .........
.... . .. ..
••
••

......... . ....
!!: :::: ::: :::::: ::::: ::: ::::::::: :::::::::: '
::: : :: :: ::::::::::::
arrastar e soltar usada .....' ..' ... ... .. ... ... ... ... ... ... ... ..... ... ... .. ..' .. . .. ... ...... ... .. .. ... ... ... ... ... ... ... ... ..... ... ... ... ... ... ... ... .. ... .. . .........
.
.
. .
. . . . . . .. . ..
no desenvolvilnento. ........... ............... . . .... .. ... ......... ...
.
. .
"
...
. .
. . ................. . ... . . ....... .. .. .
.

f:. .::. .:::::


................ . ..: ..: ..:::::: .. . ......::: . .. .... .. .. ...::
. . :. .: ..~~:::::
. .
. . .. .. .' .. ..: ..: ..:::
..:::::
. .....::...::::: . . ... .......
... ...... ::::::::::: . . . . . . . ..::
.............. . .. ............ .... ..... . ....... .. . .

............' ...... ................................ ...... ......... ............................................................ ...........


' .
. .
.......... . .... .. ....
'

.... ............. .. .. . ............. ...... .....................


"

O Visual Basic cresceu em popularidade co,n o tempo. U1n único recurso se 1nostrou essencial
para seu sucesso. Era a possibilidade de a Microsoft, o programador e outros fornecedores cria-
retn co1nponentes de interface personaliza.dos que podiam ser adicionados aos programas. As
empresas rapida1nente entraram nesse 1nercado, desenvolvendo componentes que adicionavan1
vários recursos aos aplicativos do Visual Ba.sic, como a geração de gráficos, edição de iinagens,
conexões com 1nodems e 1nuitos outros. Esses co1nponentes permitiam que o progra1nador do
Visual Basic criasse aplicativos 1nais avançados combinando vários componentes con1 seu pró-
prio código. Isso au,nentou 1nuito o desenvolvi1nento rápido possibilitado pelo Visual Basice
ajudou a torná-lo u1na das linguagens mais populares de programação.
Toda. versão atualizada. do Visual Basic adicionava. novos recursos, o que o tornava. cada. vez
1nais u1na ferra1nenta de desenvolvimento cornpleta1nente capacitada. U1na alteração importan-
te, em particular, foi na maneira co1no o Visual Basic era processado no tetnpo de execução. Até
a versão 5 ser lançada en1 l 997, o Visual Basic era urna linguage1n interpretada, o que resultava
ern um desempenho relativamente fraco se co1nparado com o do Visual C++, Delphi e outras lin-
12 Dia 1

guagens compiladas. O Visual Basic 5.Otornou possível criar versões compiladas ou interpreta-
das de programas, e o dese1npenho 1nelhorou de 1nodo considerável.
Outra alteração essencial no Visual Basic foi a possibilidade de criar cornponentes. Em progra-
mação, encontra-se con1 freqüência u1n trecho de código, como u1na rotina de cálculo de hipote-
ca, que poderia ser usado e1n muitos locais do programa e potenciahnente até 1nes1no em vários
progra1nas diferentes. O compartilharnento desse código dentro de um prograrna e1n geral é con-
seguido escrevendo-o como um procedimento, um bloco de código que é digitado uma vez no
prograina, ,nas pode ser cha1nado de qualquer local do aplicativo. O co1npartilhamento entre
progra1nas pode ser feito apenas copiando-se o código do procedin1ento e1n cada novo aplicativo
que for desenvolvido, mas isso gera um problen1a. Sempre que você, ou outra pessoa, fizer u1na
alteração nesse bloco de código (para corrigir um erro ou rnelhorar a maneira do código funcio-
nar), precisará copiar o código para todos os aplicativos que o utilizam.
Uma maneira de melhor compartilhar o código é criar u1na biblioteca de códigos armazenada en1
tun arquivo separado dos prograrnas que o utilizrun e que possa ser alterado de modo indepen-
dente. Essa biblioteca é conhecida co1no coniponente e é criada quase sempre na forma deu.mar-
quivo .d ll. Usar tuna biblioteca é o rnétodo preferido de co1npartilhar códigos. No decorrer do
desenvolvimento de novas versões do Visual Basic, sua capacidade de criar esses componentes
foi avançando regularmente. A versão 4.0 (lançada en1 1996) foi a prilneira a permitir a criação
ele co,nponentes, e hoje esse é tun recurso extrema1nente essencial e1n projetos de desenvolvi-
1nento. Discutire1nos os con1ponentes com 1nais detalhes no Dia 14, "Introdução à Programação
Orientada a Objetos".
Muitos recursos co1nplementares foram adicionados ao Visual Basic, mas tudo foi construído
ern cin1a da base existente. Isso não é raro. A 1naioria das ferra1nentas de desenvolvi,nento pro-
gride dessa maneira, contudo há o efeito colateral de acumular lixo. As versões novas de uma
ferra1nenta tenta1n 1nanter a co1npatibilidade co,n todos os aspectos muito pouco eficazes das an-
teriores. Reescrever uma linguage1n a pa1tir do zero é quase impensável. O trabalho necessário
poderia ser enonne, e romper a co1npatibilidade co1n o código já existente para o usuário pode
não ser betn aceito. O benefício de uma mudança dessas seria tuna imple1nentação nova e limpa
por co,npleto, que poderia manter o que fosse bom e desca1tar as partes inválidas da linguagen1
anterior.
lsso foi exatamente o que a Microsoft fez na passagem do Visual Basic 6.0 para o Visual Basic
.NET. Ela reescreveu a linguagem para criar uma versão limpa que eli1ninasse o lixo que se acu-
mulou por tun.a década de atualizações sucessivas. Isso significa uma curva de aprendizado se-
vera para as pessoas que tinham experiência na versão anterior da linguage1n, n1as o resultado
final vale o esforço. A alteração radical faz com que este seja u1n grande momento para ser inician-
te no Visual Basic,já que os conceitos ensinados neste livro terão uma vicia útil 1nuito mais longa
do que aquilo que se aprenderia co1n um material relacionado à versão anterior.
Há muitos benefícios nessa mudança, todos eles foram estimuladores dessa decisão, mas a n1oti-
vação n1ais significativa foi a necessidade de adaptação ao novo ainbiente .NET. No decorrer
Bem-Vindo ao Visual Basic .NET

desta lição, você aprenderá mais sobre a plataforma .NET, o que é e como o Visual Basic se en-
quadra nela.

,
O Que E .NET?
À prin1eira vista, .NET pode parecer apenas um conceito de marketing, uma maneira de evitar
mais u1n nú1nero após Visual Basic, 1nas é ,nuito mais que isso. .NET representa toda u1na gan1a de
tecnologias e conceitos que forma,n uma plataforma na qual você pode desenvolver aplicativos.

Na verdade, o Visual Basic .NET possui um número real de versão, 7.0- só que
NOTA ele não é muito usado. Da mesma maneira como o Windows 2000 é na realida-
de a versão 5.0 do Windows NT, quanto mais simples ou assimilável é o nome,
mais ele é usado. No entanto, não espere ouvir Visual Basic 7.0 com freqüên-
cia; havia até uma penalidade em dinheiro dentro da Microsoft para quem se
referisse ao Windows 2000 como NT 5.0.

No início desta lição, expliquei co1no o sistema operacional fornece u,n nível de funcionalidade
básica aos aplicativos (co1no a possibilidade de ler arquivos de u1n disco rígido ou disquete). A
plataforma .NET pode ser explicada de maneira se1nelhante; ela é uma camada que existe abaixo
de seus progratnas e fornece u1n conjunto de serviços e funções básicas. Essa camada conté1n urn
grupo de aplicativos e sistemas operacionais chamado servidores .NET; um conjunto básico de
objetos cha1nado .NET Framework; e um conjunto de serviços que dá supo1te a todas as lingua-
gens .NET chamado Con1mon Language Runtin1e (CLR). Cada uma dessas partes da plataforma
.NET (veja a Figura 1.8) será abordada individualmente.

FIGURA 1.8 Aplicativo do Usuário (incluindo seus programas!)


.1YET é ,nais do que
apenas 11111 item; é u,11
conjunto de s0,ft11,ares e .NET Framework
conceitos que
.funcionan, juntos para
Servidores .NET
per,nilir a criaçcio de
Windows, BizTalk, Exchange, SOL, App Center...
soluções para
e1npresas.
Dispositivos .NET

Componentes de Hardware
14 Dia 1

Servidores .NET
O principal objetivo do conceito .NET é di1ninuir o desenvolvimento de siste1nas distribuídos,
nos quais o trabalho é feito e1n vários locais diferentes. E1n geral, esse tipo de siste1na faz seu tra-
balho no back-end, no nivel do servidor. A Microsoft fornece um conjunto de softwares que jun-
tos são conhecidos como .NET Enterprise Servers. Eles fora1n projetados para substituir os
recursos de back-end necessários ao siste1na distribuído. Esses produtos incl.uem:
• Um siste1na operacional do servidor, o Microsoft Windows (Server, Advanced Server e
Datacenter Server)
• Softwares de agrupa1nento e balanceamento como o Microsoft App Center e o Microsoft
Cluster Server
• Um servidor de banco de dados, o Microsoft SQL Server
• Um siste1na colaborati.vo de correio eletrônico com armazenamento de informações de
forn1a livre, o Microsoft Exchange Server
• Um 1necanismo de transfonnação de dados com base e1n XML (falarei 1nais sobre a XML
no Dia 20), chan1ado Microsoft BizTalk Server
• Un1 servidor para o acesso a sistemas legados, como o AS/400s, cha1nado Host lntegrati-
on Server
• E mais ...
Juntos, esses servidores fornecerão os serviços básicos a seus aplicativos .NET, fonnando o ali-
cerce dos sistemas. Este livro se referirá a eles algumas vezes, mostrando onde podem ser usados
e1n seus sistemas .

.NET Framework
Na passage1n para o Visual Basic .NET muitas coisas fora,n radicahnente alteradas; u1na delas
foi o desenvolvimento de urna nova base para todas as ferramentas .NET de desenvolvimento.
Essa base, conhecida como .NET Framework, fornece dois itens essenciais: o ambiente princi-
pal de tempo de execução e u1n conjunto de classes básicas. O a1nbiente de te1npo de execução é
se1nelhante ao siste1na operacional por proporcionar u1na ca,nada entre seu programa e as co1n-
plexidades do resto do siste,na, executando serviços para seu aplicativo e si1nplificando o acesso
aos recursos das camadas inferiores. As classes básicas fornecem um vasto conjunto de recursos,
empacotando e detinindo essas tecnologias co1no protocolos da Internet, acesso a siste1nas de ar-
quivos, manipulação de XML e 1nais.
O verdadeiro poder dessa estrutura será explorado com mais detalhes no Dia 8, "Introdução ao
.NET Fra1nework". Por enquanto, só temos de entender que o .NET Fra1ne\.vork é e1n 1nuitos as-
pectos semelhante ao sistema operacional e que fornece seu próprio conjunto de APTs a fim de
facilitar aos programadores o aproveitrunento de seus recursos. A Figura 1.9 ilustra o relaciona-
mento do Framework conJ o seu código e com os serviços subjacentes do siste1na operacional.
Bem-Vi ndo ao Visual Basic .NET

FIGURA 1.9
Aplicativo do Usuário (incluindo seus programas!)
O .NET Fra1ne111ork
fornece outra ca,nada
de abstração sobre o .NET Framework
siste,na operacional,
exatamente como esse
.faz para o har<Íl11are Sistema Operacional
do co111putador.
Drivers de Dispositivos Drivers de Dispositivos

Componentes de Hardware

Para u1na linguage1n de progra1nação se beneficiar do a1nbiente de te1npo de execução e outros


recursos do .N-E T Frame\.vork, o compilador deve produzir um código que adote u1n certo pa-
drão. A Nlicrosoft fornece esse padrão, o Comn1011 Language Specification, como uma maneira
de fazer co1n que qualquer con1pilador possa ser usado na platafonna .NET. Ela criou os co1npi-
ladores do Visual Basic, Visual C++ e C# que se destinam ao .NET Fra,nework, mas também
disponibilizou o Common Language Especification fora da Microsoft de modo que outras em-
presas pudessen1 desenvolver con1piladores para outras linguagens. O resultado é que, alé1n das
linguagens fornecidas pela Microsoft, 1nuitas outras existentes (como o COBOL, APL, S1nall-
talk e assiin por diante) fora1n desenvolvidas sobre exatamente a mes1na base do Visual Basic.
NET.

Neste ponto, é impo,iante distinguir os recursos fornecidos pelas linguagens e os proporciona-


dos pelo .NET Framework. O Visual Basice o COBOL co1npartilha1n todos os recursos do Fra-
me\.vork, n1as, já que são linguagens diferentes, ta1nbém possuen1 suas próprias funções e
sintaxe exclusivas. Ao dar prosseguiinento à leitura, você aprenderá tanto sobre os recursos es-
pecíficos do Visual Basic quanto os fornecidos pelo Fra,nework.

Serviços .NET
A platafonna .NET inclui certos conceitos que se estendem além dos detalhes de programação
para descrever como os sisten1as deve1n ser desenvolvidos e pode1n interagir. Um desses concei-
tos essenciais é a idéia de serviços da Web, recurso distribuído de uma 1naneira consistente de
modo que sua execução fique totalmente confinada em seu a1nbiente. Um exe1nplo desse tipo de
serviço pode ser uma folha de pagamentos, para a qual u1na empresa possui servidores e aplicati-
vos e1n sua própria organização que pode1n 1nanipulá-la. A e1npresa fo,nece esse serviço para
outras por 1neio de u,n serviço da Web (veja a Figura 1.1O). lsso é diferente de apenas disponibi-
lizar u1n site da Web; é u1na interface que outros aplicativos ou sites da Web poden1 acessar atra-
vés de código.
16 Dia 1

FIGURA 1.10
Uni se1,1iço da l Veb
1

per111ite que as
e,npresas .forneça,n
serviços coni base em
sof1111are pela Internet e Servidores do Aplicativos Clientes
que outros aplicativos Windows 2000 Executando
e/011 sites Serviços da Web

da Web os 11tilizen1.

........
=

-
Grande Quantidade Servidores Web
de Serviços Disponíveis

•o

•El licitações Ji'.ML


Resoostas XML

Os serviços Web podem ser expostos a partir de


qualquer sistema operacional e criados com qualquer
ferramenta de desenvolvimento que dê suporte a HTTP. Usuários Remotos

Essa tecnologia pode ser usada de várias 1naneiras, 1nas o conceito de serviços da Web consiste
em que há certos serviços básicos ou fundatnentais de que 1nuitos aplicativos precisam, como
autenticação, organização de calendário, envio de tnensagens (correio eletrônico) e outros. Se
esses tipos de recursos foren1 serviços da Web, qualquer pessoa no n1undo poderá se beneficiar
deles para reduzir o ten1po de desenvolvimento de seu próprio sistetna. A Microsoft, como parti-
cipante da ini.c iativa .NET, está fornecendo alguns desses serviços para autenticação (con.hecido
como Microsoft Passpo1t, www . passport. com), envio de 1nensagens (hotrnail, www. hotma i 1 . com)
e outros.
Posteriormente, no Dia 21, "Criando Serviços Web co1n o Visual Basic .NET", forneceren1os
urna introdução apropriada aos serviços da Web e nos aprofundaremos em corno você pode
usá-los em seus aplicativos.

Dispositivos .NET
Atualmente, há uma grande variedade de sistemas que podern ser usados para se conseguir aces-
so à Internet, à rede de sua e1npresa ou a suas infonnações pessoais. Sendo eles PCs cornpletos,
tenninais da Internet corn base em TVs, simples clientes ou Personal Digital Assistants (PDAs);
todos são possíveis dispositivos utilizados pelo usuário para acessar um aplicativo .NET. Essa
Bem-Vindo ao Visual Basic .NET

tendência direcionada a vários dispositivos forçará você, como progra,nador, a esquecer o


padrão geral de um único tipo de cliente, etn geral un1 PC, e a considerar, em vez disso, que wn clien-
te poderia estar se conectando por meio de um entre muitos dispositivos possíveis. Esses podem
ser classificados co1no dispositivos .NET - u1naco1nbinação de recursos de hard\.vare e soft.\vare
projetados para funcionar co,n os serviços e aplicativos co,n base na plataforn1a .NET. Hoje, a
variedade de dispositivos .NET disponíveis inclui con1putadores que executam o Windows
(Windo\.vs 9x, Mi llenniutn Edition e Windo\.vs 2000 coin o .NET f ratnework instalado) e dispo-
sitivos que executan1 o Windows CE. (O .NET Fra1nework cotnpacto está disponível para essa
platafonna, permitindo o supo,te aos recursos .N-ET.) Haverá um cresci,nento contínuo nessa
área.
Não se preocupe se ainda houver partes da platafonna .NET que parecetn confusas: elas preci-
sam ser! Durante os dias restantes, as lições deste livro explicarão tnais detalhes que ajudarão a
esclarecer tudo. Por enquanto, lembre-se do relacionamento entre a plataforma .NET e seus pro-
gra1nas - tuna ca1nada de funcionalidade que já é fornecida e fácil de acessar pelo seu código.
Co1n esse conceito e1n tnente e sabendo que o resultado final é um desenvolvi1nento mais rápido
na passagem da idéia para o programa concluído, você terá aprendido bastante sobre a platafor-
1na .NET nesta lição.

Desenvolvendo seu Primeiro Aplicativo no


Visual Basic .NET
,
E hora de escrever seu primeiro trecho de código do Visual Basic .NET. Antes de continuar cotn
este exemplo, e os do resto do livro, você deve ter o Visual Basic .NET instalado. Nesta seção,
explorarei o processo de instalação do Visual Basic ou do Visual Studio (incluindo o Visual Ba-
sic) en1 seu computador. Se já o tiver instalado, vá para a seção "Onde Está meu TOE?".

Preparando-se para Codificar


Antes de realizar qualquer trabalho com o Visual Basic .NET, será preciso instalá-lo. Você deve
ter vários CDs ou um DVD (dependendo de onde conseguiu o produto) pelos quais possa fazer a
instalação. Também é possível instalar de u1n local da rede, mas o processo é basica1nente o 1nes-
1no nos três casos, sendo a principal diferença a alternância de CDs se você tiver a versão que
vetn etn vários deles.
A primeira tela que você verá quando inserir o disco 1 ou executar a instalação pelo CD ou pela
rede, será unia caixa de diálogo que apresentará três etapas distintas (veja a figura 1.11 ).
A pri1neiraetapa é elevar os co,nponentes do sistetnaoperacional de sua 111áquina até o nível que
a plataforrna .NET exige. Isso é chamado de Windows Co1nponent Update (WCU), e se você der
u,n clique na pri,neira opção da caixa de diálogo da instalação (veja a Figura 1.11 ), será solicita-
do a fornecer o disco de WCU, se necessário, e a instalação começará. O que é visto durante a
18 Dia 1

instalação do WCU depende do sistema, porque apenas os itens que ainda não foran1 atualizados
o serão. Algumas das instalações possíveis são a do Windows 2000 Service Pack 2, do MDAC
2.7 (co1nponentes atualizados de acesso a dados) e do Internet Explorer 6.0. U1n item que será
instalado na maioria dos siste1nas é o próprio .NET Fran1ev.1ork, que não inclui o IDE do Visual
Studio .NET, mas fornece todas as classes e arquivos de suporte do Fran1ev,rork necessários à
execução dos aplicativos .NET. Dependendo de que co1nponentes foren1 precisos, o programa
de instalação pode ter de reinicializar seu computador u1na ou mais vezes. Quando essa instala-
ção estiver concluída, você retornará à primeira caixa de diálogo de instalaçã.o, co1no mostra a
Figura 1.11.

FIGURA 1.11
O processo de
instalação do Visual
Studio .NET é dividido
Wlndnw!j: Comonnent Updotc
ern três etapas. Re1nslbll Wln-dows ccmponents fo r Visu~I Studio..NET to
énsuTc t.h4t thc)' .:ire n()t C:Ol'l'Upléd, o r msto11 \'I n e i,1 vcni.on
ot the Windovvs Component Updo\e,

Dê um clique na etapa 2 para iniciar a próxi1na parte da instalaçã.o do Visual Studio .NET. Você
será solicitado a inserir a chave do produto e aceitar ou não o Contrato de Licença de Usuário Fi-
nal (EULA, End User License Agreement) antes que a instalação principal possa ser iniciada.
Depois que as inforrnações solicitadas forem fornecidas e o EULA aceito, surgirá uma tela corn
várias opções em que poderão ser selecionados os ele1nentos do Visual Studio .NET que você
deseja instalar (veja a Figura 1. 12).
A Figura 1. 12 foi baseada no Visual Studio .NET Beta 2 e algumas das opções podem se alterar,
mas no geral você deve ver a mesma lista. Se estiver planejando progra1nar grande parte no
Visual Basic .NET, sugiro a seleção das mesrnas opções que podemos ver na Figura 1.12. A pri-
meira escolha digna de nota foi a seleção do Visual Basic e do Visual C# na opção das lingua-
gens. O Visual C# não é necessário, ,nas veremos que ,nuitos exemplos de código estarão
disponíveis nessa linguagem, e é n1ais provável que façamos testes co1n a C# do que con1 a C++.
També1n é possível selecionar o Visual C++, rnas só é aconselhável fazê-lo se houver reahnen-
te a pretensão de usá-lo já que ele ocupa mais espaço e,n disco do que qualquer das outras Iin-
guagens.
Bem-Vindo ao Visual Basic .NET 19

..
• - X
FIGURA 1.12
:. '
Você pode examinar e
selecionar quais
co,nponentes do Visual ....... ~loolS
Studio ./liET deseja Sebl ltetn:L to iru,loll; f•IJJ, F' ,.;.\Aog#ll Fff'1~0:.1C1tOltVnuol SOJdot.'[ T\

instalar.
8 li!! b Vlsu,ol StodioJrEI (ntc, p,*1,c EdoUon
e !atblfi,\l@ij$tt:tN
!p.xeRc~ .........
e,i:t,........... O ff!,>tur,;: dNc,lpUon
O X -Ctt
'i' l<!.!J»IWI e, uoouaoe To.ois
1/S De>veloomtnt f11ffonmeM. ~d l-6nouaot woi.s. .d
Q 121itJ lott'rtMI~ Dc-vrlol)me:flt lcwik
9!t,c,ysul P,e,c»u t~ ~elSWJo..1-El
.:.J
fi!!~ V!JWI ~E,«,fffie YttttibCtt
e Bó•""'"""°lt+!I
til ít]ct) Erter?'se So!mles
Show/HHfe Qrfv~•· I
E!o"""'-"'""" o,~c:

m21~
l Eaí!)Ai~Cent«
0$1:Y\sWil !hdo/wly:fJt
lilitl"""'""'-.....
Sctve,- (M'OO(le1'U
Ttstl~\t,u,ilstvd,) ,.C

"'
. Vk'dSpJCt C,AQI)
.ft'e!!c).!(.e(4.lGS)

9 i!:litil fooisc I« R~1Jtr1butJn9 A~


m eim.~·ooc...n~Mt"UOf\ O,fflt D:
• 1 ic.o.1 <Cri..-.. fl Q Qll .:.J
-·~--------~.!l

Rrniao: Qcfaul"

A seguir, certifique-se de que marcou todas as opções disponíveis e1n Enterprise Tools, Server
Con1ponents e Tools for Redistributing Apps. Não explicarei o que essas opções contêm, n1as
marcá-las assegurará que você tenba todos os recursos disponíveis en1 sua versão do Visual Stu-
dio (versões distintas do Visual Studio possue1n conjuntos diferentes de opções de recursos).
Para concluir, selecione MSDN e 1nantenha a configuração-padrão Run from source, que solici-
ta.acesso a seu CD, DVD ou local de instalação na rede, ou se tiver bastante espaço e1n disco, al-
tere para a instalação etn utn caminho específico (veja a Figura 1.13). Executar o MSDN do local
de instalação é 1nais lento do que tê-lo en1 sua 1náquina local, mas a decisão e1n geral é baseada
no espaço disponível e1n disco e1n vez de na velocidade.

FIGURA 1.13 :. :. 1 •

As bibliotecas lv/SD1V,
que contêm ,nuitos
docu,nentos e artigos
úteis, podendo os Sdttt ilcn~ lo in.1tól:
e fa\!)Vh.u.ol Shtdio.N.Y foterpri1< fdit.lon
exe,nplos ser instalados &-121±,t.nou"'OCI lool~ 1 1
(i!~......... O rcotu,e ~iption
locabnente para que se O X VtAJlJCH NS01'1 for Vbuol 5tudlo,NET
~ QfâVdUdC• Th,e Mile:rotoft Oov,IOPi:r u ,ti,r,o,~ (MSO.N) Libtor'f lf th11 u1c.M:11I
obtenha 111ais G S!ls!>tntcrpri,cOcvdoc,mcnt toob rr.'ct.r,nco fOf' dovelqper$, ..tth ffiOf"O th-,-. • ç1oi1by,o o! tctchncol
proi:;r am!"IW'JQ 1nforrn.l~on
$ f;!l~Servcr (OO~f'lt.S Aooessino m. lib,.,ry, "l'O\I c.in 'l'iew:
velocidade. e 52!,:blool, for RC'di,.triblAá,,g Afl9•
& l<l(:l~ -
Ga~vàut1Sh.d:10oo.,riertd,Jon

50<-
&J~Vd>.l:J~Docu'!~·-teU:11 Drive C:
~ (;}V8J1'C# o « ~ • UJecJ!Ciac~ (7.tc:iB)
9 @ ,V~!IIC+.- Docuud.!,U!r'! • M'H !ic)a(e (..; :3 G8)
(i!(i:,.,.,., '--'"
&l(i:!.""""" " " -
(i! • Md_..,...__
Ci1(l:.V~lll~ T@.an:ls;o.: Ooo.ncrt.tl:lon
O,.iYo D:
!ill.;!...,,..._ ............
20 Dia 1

Depois que você fizer todas as suas escolhas, dê um clique no link Install Now! na parte inferior
da caixa de diálogo para iniciar a instalação. Vários trechos de texto que descrevetn os recursos
da platafonna .NET serão exibidos enquanto a instalação progride, encerrando por fim com u1na
tela de tértnino (veja a Figura 1. 14). Se algo der errado durante a instalação, será exibido nessa
tela.

- C' X
FIGURA 1 .14
Se algo der errado
durante a instalação,
você será inforrnado do
11roble111a nesta tela. Setup is complete.
Thtr• wel'e no t rrofS dunno serup. To femove umo,ont'l files W t wtft c,u~td ~ntl(I ttt!JCI!, ,ou m•r w1sh to ,esurt
,out o,mpui.r. \'ÍJU-tl $'tl.,d10,li!T ~ uftl't bt run iK •nr1.tmt,
fO< lnform.,tion on ctiegnosino p,obi.m• SH tht ~ .
FOt" detti!ed Wo,mttion- on tht insulltlion s. . lht <11rrcw tog

t,f,oio,:ol!V~Sh.do llf;T 7.0Ei~ t Sell..O• coni:-ele


T"" ,CfflQt'..,,_ Ofl'ft.âc

Por fim, quando você tiver retornado à tela inicial da instalação, a terceira opção estará disponí-
vel. Dar um clique nessa opção, Service Releases, o conduzirá à outra caixa de diálogo (veja a
Figura 1.15), etn que poderão ser selecionadas as atuaUzações da instalação pela Web ou pelo
disco. Se houver conectividade co1n a Internet, reco1nendo escolher a pri1neira opção para asse-
gurar a obtenção da lista mais recente de atualizações.

FIGURA 1.15
O progra,na de
instalação do Visual
Studio .NET pode fazer \lts-uõl Studio.ffET 1 .O Setu? olloYJs you to 1ostoll Service Rcleoses thot updoto
your JJStem w•th thc lotcst vor11on of v,s.u-.11 Stvd10 .f<ET, Serv10l" Releote:.: olso
o doivnload e instalar 1nelucf!: updotes o{ requ,red Vl,ndow$ eomp<Wient~.

atualizações pela fà êhecllii:J.crvlCe tstl<Í.ASOLOO tlii; lntcr:iii:J


internet.. ~ l hi; o~ i. reo:.~ed to onnre ~ t.,vo lj-.e, b'o:t Servic:,c,
Acn'"e"- lf mete reçcnl Serv,;c Rel*e; .cite ~•btle.y«J~I h:ivethe
oPl,IM o# ex,,...,~ !htff'l llffll lhe rr,~l'>f( 0t n!l&lng, thfm Íl<lh 6 <th•.
I l11tvr II Yh:u~I ~1udin.NET 7.0 Sit'rYiCP Padr did(
Choott ct.= ((lhen t yw w.vcto mldl a St'Mce-P.c:t( fr"" • 6~ yw
a\i'J.rl\' O'HI\ 1l'i: OObM .,.,ti l"IC( <hcc~ tocor,füm th)l tha vct:,c.) d lhe
Se1\~e'Po..lt i; tt;c bte.t
Bem-Vindo ao Visual Basic .NET

Agora o Visual Studio .NET está instalado e deve estar pronto para ser executado, portanto, você
pode passar para a próxi,na seção etn que co,neçará a escrever alguns códigos.

Onde Está meu IDE?


Agora estudaren1os o Visual Studio .NET, u,n dos mais avançados pacotes de desenvolvimento
disponível, e seu prirneiro progran,a vai ser elaborado corn o uso do Bloco de notas e do pro,npt
de co,nando. Si,n, é exata1nente o que leu, o prompt de comando. No início desta lição, expliquei
que rnuitas linguagens de prograrnação eram co1npostas apenas de um co1npilador. Em uma lin-
guagern desse tipo, os progra1nas são escritos co1no arquivos de texto e, em seguida, o compila-
dor é chatnado para converter esse código (pressupondo-se que não tenham sido cometidos
en·os) etn un1 programa executável. Na maioria das linguagens, isso nunca foi alterado. A final i-
dade de utn IDE é fornecer utn ambiente único de trabalho, 1nas ele ainda estará usando a mes1na
seqüência de edição/compilação/execução do processo 1nanual. Antes do Visual Basic .NET,
tuna linha de co1nando podia ser usada para cotnpilar os progra1nas, n1as isso era o mesmo que
executar o IDE de modo não visível. O Visual Basic .NET separa as duas funções, compilação e
edição, pelo fornecimento do con1pilador con10 um progran1a completamente distinto.
Com o IDE, você nunca precisará examinar a co1npi lação. Ela será manipulada de modo auto-
mático, mas ainda assim será executada. A principal diferença entre o cotnpilador do Visual Ba-
sic .NET e o de versões anteriores é que aquele é totahnente independente do IDE; não há nada
que você possa fazer no IDE que não possa ser fe ito corno uso apenas do cornpilador da linha de
comando e o Bloco de notas. Já que o IDE é um progra1na grande e co1nplicado, será mais siin-
ples se concentrar na linguagem e trabalhar no nível da linha de comando de tempos em te1npos.
A lição de amanhã- Dia 2, "Trabalhando corn o Visual Basic .NET" - introduzirá o IDE e per-
correrá os fundamentos de seu uso para edição, execução e cornpilação de seus programas.

Uma Tarefa Simples


Para criar seu primeiro programa, você precisará de um objetivo, algo para ele executar. Não é mi-
nha intenção produzir progran1as "Hello World!" neste livro, aqueles que não possue1n u1na finali-
dade. Isso é patticulannente dificil quando se tenta escrever o prin1eiro pequeno trecho de código.

Novo TERMO
A expressão programa "Hei/o World!" ou "Olá Mundo! " descreve o exemplo de
u,n programa que não faz nada de útil, ou ,nais especificamente, nada mais útil do
que apenas exibir a n1ensagen1 solicitada.

Você vai corneçar co.m u1n programa que poderá executar da linha de co,nando e que retornará
u1n texto pequeno. Ern seguida, mostrarei co,no esse progra,na ilustra quase tudo que é preciso
saber para desenvolver um utilitário proveitoso que exiba infonnações sobre a versão de seu sis-
tema operacional (por exetnplo, no lançamento do Windo\.VS 2000 houve uma versão nº
5.00.2195). Isso pode ou não ser útil como utn utilitário de linha de comando, mas de1nonstra o
conceito básico de sua criação.
22 Dia 1

Escrevendo o Código
Já que você con1eçará e,n u,n editor de texto (como o Bloco de notas) e,n vez de no JDE, nada
será feito de ,nodo auto,nático, e o arquivo a princípio estará vazio. Isso significa que será preci-
so configurar a estrutura básica de seu programa antes de começar a escrever u1n código que seja
compilado corretatnente. Para iniciar, crie utn arquivo novo de texto e,n algun1 local de seu co,n-
putador; para os exemplos deste livro, crie u1n diretório e1n seu computador cha,nado
C: \ TYVB\Cl \ . Para gerar o novo arquivo de texto, dê um clique co1n o botão direito do mouse na
pasta apropriada e selecione Nev.1 (Novo) e Text Docu,nent (Documento de texto) (veja a Figura
1.16). lsso criará um arquivo de texto cotn extensão txt. Renomeie esse arquivo para que indi-
que seu conteúdo final alterando para Stepl. vb.

FIGURA 1.16 •
An~I~ •
O ,nenu de atalho do l-., Up IC<ltlS
Relre,t,
E.xplorer.fornecerá a
voce 11111a 1nane1ra
A •

direta de criar 1.1111


arquivo de texto e 0 $,ort<ul
,nuitos outros L---"--'--'-"-------1
a 1111.,""'"
docu,nentos. 'f/ 8lmap lmoge
~ M'crosdt Wctd Ooo.ment
@ M'aosdt Access Ap.,i;c.ti:,n
@] M'aosdt Powe,Point Pr-ion

~ M'ao<dt 1/lslO o,ow1no


'fil W•~ SOund
~ Mcrosdt Excel Worl<sheet
~ WfnZé> file

Com o arquivo reno1neado e no diretório correto, você poderá dar prossegui,nento e começar a
configtirar seu código efetivo. Abra o arquivo no Bloco de notas dando um clique nele com o bo-
tão direito do n1ouse e selecionando Abrir con1. Isso abrirá un1a caixa de diálogo por meio da
qual será possível selecionar o Bloco de notas ou outro editor de texto (o Word Pad, por exem-
plo). Depois de ter selecionado um progrruna, dê u,n clique e1n OK, e o arquivo será aberto. Nã.o
deve haver nada nele neste 1non1ento; você terá de adicionar tudo que o fará funcionar.

Execução Passo a Passo


Se1npre que você escrever u,n código, e principalmente quando fizer algo novo, tente resolver o
caso em várias etapas. Dessa maneira, ao se deparar com u,n problema, saberá que pa,tes do pro-
grruna funcionara1n e quais não tiveram êxito.
Na prin1eira etapa, você se certificará de que pode criar u1n aplicativo por 1neio do compilador de
lin.ha de co1nando. Para tanto, precisará de um código, porém ele não precisará executar real-
1nente nada. Apenas terá de apresentar o for1nato correto. O código a seguir represe11ta a estrutu-
Bem-Vindo ao Visual Basic .NET 23

ra básica de um programa do Visual Basic .NET; digite-o na janela de seu Bloco de notas e, em
seguida, salve-o co1no Stepl. vb.
Public Class Stepl
Shared Sub Main()
End Sub
End Class

Ao tentar salvar seu código como Stepl. vb, você pode acabar com alguns re-
ALERTA sultados estranhos. Por causa da tendência do Bloco de notas de criar arquivos
de texto e dependendo das configurações de seu sistema com relação às ex-
tensões, pode terminar com um arquivo chamado stepl. vb. txt em seu disco
rígido. Para evitar isso, certifique-se de ter desmarcado a opção Ocultar exten-
sões de tipos de arquivo conhecidos (guia Modo de exibição em Opções de
pasta no menu Ferramentas do Windows Explorer).

A seguir, inicie urn prompt de co,nandodo progran,a Visual Studio .NETTools, como na Figura 1.17.

FIGURA 1.17
Selecionar o pro,npt de
~
~
-,..
~-·-•ools
t~f«Wl'dows:M'
~ _ ,omc. roo1s
co,nando do Visual !llll
lJ -t,wo,t E-c,
Studio .NET é a ,nelhor
nianeira de trabalhar !E oso1,_""'
'""""'"
QJ; .....
@ .....oso1,E><d
li:S ""°'"''...__
~-.-....
co111 a plataforrna .NET
a partir de 111110 linha
de con,ando. ~-u-
~,.,.
ISl ....oso1,_
liil ....oso1,W..d
s-....
·--
til P1ow01flc<....,,... o
--lloye,
Õl.dOOlc.Exprt"Ss

~-
{j OoenOll<• - - ,f!!:
o -"'" ~ "'<r00ft SQl Sctw1

~ ....oso1, SQl S.WO. • - " ' •


. .....Studo.lVC-- 1s .........-•.o
.!jtf!Kli!lp-

,
E essencial que você use essa opção para acessar a linha de comando, porque só através dela será
possível conseguir que o(s) caminho(s) correto(s) seja(rn) configurado(s) para executar ferra-
mentas .NET como o compilador do Visual Basic (vbc.exe). Se quiser e1npregar uma linl1a de
comando habitual, terá de adicionar a configuração do carninho apropriado (execute urna pes-
quisa ern vbc. exe para encontrar o diretório que precisa estar e,n seu ca1ninho) à sua rnáquina.
Isso apresentará um console de comando (corno rnostra a Figura 1.18). Desse local, navegue
para o diretório que contém seu arquivo Step J. vb. Agora você pode compilar seu progra1na,
24 Dia 1

criando um executável, 1nas adie um pouco mais adicionando uma etapa co1nplementar antes da
cotnpilação.

FIGURA 1.18
O 11so do co,npilador
de linha de co,nando é
Jeito por ,neio do
console (ou do prompt
do 1\!!S-DOS; co,110 é
ji·eqüente111ente
cha1nado).

No prompt de co1nando, digite vbc e pressione Enter. Você deve ver este resultado

RESULTADO Microsoft (R)Visual Basic.NET Compiler version 7.00.9254


for Microsoft (R).NET CLR version 1.00.2914.16
Copyright Microsoft Corp 2001 . All rights reserved.
Visual Basic Compiler Options

seguido por utna grande quantidade de informações de ajuda sobre o uso do cotnpilador do Visu-
al Basic. Se isso funcionar, você terá confirmado vários itens:
• Você realmente te1n o Visual Basic .NET instalado.
• Você possui as pennissões apropriadas para executar o compilador.
• O sistema pôde encontrar o arquivo vbc . exe.
Ao testar primeiro o vbc auto1natican1ente, você poderá eliminá-lo co1no fonte de qualquer pro-
ble1na que encontrar ao tentar co1npilar um progra1na efetivo. Continuando esse raciocínio, ago-
ra pode1nos co1npilar seu progra1na salvo, Stepl. vb, inserindo um comando do vbc, Stepl. vb
/t: exe e, e1n seguida, pressionando Enter. Se tudo der certo, deve aparecer este resultado:

Microsoft (R)Visual Basic.NET Compiler version 7.00.9254


for Microsoft (R).NET CLR version 1.00.2914.16
Copyright Microsoft Corp 2001. All rights reserved.

Isso significa que a co1npilação foi be1n-sucedida, e se você estivesse exa1ninando essa pasta
agora, por n1eio do Windows ou e1nitindo um comando DIR, veria que já há um novo arquivo
Stepl .exe. Processar esse executável (digitando Step I no prompt de co1nando e pressionando
Enter) não produzirá nenhun1 resultado visível, o que é de esperar porque o código de Stepl. vb,
na verdade, não te1n uma finalidade. O fato de que foi compilado e executado demonstra que ele
até aqui está correto.
Bem-Vi ndo ao Visua l Basic .NET

A chan1ada ao vbc pode aceitar u1na grande variedade de parâmetros opcionais (comandos com-
plementares adicionados à linha de cotnando, em geral separados por barras [/]), como você
pode ver na execução automática do vbc. No entanto, nesse caso, só foran1 usados dois. Com o
forneci1nento do non1e do arquivo-fonte, stepl. vb, foi infonnado ao vbc que arquivo compilar.
A segunda opção para / t (que significa 'destino' e ta1nbém pode ser digitado co1no /target)
pode ser un1 programa winexe, exe, uma biblioteca ou un1 módulo. Todas essas opções serão
abordadas depois, mas, por enquanto, só as duas pritueiras são particulannente relevantes; wi11e-
xe cria u1n aplicativo do Windows e exe, uma linha de co1nando ou aplicativo do console (que é
nosso objetivo). Por padrão, quando vbc for executado, ele usará /t :exe.

Vejamos a Exibição do Resultado


Agora, lembrando-se de seu objetivo fmal de retornar a versão do siste1na operacional, tente exi-
bir algu1n texto. Antes de conseguir um resultado efetivo em u1n progrruna do Visual Basic
.NET, é preciso infonnar ao compilador que partes, se houver algun1a, do .NET Framework se-
rão usadas. Nesse caso, será empregado apenas o root (raiz) ou o objeto do nível superior do Fra-
mework, System, portanto, adicione a linha Imports System ao início do arquivo de código.
Agora você pode se referir a esse objeto, System, e usar seus recursos e1n seu código. Un1 dos
me1nbros ou partes da classe System do Fra1nework é o objeto Censo l e. Esse objeto pennite que
os usuários leia1n e grave1n através da interface de linJ1a de comando. Nesse exemplo, empregue
a instrução Censo l e. Wri tel i ne pru·a retornar algu1n texto à janela do comando. Não importa que
texto será retornado, é apenas um teste de exibição de infor1nações. E1n seu código, foi utilizado
o texto É aqui que entrarão as informações sobre a versão do sistema operacional! paradeixar
claro que esse é só um espaço reservado. Salve esse novo arquivo de código alterado (que deve
se parecer com o código a seguir) co1no Step2. vb e, em seguida, volte para a janela do comando
a fim de cotnpilá-lo:
Imports System

Public Class Step2


Shared Sub Main()
System.Console. Writeline("É aqui que entrarão as informações sobre a
versão do sistema operacional!'')
End Sub
End Class

A instrução de co1npilação será quase a 1nes1na da etapa anterior, exceto por você especificar o
no1ne do novo arquivo-fonte, vbc Step2. vb /t: exe. A execução dessa instrução de co1npilação
produzirá un1 arquivo chamado Step2. exe, que poderá, em seguida, ser executado do prompt de
cotnando digitando-se Step2 e pressionando-se a tecla Enter. Se sua com pi lação funcionou e não
houve problemas no código, o resultado a seguir deve aparecer em resposta a seus comandos:
26 Dia 1

CôOIGO/ C: \TYVB \Cl>vbc step2.vb /t:exe


RESULTADO Mi crosoft (R)V i sual Basic.NET Compiler version 7.00.9254
for Microsoft (R).NET CLR version 1.00.2914.16
Copyright Microsoft Corp 2001 . All rights reserved .

C: \TYVB \Cl>step2
É aqui que entrarão as informações sobre a versão do sistema operaci ona 1 !

Adicionando a Funcionalidade das Informações sobre a Versão


Você sabe que o código está correto até este ponto (porque funcionou), portanto, ele fornece um
bom ponto de partida para a próxima etapa. O que precisamos fazer agora é obter as informações
reais sobre o sistema operacional e, em seguida, exibi-las no lugar do trecho genérico de texto.
Terernos de usar o .NET Frarnework nova,nente para conseguir essas infonnações, por ,neio de
outro recurso que ele fornece, o acesso aos dados sobre o sistema operacional atual, como o Win-
dows 2000. Essas infonnações são disponibilizadas pelo mesmo objeto Systeni, ,nas em vez de
usar Systeni.Console, empregare1nos System.Environment.OSVersion. Altere o código de
Step2.vb para que tenha a aparência do descrito abaixo e, então, salve o arquivo como Step3 . vb.
Imports System

Public Class Step3


Shared Sub Main()
System.Console.WriteLine(System. Environment.OSVersion.ToString())
End Sub
End Class

A compilação do código vbc step3. vb /t: exe não será diferente do que foi feito nos dois exem-
plos anteriores. Essa compilação produzirá um progra1na executável co1n o non1e s tep3. exe.
Executar esse programaexe, digitando Step3 Enter najanelaabe1ta da linha de co1nando, gerará
o resultado a seguir:
C:\T V \Cl step3
Microsoft Windows NT 5.0.2195.0

Observe que o resultado indica un1 co1nputador Windows 2000 (NT 5.0); outros resultados serão
gerados para co1nputadores diferentes. Agora você te1n um pequeno programa exe que retornará
a versão do sistema operacional, decerto ele será útil pelo menos para administradores de rede. O
aplicativo é cha1nado de s tep3. exe, mas seu nome pode ser facilmente alterado para algo mais
próxi1no de sua finalidade real.

Usando o Compilador de Linha de Comando


Nos exemplos anteriores, você usou u1n compilador de linha de comando para especificar dois
itens, o destino dele (/t :exe) e o arquivo-fonte a ser compilado (stepl. vb, por exemplo). O com-
pilador funcionou 1nuito be,n co,n essas duas opções, produzindo auto1naticamente progrrunas
Bem-Vi ndo ao Visual Basic .NET

executáveis com o mesmo no1ne do arquivo-fonte, mas há muitas opções co1nplementares dis-
poníveis co1no parte desse co1nando. Aqui estão alguns parâ1netros de linha de comando que po-
dem ser mais úteis quando co1neçannos a fazer testes com o Visual Basic .NET:
• /target:<winexe, exe, library,ou module>(podesercha1nadoco1no/t)especificaque
tipo de resultado deve ser criado pelo co1npilador. A opção wi nexe cria um aplicativo do
Windows. A opção exe, usada em nossos exemplos, gera um aplicativo do console ou de
linha de comando e é o padrão se nenhum. parâ1netro /t for e1npregado. As duas outras
opções, 1i brary e module, são util izadas na criação de resultados que não possa1n ser usa-
das direta1nente, 1nas que esteja1n destinadas a fazer parte de outro aplicativo. Você
aprenderá 1nais sobre todos esses tipos de saída nos dias posteriores.
• /out: <nomedoarqui vo> é usado para especificar o nome do arquivo criado . .E1n seus
exen1plos, você o 01n itiu, fazendo cotn que vbc empregasse o nome de seu arquivo-fonte
(Stepl . vb) para gerar o arquivo de saída (Stepl. exe, por exemplo).
• /he l p (ou/?) é equivalente a executar o vbc sem opções: em qualquer das duas formas, o
resultado será uma listage1n detalhada de todos os parâtnetros disponíveis.
• /verbose faz o coinpilador produzir resultados 1nais detalhados durante a compilação e
pode ajudar a solucionar problemas.
• /reference:<nomedoarquivo> (abreviando-se te1nos /r : <nomedoarquivo>) é usado para
inforrnar ao cornpilador que seu código requer alguns arquivos cornple1nentares alé1n do
que está incluído como padrão. Por exe1nplo, se você quisesse trabalhar com as partes de
Sys tem . Web do .NET Fran1ework, precisaria adicionar un1a linha lmports System. Web no
início de seu código e, em seguida, especificar /r: syst em. web. dl 1 quando o con1pilasse.

Resumo
Nesta lição abordamos u1n pouco do histórico da programação, o Visual Basic e a plataforma
.NET antes de criar um programa pequeno. Agora, você está pronto para passar ao aprendizado
da Jinguagein propriamente dita e escrever progran1as 1nais co1npJexos. O Visual Basic é uma
das linguagens de progra1nação 1nais populares do mundo, ejá cobri1nos u1n dia na direção que
conduz ao seu domínio.

P&R
P Por que o Visual Basic .NET é tão diferente das versões anteriores do Visual Basic?
R O Visual Basic tem evoluído co1n o ternpo. Cada versão te1n sido rnuito semelhante à an-
terior, mas, en1 certos pontos, uma revisão 1naior co1no a da plataforma .NET era neces-
sária para assegurar que a linguagem acompanhasse outras alterações da indústria, co1no
a Internet e a computação distribuída.
P Ouvi falar sobre outra linguagem .NET, a C#. Devo aprendê-la em vez do Visual
Basic .Net ou estudar as duas?
28 Dia 1

R AC# é u1na ótima linguagem nova, uma 1naneira 1nais simples e fácil de usar a C++, mas
não, você não tem de aprendê-la. Todas as linguagens .NET são iguais em termos de suas
capacidades; se você
,
puder criar um certo tipo de aplicativo em C#, poderá fazê-lo no Vi-
suai Basic .NET. E possível que as pessoas achem que muitos exe1nplos da M.icrosoft
aparecerão em C#, apenas porque é uma linguagem que tanto os progra1nadores do Visu-
al Basic quanto da C++ achan1 relativa1nente fácil de ler.

Workshop
O Workshop foi planejado para ajudá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e con1eçar a pensar em como colocar seu conheci1nento em prática. As respostas do teste estão
.no Apêndice A, "Respostas dos Testes/Exercícios".

Teste
1. Qual produto da Microsoft foi o predecessor do Visual Basic?
2. Por que todas as linguagens .NET (Visual Basic, C# e outras) co1nparti lha1n certos recur-
sos co1nuns (o .NET Fra1nework, métodos de criação e uso de objetos e 1nais)?
3. Co1no se denomina o processo de converter o cód igo-fonte (seus programas) e1n código
nativo de 1náquina (co1no um arquivo exe)?
4. Considere o código a seguir:
Public Class MyClass
Shared Sub Main()
End Sub
End Cl ass
Se esse código fosse salvo e,n um arquivo cha,nado MySourceCode . vb e, em seguida, fosse exe-
cutado o comando vbc /t: exe MySourceCode. vb, que arquivo seria criado?

Exercícios
1. Nos exe,nplos desta lição, você não especificou un1 no1ne para o arquivo de resultado
quando compilou, o que fez co1n que o compilador usasse o no1ne do arquivo-fonte co1no
padrão. Reco1npi le s tep3. vb, definindo um nome para o arquivo de resultado igual a
WhatOS. exe.
2. Para obter infonnações sobre a versão, você e1npregou o objeto System. Envi ronment,
que possui várias outras propriedades úteis. Use a documentação de ajuda que está insta-
lada no Visual Basic (veja a seção "Preparando-se para Codificar" ) para saber o que
1nais está disponível e, em seguida, crie outro programa para exibir u1na ou mais dessas
propriedades con1plementares.
SEMANA 1

DIA

Trabalhando com o Visual Basic


.NET
No Dia 1, "Bem-Vindo ao Visual Basic .NET", você aprendeu algu1nas infonnações gerais so-
bre progratnação, Visual Basice plataforma .NET, que lhe forneceran1 o conhecimento necessá-
rio para começar a desenvolver aplicativos. Nesta lição criaremos u1n aplicativo Windows real
por 1neio do Visual Basic e, no processo, abordaremos os tópicos a seguir:
• O IDE do Visual Studio
• Soluções, projetos e arquivos
• Criação e execução de u1n exemplo de projeto no Windows
Começarei co1n uma visão geral do IDE do Visual Studio (VS). Os IDEs fora1n abordados na li-
ção anterior (Dia 1), mas incluirei un1a revisão rápida sobre seu significado e finalidade.

O IDE do Visual Studio


A finalidade do IDE (lntegrated Develop1nent Environ1nent, ou Ambiente Integrado de Desen-
volvitnento) é ser u1.n a1nbiente únjco de trabalho para os desenvolvedores. Etn geral, o códi-
go-fonte é co1nposto apenas de texto e poderia ser inserido e editado em qualquer editor de texto
(o Bloco de notas, por exemplo), e compiladores pode1n ser usados na linha de co1nando sem
1nuito problema, portanto, tecnicamente o IDE é desnecessário. Apesar disso, há poucos progra-
madores que concordariam em trabalhar com u1na linguagein que não possuísse algu1n tipo de
130 Dia 2

IDE. Mesmo as tarefas si1nples de edição e compilação de seu código serão muito simplificadas
pelo IDE do Visual Studio que fornece ,nuitas possibilidades complementares que apenas não
existiriam sem ele.

Iniciando
Antes que você possa usar o IDE do Visual Studio, ele deve ser instalado en1 sua 1náquina. O
processo usado para fazer isso fo i detalhado na lição de onte,n, portanto, leia esta seção se preci-
sar concluir a instai.ação antes de continuar.

Configurações do Perfil
O primeiro ite1n que você verá quando injciar o Visual Studio .NET será uma interface parecida
co,n u1na página da Web (que foi chamada de Visual Studio Home Page) solicitando a confinna-
ção das configurações de seu perfil. O conceito de perfi l é novo nesta versão do Visual Studio,
tuna variação da idéia de preferências do usuário que provê a capacidade de configurar n1uitas
opções diferentes em um único perfil. As opções básicas fornecidas foram projetadas para facili-
tar sua transição para este ambiente dependendo de sua experiência particular. Essa disponibili-
dade de padrões me levou a escolher rapidamente as configurações mostradas na Figura 2.1. No
entanto, depois de algu1nas horas de uso, as alterei para algo um pouco diferente de qualquer dos
perfis-padrão. É provável que você faça o mesmo.
Por enquanto, selecione o perfil Visual Basic Developer, e depois você poderá voltar à caixa de
diálogo para alterar essas configurações se desejar. Dê um clique em Get Started para sair da pá-
gina de configurações de perfil. O que apareceu agora é considerada a área principal de trabalho
do IDE do Visual Studio, uma localização geral que contém conteúdo de vários tipos, como o có-
digo editado ou as páginas da Web projetadas. Ela tambéin inclui u1n navegador da Web interno,
que é aberto por padrão; ele é usado para 1nostrar u1na interface para o Visual Studio co1n jeito de
Web.
Na I-Iome Page (veja a Figura 2.2), você encontrará várias opções úteis. A prin1eira, Get Started,
é a página que será ,nostrada sempre que o Visual Studio for aberto. Projetada como un1a prepa-
ração inicial para seu trabal.ho, essa página fornece tanto u1na lista dos projetos recentemente
abertos quanto u1n link para a criação de um novo, permitindo que se dê prosseguin1ento co1n um
sin1ples clique em algum local dela. Por hora, selecionare1nos uma das opções de navegação que
se encontra1n no lado esquerdo da página
T rabalhando com o Visual Basic .NET 31

FIGURA 2 .1
·•. Mluosoít Dl!Velo,pment E:nviNJnmenl ( deslc)n] - .,tart Paqe

fj, (<lt ~ !od, '!!:i'd>w !!oi>


1

O JDE do Visual Studio I àil . . r$ lil ? 1J i\ ,, : .... Ç' • C+_l ••


.NET pode ser 1.. .. O @J S 'lll t!l lài
• • •
__ ,
Rr;J EI

· liõ! ii' ~ ·:
. , .. t ' J!, .

personalizado para
tornar ,nais fácil a . .... r

transição por ,neio de


outras ferra111entas de Ve.,ify ttt.t tho folowmo settinos .,ro pcrsofWlud for- you;

desenvolvin1ento,
eoH,r -----..... ~·..iel C e,elo"e r
incluindo a versão
tt•Jbo.wd Sehem•: (v,su~I 8.os•c6 .:.)
anterior do Visual
l!l•ndc>w u,out: lvisu,,1 Stucho Ocfoult ::J
Basic. tielP r.tter-: !{no tltl.e r) ::::::J

Show Help: <=' 1ntem1'1 Help (' [rtemol Ht:lp


At Stllrtup: ( Sh ow St-,rt Poo c

..:1

FIGURA 2.2
/1 página inicial
fornecida pelo Visual
''· Mlcr°"oll Devdopment rnvmmment [d~lgn)- Stm-t Poge
!jlo [dt l')cw !col! l!ó'<low !!<O
ISJ · "'· iã: liil OI ~ 6 1,, : r.. ç-.r;.J •
1 1 -- • W

1.... O @J S 'Q ID !à\ i ""'"""''"""


~ \
__ ,
1!10 Ei

Studio disponibiliza
urna visualização ..•..
. ..
..
~

ji,ncional dos projetos


que você abriu
recente111ente, alé111 do ,WindowsApplh:6\iOn9 Yestcird..,,

acesso a várias fontes filer 6/14/2001


Cruddy-Art,,loExom;plc 9/10/2001
de in_for,nação.
Opt'n PrOJt'd I Nt:11111 ProJ1:1cl

Reriort a Visu al Studio,ner issue

..:1

As opções l.aterais restantes apresentam:


• Detalhes dos novos recursos do VisuaJ Studio .NET. What's New (O Que 1-lá de Novo)
está vinculada a vários recursos on-line con10 newsgroups (Online Co1nmunity)
• Uma página de notícias ao vivo sobre o Visual Studio e outros tópicos relacionados a de-
senvolvedores (Headlines, veja a Figura 2.3)
• Utn link direto para pesquisas na Web (Search Online)
32 Dia 2

• Um link de retomo à página de seleção de perfis que é apresentada por padrão na pri1neira
execução do IDE (My Profile)
Todos esses recursos estão disponíveis para o desenvolvedor do Visual Studio, o que torna essa
página inicial un1 bo1n ponto de partida para muitas pessoas. No entanto, se você quiser adicio-
nar algo a essas opções ou substituir por completo o conjunto de páginas, a fonte integral da pá-
gina padrão está disponível em \Program Files \Microsoft Visual Studi o. NET\HTML. Porém, aí
vai un1 aviso - as páginas-padrão não são simples, e seria fácil danificá-las se1n que possan1 ser
reparadas. Faça uma cópia do diretório como backup antes de começar a personalizar!

· •. MlcrMGfl Devdopment lnvtrol'lm~nt [de...l,gn] - StMt P4Qe 1!10E!


FIGURA 2.3 ti> (dt y.,.. Iools ~ !!<lo
ln/armações relevantes l lSJ • l1., • ~ lõl O
'
J • .,, e. J ,, :
'
r, •&' • 1:. J •
. ~
'
para progrcunadores do o
1.. .. [l;J 6,1 :à Ci) [àj 1""'dd, út.t.,.
Visual Basic ..1VET
~· ,;·

pode,11 com fi·eqiiência An ppdate for Visuol Stud,o,NET ,S .svad111blo. Cltck ho;e·to do,..,nJood.

ser encontradas no site ViwoJ DoltC ond Re lote d ..

da Web
msdn.Microsoft. com,
Oot, Op"rotlOf'ls on 1-liora,C,,.,uJ Row O.ot•
que é realçado &u ld• 0 1dnW.'"'<1 A l11e~bOru: 'l'<fh ~j f f

auton1atican1ente en1 Di1tiin9 Into Data Actf!ss: 06tab.ue-


Noth.n' but ASP.l,ETI A$P.r-lETCo,chinQ
Oôta Containers

seções da página DHn,&L Oude: AMorino and- lntrus,.,.e Sites


Wc.b Tum Tol'-:.n9: w-,d,no for Answcrs
inicial do Visual Ouwerrush Online U11ng lhe >Cf'IL ruwres of S(!L s~rv"r 2000
UslnQ f.olJerosok. ProJoC( <:0-ntr•I <:ontrols Wlth Anoth,,. 04t• Soure.
Studio. Mk o.-. Gtll Wee-ld,'1 Ab.bndonrntAt end P.!ltel'niw
Worbn,o w1th C,r: Th(I Woll·Tomocrod hGeC.\101'1

A Janela Principal do IDE do Visual Studio


Mes1no sendo tão útil, essa página inicial é apenas u1na das várias janelas disponíveis como parte
do Visual Studio, e iremos percorrer a n1aioria delas nesta lição. Com o perfil Visual Basic Deve-
loper selecionado, você já terá diversas janelas visíveis: o navegador da Web interno discutido
anterior1nente, o Sol.ution Explorer, Properties e Toolbox no lado esquerdo. As outras janelas,
que abordare1nos nesta lição, 1nas que não se torna1n visíveis no perfil atual por padrão, são:
• Object Bro\.vser
• Con1mand/ln11nediate
• Task List
• Class View
• Server Explorer
Há outras janelas que abordarei quando se tornare1n i1npo1tantes, 1nais adiante no livro.
Trabalhando com o Visual Basic .NET 33

Recursos Comuns das Janelas


Todos os recursos destas janelas, incluindo o conceito de 1núltiplas janelas, foratn desenvolvidos
para proporcionar uma utilização mais eficiente do espaço. Em qualquer IDE, e principalmente
no Visual Studio .NET, a quantidade de opções e ferra,nentas disponíveis é quase infinita, ,nas a
área de seu monitor não é. U1na solução para esse problema é utilizar um 1norlitor de 21 polega-
das (ou rnaior!). Por algu,na razão desconhecida, essa ,nedida ainda não foi adotada, portanto,
outros 1nétodos foram desenvolvidos. Um deles é dividir as opções disponíveis em janelas dife-
rentes, que é a abordagem usada pelo Visual Studio .NET. Agora, o objetivo é tornar o posicio-
namento dessas janelas fácil e flexível o suficiente para que os desenvolvedores crie,n seu
arnbiente ideal de trabalho. Elas são cha,nadas individualmente de janelas cle.ferra,nentas. To-
dos os mernbros de uma janela de ferramentas comparti lhain alguns recursos co1nuns, como a
capacidade de estar encaixados/desencaixados, ocultos, associados etn grupos de guias de jane-
las e assim por diante. Todos eles podem ser redhnensionados de várias forn1as.

Encaixando/ Desencaixando
No perfi l Visual Basic Developer, tanto o Solution Explorer quanto Prope1ties ficam alinhados
no lado direito da tela do Visual Studio, e Toolbox fica no lado esquerdo (veja a Figura 2.4). O
posiciona,nento de u1najanela rente à outra área é descrito con10 encaixar essa janela. Quando
está encaixada, a janela é bloqueada por essa área em u,n ou dois lados (dois lados, se estiver en-
caixada em um canto). Todas as janelas de ferramentas do Visual Studio .NET pode1n ser encai-
xadas e não há lirnite para as margens nas quais é possível alinhá-las.
·~. Wridowt.Appl1c ól:wn8 - Milt:""'on Vh.u.aJ Ba-ucMT {dewgn) - fonnl .vb l!lliJ EJ
2.4
FIGURA @, [dt l(lo• &oi<« ~ ~ tod, ~ tt,lp
. . '
Quando o Visual Studio l:.il · UJ ·câ:lilO
'
Ji~e.1.-..: . :. ~· r.+I , ·....., . ~
. Qlli'*
í lfi \. ~ At I• ! '1-; :: ,, U u' J'. ,
':
.NET é configurado -:---:--:-"l!""~~-
....,,,.....
~*·~~-='=a;s=~~
[SCWlnE,g>io<e<· ~ · · · ~ X
~ . locb:tx
~-
co111 o pe1fil de ~dRr,q f l • I f'\:r,om'1 (Windowi.Ac,,plic<1U.;J lll\ (Ocdo,0Uoni.)
,i:-1=======;:::!=! r- E Pub 11c- e 1us f'ol"tl>t
3 .íB :e tfl fã> ;::-
·- S o l J t \ : l n ~ ~(1 tt
desenvolvedor do i lit' Ptt(o, •• • ÍI lnhertt!I SV8te?D, V1ndiOOS . f'Or1113, f 0'0:11 .!. 6 ~ WindowsApplic•UonB
Visual Basic, ele : ~ Reo1on .. lhndov.s r orm Des1~r qenecat.ed
• 8tl A.tfffft'Ut
~ .........,,,,......
fiJ Fermt.~
organiza suas janelas
PUb U e Sw> Nevo
de .forrna aproxi111ada Y.ve~c .Nev( )

à do IDE do Visual •
Basic 6.0.
'Tbu c;oll u rcq\lU:4:d by the 1hM , ~· ~ - - -
I nitiali:eOom~onent () .
..
'Add ouy 1n1t1aJt:etlon atter thc • X

tnd Sl&b

rorm overtides d1~pos~ to cieon up tt


Prot,ect.ed Ovec le>ael:I ovei:-rtde!I SUl) D1!1-:
tt dí~po~1no Thcn
u Not (c:omponents l!l ?lot:hl. no)
componcnt.:, , D13p,o:te ()
Et'lcl l !
tr.d. 1t

l '): ! : - - •-v_,ej__ c . Di:u,o:ic: Cd1.:,~o:i : na:l
•- - - ---~·:.!.J.l::: •
ln4 OIS

Para rnover uma janela encaixada para outra área da tela, deve-se dar u1n clique e rnanter pressio-
nado o botão do ,nouse na barra de título da janela de ferramentas e, e,n seguida, arrastá-la para a
34 Dia 2

nova posição. Enquanto ela estiver sendo arrastada, um contorno aparecerá na tela para 1nostrar
onde a janela seria posicionada se você soltasse o botão do mo use. Para encaixar a janela e1n ou-
tro lado do IDE, apenas arraste-a para u1na borda deJe, 1nantendo o botão do n1ouse pressionado
e soltando-o quando o contorno da janela 1nostrar o resultado desejado. No trajeto, pode-se ter a
impressão de que o contorno não foi encaixado em nenhu1na parte do IDE (veja a Figura 2.5).
·~. WW1dow,,,App.!1c õttonO · Muro,ofl V11ou6f O,n1,1tJl<í 1 ( dM.lor,) · \tllft Png" f!IQ E3
FIGURA 2.5 ,.a. <i!t l"" f)'o)ect ~ QebJ9 Iocls Jll.hdow t!<I>
- ~' •
O contorno de zuna I~ · W • e.;;: liJ Gil I x. ~ P..l •0 ; e,· ~ · 14] ,'- · r,;'
. ' .
1.. .. o @! ~ . 12 ru ti';\
'
1-·"'·'""
· 1Q r.1i' *
.. t, i.&: .
':
janela que está sendo
arrastada se altera
~

para in<iicar o que


.
ocorreria se voce
. An ui,do\O for visu.S Swd10.uET ,S .,...~1.oblo, Cltck ho;t/w d
. . .
parasse de arrastá-la Verify U..,t Ú'IO folowl
you:
en, u,11 lugar espec{fico. .•
l(wstom) ..:.J
tte1bHtd S.ch~moe: Visual lus1e 6 ..:J
!!•ndo.,.. l..oyout~ V1suol &011-c 6 _:J

visual &asie and Related ..:.J

.Show Help: ,:, !~mel Hei;> r f ttemol H~lp

Al Stairtup1 Show Sta,t Pooe • 1

Se você deixasse a janela de ferramentas nesse ponto, ela ficaria' desencaixada', o que também é
conhecido como janelaflutuante (veja a figura 2.6), posição na qual ela não estaria 1uais fixada a
nenhuma borda do IDE.

• tl X
FIGURA 2.6 t<o ,~ l(1e,< l;rOJect ~ o,obu9 Oi'> I°"' 'iUvltiw ~

Se você tiver bastante l~ · lli . e.;;: "~ 1 j, ~ e-1,, ~ ~·. J;:. C.J •:- rli,
1 . l ,i "'I ,-; 41) "' 1... tl ~L &.l ,,,.. i;o: !':' ~ -~ }: ê: o: 1!§1 ~ 'l'4o 'ii .
espaço na tela, poderá Forml.vb [De1i9n]
deixar suas janelas D ' D • D
_!'.rorm1 Solutlon hcplort:r - Wlndow\.A llrnllonO ti
desencaixadas. .... . ... .. ... .. .. '' ..
....
.
..

,.., _
~ F C IUM

A ......
·~~~==·=--~-,---;:::=============~
((!) ,.._,
-~-~•
wtb 5fS XSK b t\»fNed COO:
ô .......... S<+.tm El!L'bã
,!,J M«> ~
)'W!f l},sç «:d )lWI e• rxemu
~ Tex.18ox ~ . í:'19!:m+ MdfJN
:ili- A$Sttâ!tl Wtb S::o+:r:1 lo Mm,a,:,J Co6:
lHQ;:1 tht Pclun:r.
~ Chod8ox
1.i~......,..
~ ..
9'bo!!dlU)O
_J 'ft2rl sm· $rds Iro"=,
'!1:Bf:;l 2'Pg $:xrP:1
li®t!éft:·ti~ Toobox I 1 • ~
1
Trabalhando com o Visual Basic .NET 35

Quando as janelas estivere1n desencaixadas, você poderá reencaixá-las seguindo o mesmo pro-
cedimento que acabou de usar.

Pode ser complicado levar uma janela encaixada de volta ao local exato do
NOTA qual a moveu, portanto, aí vai uma pequena dica: em vez de arrastar a janela
para encaixar e desencaixá-la, dê u m clique duplo na barra de título. Isso de-
sencaixará a janela de ferramentas que estiver encaixada ou levará uma janela
flutuante de volta a seu local original.

Ocultação
Encaixadas ou não, as janelas ainda ocupa1n espaço e,n sua tela, ,nas é possível ocultar ou fechar
janelas específicas que você não queira que permaneçam visíveis. Toda janela de ferra1nentas
possui um botão X (veja a Figura 2.7), sen1elhante ao ícone comum de fechan1ento de outras ja-
nelas. Dar um cJique nesse botão fechará a janela de ferran1entas, removendo-a da tela.

FIGURA 2.7 . e,o;,ct


feio tdt Y"" ' !.'Ad Q<b.'9 ot!o . .: -··roct,Ç· -ql ....!lei>..... .
As janelas de l íiil · 'll:l ·~lil~ i 1,1ti e.1·0 . fli,

ferramentas pocle111 ser j I p_. ,e. ,tl Õ <I) l


t.. ,o, $,< +r ·iJ I OC• ~ '};' ~ 1l }: ·~; r,: ~ ~ 'l:J, 'Pl, •

fechadas por nieio do D '· D


a
!I
pequeno botão X, que .. ' .' f
as ocultará da tela até : . ~ · ·111
· 111
· 111111111
. ·: : 1111111,u..e.., ...... '

Clo<e
' .
. necessar,as "
e
• S O W l n -00- (1 ,.0Je<l)
que se;a,n JD~lboic 9 :lil
1
VMdo,,sApp11c•Uon8
@) ~ ferences
Dota
novan1enre. _..,,,,,
~
t!) AsseiillyWo8b
J~ tillUIM
[ lt -
A l4b<I
A""..-
,;,l ......
i;;i , - .
it""*"'<nu
p Che68o>< •
(li) 11$
Qooo«d Rho 1~1 W@ Jro'.i;N"" ~F:W"}Ccd::
G<rc,4' J ~Eml.mr
Ufk!l Sõ\JIM fYml e,
Yw:I bk ::iM 'lorJ e, Prr>::<!t
......,..,., eton,. ,ed FJ!,s
AcCM8:n Wtb scrwa ln M!QIMsf Cod!
l/!Ql tt,o lldllow
!= = = = = = = = = = = = = 0• 5an'liples

Para trazer a janela de volta, você precisará usar uma opção do menu. Por exemplo, se der u1n cli-
que no botão X do Solution Explorer, esse desaparecerá da tela. Para trazê-lo de volta, é preciso
selecionar Solution Explorer no n1enu View (ou pressionar Ct rl +R). Não é tão difícil, principal-
1nente para u1najanela que não é utilizada com freqüência, n1as e aquelas que pode1n não estar
sendo usadas agora, porém, e,n geral, o são? O Visual Studio .NET fornece tuna ,naneira de re-
cuperar o espaço da tela utilizado por essas janelas, tornando-as ainda assim fácil de acessar - o
recurso Auto-Hide. Toda janela de ferra1nentas encaixada possui u1n ícone ern sua barra de título
que se parece com u1n pequeno pino (veja a Figura 2.8).
36 Dia 2

·•. WindowsApphcilÜOnU - '1k.roson YlMJal Bask:. <\f:. f { desql) - f o,m l .vb (Ocstgn] "g EJ
FIGURA 2 .8 fio [dt ~ ~...
1
~ - ~
• •.
!oob ~ •!;oi>
Todas as janelas de li&l · ttl · ~ ld? l 1>~ e. ·':"·· .JJ ·q_t , o.ouo • ~.
.f'erra,nentas possue,n l l'.t . 1 ,!, •:1 ;, <li '""' 1~ ti· iO ~ I * ~ ~ ~ I ~: ~; CI: ~ f"1 Ili ' .
u,n pequeno pino que
per111ite que seja,n
D tJ O

.. . .' .' .' .' .' ' . ..• . .• li:180lC1 , __.,,._(l p,oJ,ct)
<
. ........ .. 8· j!
s
w--.............
~..,........ í
confinadas e112 urna !!) .. _,"º·"'
posição onde .fican1 foollH»C ti Eãi#A61

abertas.
,,_
"""
O)rrpontru
WR:lows Forms

• •
1. ,!

~-
A ld>d
âlrilU

(;; rcxt8o.x D •r*Help Ci


~ Nt,rt,~r,J
f.' Ch«tSOx

Cl@é'.d"'!i
il21 .....
W,:b ~'1{!:1 lf\ M.Yb"'JttJ ('gde;

'°"""wnm:Ei ~ 1oeciox l
t:HíP.1
s+Jk'o Em«u
wm SoiJtbn Qxbcr
YlP>" ~m m 'm!nl ct t:wxt,
~ . OOJNJJ+ ;)Q!lffN.
fWflt9 Wdt S,,W:, kJ C:J:#»:l':d Cô

1,aR-------------,lfi'ts.n. . . "*» Sb: Pcb.m::

Esse é um botão de dois estados que controla se a janela deve ou não ser auto1natica1nente oculta
quando não estiver em uso. Por padrão, a janela do Server Explorer é configurada para e,npregar
esse recurso e, portanto, aparece apenas co,no u,na guia ou botão cinza no lado esquerdo do IDE.
Passar o ponteiro do mouse por cima dessa guia fará com que o Server .Explorer se torne visível
por co,npleto, deslizando para a tela. Qualquer janela de ferran1entas con1 a opção Auto-Hide
ativada será minimizada automaticamente em u1na guia na lateral do IDE onde estiver encaixa-
da. A janela oculta será trazida à tela sempre que o usuário passar o ,nouse sobre essa guia, o que
significa que só ocupará espaço quando for necessária. Esse recurso, junto da opção do ,nenu
Window, Auto J-lide Ali, é utilizado por 1nitn para configurar o Visual Studio co1n a aparência
que desejo (veja a Figura 2.9). Isso deixa o máxi,no de espaço para a janela principal, onde o có-
digo aparecerá quando você tiver aberto u,n trabalho. U1na interface extre,na como essa pode ser
desnecessária quando se trabalha em um ,nonitor grande, ,nas, cotno usuário de laptop, a acho
perfeita.

Guias

Outro recurso para econo1n izar espaço: as janelas de ferramentas múltiplas podem ser agrupadas
e,n uma única área da tela onde auto1natica1nente se transfonnarão em guias individuais de uma
janela com várias guias (veja a Figura 2. l O). No perfil Visual Basic Developer, diversas janelas
já fora,n agrupadas (o Solution Explorer compartilha o espaço con1 a janela Class View, e Pro-
perties e Dynarnic Hel.p foram configuradas de 1naneira semelhante), tnas qualquer co1nbinação
de janelas de ferramentas é possível.
Trabalhando com o Visual Basic .NET 37

FIGURA 2 .9
Você pode usar
Auto-ffide para
111axin1izar sua área
,i o.t• . : -
central de trabalho, 6- !ili !li
""'" IC'sf R:i:S!q')!t
!!! d •kma)"ty
que é onde editará rnsContrctttrt F\Bl2rn

tanto códigos quanto


objetos visuais. ~ ~ 1.11 Ooo.mtnts
EJ l focfm l ,'Ã>(~]
2,~ t P.,oc - 0 -><tt>

......... -~-"....
-2 Fotml ,'ti>

.. ~--__!'!!.~-~ ..·:....--rr::"7
- ~ ·- ---'L~
. ..
.. ...
:: :: ~:··:: : :: ~::::::::::······· IB
...
WlndowsAl)plkatlooS

·-·· -· ··-· ·· -········· ······- ·


• •

••• Wtnd~App!1c.otlonB - Mu:rcnon Vku.ol B-Mk.NET [dnigr,J · fom,1,vb [Ottlgn] l!!lr;J'Ei


FIGURA 2 .10
As guias perniitirão
ljiO td< \jow &o!Oct t\.6l l!tbJo
l~ · ID· ~ 'ii!i' I• -ll- 6 f.., ~·· -~ · r+l
O,l!o ""'""' 1oc1, ~

1~ li' ·~ .1 !'.! <11 lol I·•· ~D i.+.i 1.,. !<': '!-"~ l'. t: ·~: l>:
<= t!O~
rll,
~ Ili 'li "- .
que você tenha rnuitas PIOfJ$1* 9 x1 ". Fonnl ,vb [Design) Foimt.-.b 1 1 I' X
janelas diferentes de ro«nl $Yltem,wn:bws,Founs.krm ' D

férra,nentas abertas . . . . ..
' '
• ••••••••• :::::: •• ::: l.J;!Boocl
enquanto ocu1~an1 o
r11es1110 espaço precioso ...
Ac<f'OdMton
da tela.
,..,..........
C,cn:el'Uton

._
loc.attdtk
W~Ciilyle
Cortio&>x
Hctb,ttcn

IJM$C~dr,e,

.....,
'""
'""'
~ (1..,)

'""' JJ::::: ..
111: : : : : : : : j 11 : : : :
. . . .....
........
...
. .' . . ...............
.. . . . . . .. . ..
'
:n~i: :1;
.
.... .... .

--
Ms:d,i:f8ox
'""
("""") - ·· -· . ~· · ··· ··--· ···· - · · · - -··
'""
"......

Para adicionar u1na janela a utn grupo de guias ou criar utna janela co1n guias, arraste u,najanela
de ferra1nentas (dando u1n clique em seu título e arrastando) para outra, soltando o botão do
1nouse quando o contorno se alterar para 1nostrar u1na janela com guias, exibindo a extensão de
u.r.na pequena guia na pa11e inferior dele. Consegue-se a remoção de u1najaoela de 1naneira pare-
cida. Apenas arraste u1na das guias para fora do grupo até que o contorno perca o fonnato de guia
e, em seguida, arraste-a para o novo local desejado e solte.
138 Dia 2

Redimensionando

Qualquer janela de ferramentas pode ser redimensionada, mas, se estiver encaixada, só o poderá
ser ao longo de suas bordas desencaixadas. Para redimensionar umajanela, mova o ponteiro do
1nouse sobre a n1argem dela, até que ele se transfor1ne en1 utn indicador de reditnensionamento,
mostrando a direção permitida para a alteração. Quando o ponteiro indicar que você está co1n o
1nouse na posição certa, dê um clique e arraste para estender ou retrair a borda da janela até o ta-
tnanho desejado. Observe que o reditnensionamento entre duas janelas encaixadas estará na ver-
dade alterando ambas porque urna deve encolher para pennitir que a outra se expanda.

Toolbox
U1na das janelas mais usadas, a Toolbox (caixa de ferran,entas) fornece u1na listage1n de vários
trechos de texto, elementos de interface com o usuário e outros itens que são disponibil izados
para serem adicionados aos projetos. A seleção de itens 1nostrados dependerá do que estiver sen-
do editado no rnornento na janela principal do IDE. Por exetnplo, se nada ou apenas o navegador
da Web for selecionado na janela principal, então, o único item disponível na Toolbox será o íco-
ne Pointer. Esse ícone, que está sempre presente, é fornecido como u1na rnaneira de desmarcar
qualquer outro item da janela Toolbox. Se você estiver editando algo, corno o código HTML da
página inicial do Visual Studio (dê urn clique com o botão direito do mouse no navegador da
Web e selecione Exibir código fonte), guias cotnplementares serão adicionadas à janela Tool-
box. No caso da edição do código, uma guia HTML foi adicionada (veja a Figura 2.11) contendo
vários itens que representa1n diferentes tags HTML.

·•. ww,do.nApplic.>ttonO - Ml<ro,on Vhual U.ttk.NCT (det1<1fl) - tfl'."itroo~1· 1!10 E!


FIGURA 2.11 f.iie t4 'íiew ~ ~ Qdiu9 ' ~ ! o<* ~nd:M ~

1\'a edição de código lliil · \n ·~ liil~ 1' e l· 1 '. ,.ç.r..1 ,:- -~


1!;a 8 •·< Fa: .. ,ii, 1 • •••• ~ !:&. •
H.T.lvJL, todos os ˼ , , . ,

e/e111entos de Ui típicos
da linguage111 _fica111 .' <html>
disponíveis na Toolbox. ..J IWOn <hf'ad.>
l.J R.t:Mt 81.tton <, í t le-></t. u ; l e>
!.J ~ & . tton <meto. c.!lltl!:• "'GENC:R.\TOR" cont.enr..• "n
<lhead.>
r.i , ... ""4
(li Te«t Aleo
Á
"'(
- - _J <body>
</body)
r;n Hefie)J </ html>

p Ch«t.bo~

·-
r. Rado fUton

º
E]_.._ .....
T,t;c

el Crid..._......
gJ ,,,,..,.
l!li lklbccc
lill ""'°"""'
........, ~·.__~~~~~~~~-''·~
1=
9fbo!'==d~.....
~ Jodbc;«

La Desl,i, 1a Hlfl\.
--- ~
Trabalhando com o Visual Basic .NET 39

Qualquer ite1n, con1 exceção do especial, Pointer, pode ser usado de uma das duas 1naneiras:
• Dê u1n clique e arraste o iten1 para a janela de edição (soltando quando você tiver movido
o mouse para o local desejado).
• Dê u,n clique duplo no ite,n, o que fará co,n que seja adicionado à janela de edição no
ponto de inserção selecionado (qualquer que seja o local onde o cursor estiver posiciona-
do na janela de edição quando houver o clique duplo sobre ele).
Esses dois métodos de uso dos itens estão disponíveis para qualquer tipo de documento que esti-
ver sendo editado, mas, se uma interface gráfica com o usuário (algu1n documento visual se,n
texto co1no um forn1ulário Windows) for o docu,nento atual, então, as duas opções anteriores se
co,nportarão de maneira um pouco diferente. Utna terceira opção também está disponível:
• Dar um cl ique e arrastar o ite,n para o docu,nento visual funciona da n1es1na forma que
para um texto, mas, em vez de aparecer um ponto de inserção do cursor, será mostrado um
contorno real do item quando você 1nover o ,nouse sobre o docu1nento.
• Dar um clique duplo também funciona, mas, já que um documento visual nen1 se,npre
possui u,n ponto de inserção selecionado naquele momento, o novo ite,n e,n geral é ape-
nas criado no centro do documento.
• Uma terceira opção, que não está disponível para edição de texto, é selecionar o item dando
u,n clique nele, realçá~lo na Toolbox e, e,n seguida, dar um clique e arrastá-lo para o docu-
1nento visual. lsso esboçará o ta1nanho e o local no qual você deseja que haja a inserção no
docutnento, e o novo item será criado de acordo co,n o definido (veja a Figura 2.12).

'~. w -.ndoW1.App.llcdllonB - "'1i(,011on Vh.u.n.l Bat.kMT (d-ic;11} • f onnl.vb (01"1.lgnJ- 1!!10 Ei


FIGURA 2.12 EJe [àt llic,, f,ojoct ~ - - For"* !ods - l:!tb
Você pode desenhar l;,iJ · trl · ~ "~ I~ ~ 6 1..., : ·· o!J·~I .:-... . ~-
elen1entos visuais, 1~ "' ~ ,;J :,' <!} ó 1!7,:
Íd,ox
?. ' ••• I !<;: ~ ~ 1
g )(' •
o()o
~ ~
*~: §; ê: ~ ~
. ~ fo,mJ,vb (OcJl9"1]•'
or. ... .
corno caixas de texto, !~
°=
"ª- - : - - - - - - - - - - - - : 1 •

. -=.,,,"-...- - - - - - - - - - 1 - - !.l
D '· D

en, 11111 .formulário ~


'"',."" ........ .... ................. ... .... .
depois que os tiver li: - ' ." .... ' . ... .... . ...
A Ubel . . ... . .
selecionado na /:,LriLllool ·:: :::::.:
. · . ·: 1::· · ·: :::::::::: · · · · · · ·1::: ::· ·: ·: :::::
. . .. . . . .. . .. . . . . . ... . . . .. ... ..... .. .. . .. ...
Toolbox. ---
.e)IUb>n

~-'
r.i I....S..

p O>e<ISOx
r.~on
~- .. D
. .::::::. .
.... .... ...::::: .
. .. .. .. .. .. ... .... . .. .
.......... . '

.......... . . ..... ·· ·· ·
'
...i.« .: :: . :.
' ........... ...
' '

ir -
i;;:, .......... ..........
......
'

...... ................... .. ..... ........ . .......


. ..... ... .
o •..,.,
GJ D,ta(,ld ............. . ...... ...... .... .......... .
'
' '
'

!E; """""
ai--.. -·~ .
' '

ttJ CotnbOGOJC
::i IJst~
CJeo.>:d...,., _...,t ::.J
. . .fi. .;j~
40 Dia 2

Há um pouco de imprecisão nas descrições anteriores, que podem fazer você


NOTA pensar que a Toolbox é mais difícil de usar do que parece. Bem, a falta declare-
za é resultado da natureza do IDE do Visual Studio, que foi projetado para aten-
der a uma grande variedade de linguagens de programação, nem todas
disponíveis hoje. Portanto, seu comportamento exato (ou de qualquer parte
dele, como a Toolbox) é difícil de descrever. Mas, pode estar certo de que, no
aspecto geral, ele sempre funcionará como o descrito, independentemente da
linguagem utilizada.

Apresentarei de modo detalhado um exemplo de uso da Toolbox com um docu1nento visual pos-
teriorn1ente nesta lição, quando você criar um formulário Windows como parte de seu primeiro
aplicativo e1npregando o lDE. A Toolbox pode conter qualquer trecho arbitrário de texto, além
de fornecer alguns para a edição de HTML, desenvolvi1nento de forn1ulários e muitos outros ti-
pos de trabalho, o que significa ser possível gerar seus próprios itens que represente1n seções do
texto. Esse recurso é uma maneira útil de selecionar um frag1nento de texto (que pode ser, e pro-
vaveln1ente será, código) que se espera utilizar co1n freqüência e torná-lo facihnente disponível.
Para conseguir esse excelente feito de produtividade, selecione o texto desejado na janela de edi-
ção (o que pode incluir primeiro a digitação do texto) e arraste essa opção para a janela da Tool-
box. Tndependente,nente da guia que você arrastar, o texto dela detenninará onde seu ite,n
aparecerá. Como podemos ver na Figura 2.13, o item apresentará um nome inoportuno e bastan-
te se1n sentido, como HTML Fragment, ,nas é possível dar u1n clique nele co1n o botão direito do
mouse e selecionar Rena1ne (ten1 para fornecer uma descrição apropriada. Voilà! Agora temos
u1n novo ite1n personalizado na Toolbox, que pode ser usado sempre que se desejar apenas arras-
tando-o para a janela de edição.

·~. Wtndo-App!ic~ionO - M:uoi.cn Vii.uaJ BaUC:.NET (d-ign) · form t .vb• 1!!!10 E3


FIGURA 2.13 ~ {dt ~ eron-ct ~ Qdlu9 !ods ~ t1tb

Códigos, linguage,n 1~ • 'ili · !i$ " +'


1. ~ .,,, [ .., : r, · éJ · r.+ I , :-.. •
Q di' ~


~

HTlvfL ou outros · I~ ~ ... ~ur..


~ X

J
toot,ox fo,ml.vb* ,
trechos de texto pode111 c:Job!!o<d"!!l
~lft- Poriter
--
_J-:1 l.·J
f: ronnl (Wlnelow,Appli<ot.:) la•8"tto,,I_Clid< .:)
ser inseridos na ,...,.__ _ _ _ _ _ _ _ _ _ _ _ _
M.t: , !lutton.L. Si:c • 1.:e1o1 System. l>r6~
Ne , Bu'ttonl , Te.blnd ex O i
cc

1'oolbox e, en1 seguida. f!) TCD.t;t~~Show("Tat, Tcst 111


1 Hc . 8\ltton 1 . Text ....Buttonl .. ,q
t
usados {arrastados 'FOéff!l

para a Janela de ediçc7o t-te .iuto!co.lel!~cs 1:e - J:ev S y:,i.em


He . Cl 1entS 1 z.e • Nev Svat~. Dr:t'lv1n
de códigos e flTAI/L) Hc, Contro l:,. AddR.o.ngc: (Ucv Sy:,tco, V
:!e . ?:L~ • .. ,orml"
exatarnente corno Ho . Text • .. , orml ..
?!e . RétsumcLo.yout i rat :,e)
qualquer outro controle
dela. Ertd Sul)

# l!nd Rcoton

Pr:1vatc S\lb Buttonl_Cl i ck( 8yVol :,cnde

· Tn.:cc-t. Coo1 Tc::st 1no Code Uccc

t nd 5Ub
_)
(d I o, 1 DIS
Trabalhando com o Visual Basic .NET 41

A Toolbox, assi1n como o resto do IDE, possui n1uitas opções co1nplementares que não aborda-
rei, co1no a capacidade de adicionar 1nais guias (guias são aquelas seções deslizantes da janela
Toobox), renon1eá-las e alterar a visualização da lista de ícones de qualquer seção. Esses outros
recursos podem ser acessados por meio do 1nenu suspenso da Toolbox (o menu que é acessado
com u1n clique no botão direito do mouse) e també1n estão docu1nentados nos arquivos de ajuda
do IDE.

Command/lmmediate
Você já se surpreendeu executando o console de co1nando (ou a janela do DOS, como alguns
gosta1n de cha1ná-lo) para efetuar un1a tarefa? Para muitas pessoas, algu1nas tarefas só pode,n
ser processadas 1nais rapidamente com o uso do teclado e de uma interface de linha de comando
em vez de se empregar o mouse para navegar pelos ícones, 1nenus e caixas de diálogo. Já que a
produtividade do progra1nador é o objetivo final, qualquer rnétodo que puder ser n1ais veloz vale
a tentativa. O Visual Studio .NET possui uma janela que fornece duas fonnas com base no con-
sole de interagir com o IDE. Uma fez parte do Visual Basic por algum tempo, a janela Immediate
e a outra esteve presente no Fox Pro por muitos anos e acabou adicionada ao Visual Studio, aja-
nela Co1nn1and.
En1 tennos de utilização, elas são reahnente duas janelas, ,nas fora,n associadas para tornar a
operação u1n pouco 1nais confusa. Você pode considerá-las como duas janelas (sei que vou fazer
isso), depois que tiver aprendido dois itens essenciais: como alternar o modo da janela (de Com-
mand para ltnmediate e vice-versa) e como informar e1n que 1nodo a janela está atualmente. Pri-
meiro, o prioritário-tornemos essa janela visível; selecione View, Other Windo,..vs e Com1nand
Window no menu, exibindo assirn essa nova janela.
Essa janela, agora co1n o non1e de Con1mand Windo,.v, deve conter apenas u1na linha e1n branco
seguida de u1n prompt > (quase exatarnente como o console de comando ou o prompt do DOS
com o qual está acostumado). Ela já está no modo Co1nmand, e você pode inserir o comando que
quiser e executá-lo pressionando Return. Para passar essa janela para o ,nodo Immediate, apenas
digite o co1nando immed (e pressione Return ou Enter) no proinpt fornecido. Agora, a janela terá
passado para o modo hn1nediate, distinto do ,nodo anterior pelo acrésci,no de - Immedi ate ern
sua barra de título e pela remoção do prompt > de seu texto efetivo. Para retornar ao modo Com-
mand, digite cmd e pressione Return (sin1, você mesmo precisa incluir o pro1npt >). Agora que
sabemos como alternar rapidamente entre esses dois modos, pode1nos examinar a final idade e o
uso de cada urn.
O 1nodo Co1nn1and dessa janela pern1ite que você controle o IDE por meio de comandos digita-
dos - por exemplo, digitando Fi 1e. Ne Pro ect para realizar a mesma tarefa que seria executada
se selecionasse os itens File, New e Project no 1nenu. Uma interface do console em geral pode
ser 1nais veloz do que uma interface gráfica corno usuário. Essa duplicação de funcionalidade é
fornec ida co1no un1a 1naneira potencial de acelerar seu trabalho dentro do IDE. U1na grande
quantidade de comandos está disponível , n1as o modo mais rápido de encontrar muitos deles é
142 Dia 2

percorrer os nomes dos ,nenus visíveis. Depois que tiver digitado um non1e (co,no Edit ou
Fi 1e), adicione um ponto, e será 1nostrada u1na lista suspensa co1n os comandos disponíveis para
esse no1ne de tnenu. Aqui está u1na lista curta de comandos que é bom conhecer:
File.NewProject
File.SaveAll
Wi ndow.AutoH ideAll
A janela hnmediate fornece a capacidade de avaliar as instruções do código direta1nente (de
imediato!). Isso permitirá que você insira un1a única linha de código e veja os resultados se1n ter
de criar um protótipo inteiro do projeto. Esse recurso é útil quando se está no 1nodo de interrup-
ção, e,n que se interrompe a execução de um progra1na e,n curso. treinos desenvolver u,n exem-
plo si1nples de projeto, no qual usare1nos u1n 'ponto de interrupção' para provocar o
ence1Ta1nento da execução do programa e1n Luna certa linha de código. (O ponto de interrupção
será abordado co1n ,nais detalhes no Dia 6, "O Que Fazer Quando Progra1nas Bons Apresentam
Prob.le,nas e para Se Ce1tificar de Que fsso Não Aconteça", porque ele é reahnente uma ferra-
menta de depuração).
Você usará a janela Co1n1nand no início deste exe1nplo apenas para ter u1na noção de como ela
poderá ser útil no futuro. Certifique-se de que a janela Command tique visível e no modo Com-
mand, selecionando View, Other Windows e Co1nmand Window na barra de 1nenu. Agora, aja-
nela Command deve estar visível con1 u1n pro1npt > 1n.ostrando que está no 1nodo Co1nn1and.
Digite o co1nando Fi 1e. Ne Pro ect e pressione Enter. Uma caixa de diálogo aparecerá, solici-
tando a criação de utn novo projeto. Selecione a pasta chamada Visual Basic Projects na lista da
esquerda e o tipo individual de projeto chatnado Windows Appl ication, na caixa à direita. Dê um
clique e,n OK para fechar a caixa de diálogo, gerando un1 novo projeto em branco.
O projeto criado conté1n apenas um formulário Windows, e você ainda precisa adicionar seu
próprio código. No entanto, o Visual Basic já inseri u de ,nodo autornático tnn pequeno trecho de
código nele, um pouco do trabalho que é necessário para gerar e inicializar o novo formulário em
branco. Esse código pode ser visto co1n un1 clique no botão direito do mouse sobre o novo for-
mulário (najanela central do IDE) e selecionando-se Vie\.v Code. Esse procedi1nento irá adicio-
nar e selecionar u,na guia nova na janela central, un1a janela de código que exibe aquele
associado a esse formulário. Já que nada foi adicionado ao formulário, o código é um pouco limi-
tado, mas suficiente para o exemplo.
Selecione a linha Forml = Me, rolando para baixo a fim de encontrá-la, se necessário. Agora, você
quer n1arcar essa linha co,n u,n ponto de interrupção, portanto, a execução desse código será en-
cerrada ou 'interron1pida' quando ele a atingir. l-Iá três 1naneiras difere11tes de marcar a linha.
Urna é dar urn clique na margem (a área cinza-claro no lado esquerdo da janela do código), outra
é dar u1n clique com o botão direito do 1nouse e selecionar Insert Breakpoint, e a terceira é usar o
atalho do teclado para essa função, pressionando F9. Empregando o 1nétodo que quiser, adicione
o ponto de interrupção, e verá um ponto vermelho aparecer na 1nargen1 próxima à linha. Ela indi-
ca a presença de um ponto de interrupção.
Trabalhando com o Visual Basic .NET 43

Com esse ponto de interrupção inserido, você poderá executar o projeto, e o processa1nento será
encerrado quando ele atingir essa linha. Co1no para o ponto de interrupção, há três 1naneiras
principais de iniciar u1n projeto: u1na é usar o botão da barra de ferramentas (que se parece co1n o
botão de reprodução dos CD players ou videocassetes - veja a Figura 2.14), outra é utilizar as
opções Debug e Start do 1nenu, e a terceira é empregar o atalho do teclado, FS. É claro que a op-
ção a ser usada é un1a preferência pessoal. Muitos programadores achan1 que, no final das con-
tas, os atalhos do teclado são a forma mais fácil de acessar as funções mais co1n.uns.
Quando você iniciar a execução do projeto, ele será rapidamente encerrado e exibirá a linha de
código marcada co1n un1 ponto de interrupção. Agora, esta,nos no 1nodo de interrupção, como
indicado por [break] na barra de título do IDE do Visual Studio. A setaan1arelaque pode ser vis-
ta na 1nargern da janela do código indica a linha que está para ser executada (processada). Nesse
ponto, pode-se alterar a janela Command para o modo Jm1nediate e testá-lo.
Se sua janela Co1nmand estava visível antes da execução do projeto, ainda deve estar presente,
e1nbora o layout possa ter sido u111 pouco alterado quando ceitas janelas foratn abettas auto1nati-
camente no momento e1n que você estava no meio do processamento do projeto. Se a janela
Cornrnand não estiver visível, abra-a usando as opções Viev.1, Other Windows e Co1nmand Win-
dow do menu.

Debug • x
FIGURA 2.14
A barra de f erra,nentas ~ li • C1 1 + l+Ji e~ ~ 1 Hex 1 @ •
fornece botões para
iniciar e interron1per a
ex ecução de
progra,nas, usando
ícones parecidos com
os controles de
videocassetes.

Dê um clique na janela para selecioná-la (tomando-a a janela ativa no IDE) e digite irrmed (segui-
do da tecla Enter) para passá-la para o modo hntnediate. Agora você pode inserir qualquer ins-
trução do Visual Basic, e ela será avaliada imediatamente (daí o no1ne). Tente as instruções a
.
seguir:
? Me.Width
Me.Width = 50
? Me.Width
? 3 + 5
? 3 = 5
44 Dia 2

NOTA
- Usar as teclas de seta para cima e seta para baixo enquanto estiver na janela
Command/lmmediate nem sempre o transferirá para outra linha dela. Em vez
disso, se você já tiver começado a inserir algum texto, poderá passar pelos co-
mandos executados. Se você selecionar uma linha que já passou (na janela) e
começar a adicionar texto nela, será criada de modo automático uma cópia
dessa linha, com suas novas alterações, na parte inferior da janela. Isso torna
qualquer texto antes da última linha da janela efetivamente de leitura.

Notou o ponto de interrogação e1n frente a algu1nas das instruções anteriores? Isso indica 'exi-
bir' e, se1n ele, o Visual Basic não saberá o que fazer co1n as instruções que retornam um valor.
Por exe1nplo, 3 + 5 produzirá 8, mas, se1n a instrução de exibição, 8 não será um comando válido
do Visual Basic. Por outro lado, instruções co1no Me. \~i dth = Me. \•li dth * 2 são trechos de código
válidos do Visual Basic e não precisam do ponto de interrogação e1n sua frente.
Pressione FS para fazer com que a execução do código continue após o ponto de interrupção, e o
forrnulário aparecerá na tel.a 1uaior do que o tan,anho original se você processou as instruções do
exemplo fornecido anteriorn,ente. Como pode ver, é possível afetar pa1tes de seu progra1na a
partir da janela Im1nediate, o que a faz uma ótima ferramenta de depuração.

Dynamic Help
Esta janela de ferra1nentas é configurada como uma guiacon1 ajanelaProperties (se você estiver
usando as configurações do perfil Visual Basic Developer) e fornece referências, co,n base no
contexto, da docu1nentação dos arquivos de ajuda do Visual Studio. E1n vez de esperar que você
solicite ajuda, esta janela de ferramentas age de 1nodo proativo quando a tecla F1 é pressionada
ou algo é selecionado no 1n.enu Help. Cotn base em sua opção ou tarefa atual, ela exibirá tuna lis-
ta de tópicos relacionados. Na Figura 2.15, a janela de ferramentas Dyna1nic Help 1nostra u,n
conjunto de tópicos de ajuda sobre a tag HTML atualmente selecionada na janela de edição de
códigos. Além dos tópicos relacionados, essa janela en1 geral exibe u1n link para vários tópicos
mais genéricos como (nesse caso) a seção Coding Techniques and Progra1nming Practices (Téc-
nicas de Coditicação e Práticas de Progra111ação) da docu1nentação. Essa janela de ferramentas
ta1nbé1n fornece um link direto para as seções de pesquisa, conteúdo e índice da docu1nentação
de ajuda por meio de três ícones da barra de ferratnentas.
Trabalhando com o Visual Basic .NET 45

... Windo"'1.ApplJc4ltoo8 • Mictollin Vk.ual B.ttkMT Idt'Monl • forml.vb R0 Ei


FIGURA 2 .15 6c [de yPw e,.,..
à)l • fu . ~ liJ o• 11 ~ e,, . , :
~ Q,l,uo [ods - t!ol>
r..1
A janela Dyna,nic J-Jelp
tenta 1nostrar ,~~ll:.··
~~~~~~~·~°'~"·~·-~~~~~~;;p;~~~~~I~ """ ·
"'",. ·
:;•
. . <, • .!P .
u~~-
~ .
~
.
inforn1ações úteis f~•O<ml (-w•A-..lone) .:J l1•1n1tl..,c<on,po...,,,.c~:.....:fil::....::~..:.....-~ - - - -~~
1nes1no antes que você • TOrlD!
Q)J ....,,
ccw«.~ro ~ A 11tftDild
as solicite. Ke . AutoScaleBa:1eS1:e • Nev Svotcm, DcawinQ, Si:c (5, l
Ctl2t::mm.
Me dRXWCtd>
Me . Clicnt$1:e • Ucu $ y:,1;ca. 1>cor,in9 , Su:e (292, 2?3) li=
Me , Com.i:ob. lddR<angc: INc1,1 Sy~tc.:w,. tlindov:,. r orm:, . Contr+ CCSs' CM tezt fdter
Me .Nt\llle • '"roml ·" CWos lcstmm on:J Prw«rm'wPr4\Sd
~lbtRctum
He . Te x t • '"f oi:101 ..
ae .Reslb!leL~'lOUt(ra1se) e' ....,...
»21 :l e:)~s S:n', tw-:s
Yl?a~ $:nl,;s

I. .... ···--·
End SUb
(Ui f".cttlno St,a,tcd
wt»S's tlNt kl l:ffl.l'N::t
t,.mJ.»e CMm!s hYM 6$
'mid2udow.tfthfe,d)f
(yats:,;r;nq tbc Qm):,MWI, (m:k«mm1
Custo;ri;,hQ Px\:'W!!C H:'Q
'D• h ,v.ltOO&.U-r'I' : t.o s.d•d. • e: \uinr.c.\ ;,,.tcro•o ! t . l\n, \ tr·~•vo<k\ vl . O. ?9H \ 1a.,1 c ll'Lf'cdtjnq ~ S tudo.t-ET
'VLndov1>.pplí.cat.iont•: t.0 "411.d ' D:\.'Doc1.1&•r.t• 4lnd S11.ttlnqt\l)\u\c-a\ Hy Do '1l'2,l;l$yôo1l(l
'v,.octovsA,ip.Uc•eJ. ont. •••' : l.o ad•d ' e: \vi.l'W$t.\ u ,11.-.J,ly\qa<\ • Y• tt.•, uj l\dov•
' V1ndovflpplicae1ont.••• ': Lo ad•d •c: \VÜlnt\•••~ l y\q~\sytt . .\ l ,O.Z41
' V1ndov1A.pplic•tiont.•••': Load•d •c:\v1:nnt.\••••lll>ly\ ~a,c\fY•t••· d r •vin~
' W1ndo~;Applicaeiont.e1e': Lo ad•d 'c:\v1J::r.t.\ a.s$1lably\ qac\ •Cc•ss~ility\
the p~ov~aa 'l 1Sa.81 Vindov,A.ppl1ca~ion8. e1•' ha.s • • 1ted v i th code O iOc

r li<!

Server Explorer
Estajanela de ferra1nentas (veja a Figura 2. 16) fornece uma listagem visual de dois recursos es-
senciais, bancos de dados e servidores. O primeiro conjunto de recursos representa todas as co-
nexões estabelecidas entre seu projeto e vários servidores de banco de dados, e pennite que você
explore esses bancos de dados para examinar tabelas, procedimentos annazenados e outras in-
formações úteis.
O segundo conjunto de infonnações, Servers, representa qualquer 1náquina co1n a qual você pos-
sa se conectar e que forneça un1a interface visual para os recursos que ela possa tornar disponível
para seu progra1na. Esses recursos inclue1n contadores de dese1npenho, registros de eventos, fi-
las de mensagens e 1nais, todos faci hnente encontrados por meio desta janela de ferra1nentas.
O Dia 13, "Usando o Server Explorer", se aprofunda no uso dessa janela de ferramentas para en-
contrar e manipular recursos de servidores.
46 Dia 2

·•. Mlcrosoít Dl!Velopmcnt lnvitonn~nt [ design] · forml.vb Rr;J EI


FIGURA 2. 16
O Server Explorer . ri,
..
l l'él ~
fornece uma 111aneira r-orml.'t'b
visual de exa,ninar e f?ij rClt'ml (W'tndows.A,ppllcaUonB)
:,1 Dd.o (:Of'W'c(batd
usar recursos tanto do s- e~g -.. ' f'oaol
drirl:iM~
se1'l'idor local quanto ~ CrlUS....ke,


a l!!! e.... ,..,, 1tc .J.utoSC(IIJcBe11a.e!:hc • Ne v 9 y#te.J11. Drelvtno.sue(S. 1·
de outras 111áquinas. rte . Cl 1ent.S1:e • New S y:9te.11:t. Dravia.q. S i u (292, 273 J
ne. control:J . .ldd.Ra.nae p:e v sv:,tcln, 11u1.covs . ronns . cont.r•
.
'il ;
.:J
-'""'
Sea..rlty
:,') l!!! ........
ne .Ho.me •
n.e.. Text •
'"foem1"
.. t·o~l"
a 'frl MHS410e Quews nc . Rc~umc:Loyout (Fa lo~)

'll D
r.: (J ""'" -
J\.tilc {\.111)..JeS
$ c:i ........ _
(!l; G) Pttfcriro~o Cwtt<S t/lnd P.eg1on
q;,, s.n,,.,
8 6J sq.,..,_,
JJ e,,~
1



Properties
O IDE do Visual Studio pennite que você trabalhe com 1nuitos itens, projetos, soluções, fonnu-
lários e classes diferentes, além de outros recursos, todos possuindo atributos e propriedades.
Essas propriedades são inforn1ações que descreve,n o ite1n, como o nome de u,n projeto. E1nbora
as propriedades seja1n em geral preenchidas auto1natica1nente, co,n valores-padrão, é preciso
uma maneira de alterá-las. A janela Properties fornece essa funcionalidade. Se1npre que um item
for selecionado no IDE, os atributos desse objeto serão exibidos nesta janela de ferramentas
(veja a Figura 2.17). Alguns desses atributos pode1n ser de leitura (não podem ser alterados),
mas, se assim o for, então, será possível dar u1n clique neles na janela Properties e alterá-los
quando necessário.

Solution Explorer
De ,nuitas maneiras, o Solution Explorer é se,nelhante ao recurso do Windov;s Explorer usado

no Wi.ndows. .E a interface de gerenciamento de arquivos do Visual Studio .NET. No Visual Stu-
dio .NET, o código que você criar poderá ser organizado e,n ca,nadas diferentes de agrupa1nen-
to: soluções, projetos e arquivos. A janela Solution Explorer per,nite que sejan1 visualizados
todos os objetos que estejam abe1tos no mo1nento, e,n seus respectivos grupos ou janelas. Aja-
nela Solutions contém projetos, isto é, aplicativos e componentes individuais, co,no u,n sistema
completo, incluindo co1nponentes executados tanto no cliente quanto no servidor. Dentro de
cada janela Project estão todos os arquivos efetivos do projeto (classes, formulários e outros ele-
1nentos).
Trabalhando com o Visual Basic .NET 47

.••. W1ndo...sApp"c t1t1on8 • MK,o~on Vl'SU<II 1:1.l-UC..Nl l {dNlf.,nJ · fom, 1.vb ( ONIQn] l!!!lg Ei
FIGURA 2 .17 Bt tdt ~;,., ~;,ct ~ l!!buo - Iods ~ ~
Quando urn objeto for !b1 • fu • ~ lil ~ 1 ,. ~ e. 1-~: <• • ~ • c.1 •~ · flf.
selecionado na janela - l $ 1 - '11 ,li 1... ~ +L ,<H I"" ~,: ~ ?.
,_ Form1•.i.(o..q,J
*: -: ·~: •
ê! ~ 'tJ, " •

,_
de edição (111110 caixa ITe>elBoMI
--
SySt!9'1..WindoM..fOtms, Text.80:..:] •

de texto e111 11111 ;. ·. ': ~· \~- ti @ i5


.for,nulário nesse caso),
.
' ' '
....... .. ...... ... ...... ... .
' ' ' '' ' · · '· ' '
' ' ' ' '' '
' ' ''
.' •' ' ' ' ' f t>.lA\IJl
T~I
Left
A .- .:::::::..... . .. . 8 tkh-lvt0t
a janela Properties ,.\LWl4bel : : : : : : : : : : : '. '. : : : : : : : : : '. : : : : : : '. '. : :1 Ac<l':j)ttA.etWt FJJl:sc

exibirá todos os seus •: : : : • ; : : : 8"10\l f::: :'. ::.:::::~ '. A(<tPUlob F4',c,

,...
.!!l ""'"'
Jiu •: • • • • ••• : • • • ••• . AbfOloOQ ...

.... ... .. .. .. ......' ..' ................ .... ...... .. . .......


To.tSooc

atributos. ;ii ............


'
.. . .. . . ..
PChcób :::::::::: l:I'. '. ' g '
.:::~::: :: ~íP3(111(1o
•.. o ... ::::
º .:::::::
''"""
(non,)
Ç° R.odo&..tton
1:J ,.._ ..... .. .... ..... . . .. .....
•.••• ·· ti o .. rn.oe

tã:J --
0 •.....i
......... . .
.
.
.
.
....... .. . . . . ....
'

...........
.. . . . .......
. . . . ...
' '
.' ... '"'"
.....
llkleortl'ol
3Z767

... .
.
. . . . .. .. .. .. . . . ..
i;:i ......... .
' '
.' .
~ UStBox . '

~-.-
'!; C:0,,-
!!l~
~~
.. -~,-
Além de permitir que você visualize o que está abe110 no 1no1nento, a janela Solution Explorer
fornece vários recursos. Por 1neio dela, poden1os
• Adicionar novos arquivos a un1 projeto (dê u1n clique co1n o botão direito do 1nouse no
projeto e selecione Add)
• Re1nover arquivos (dê um cl ique com o botão direito do mouse em u1n arquivo específico
e selecione Remove)
• Adicionar e re1nover projetos inteiros de um grupo Solution (dê u1n cl ique co1n o botão
direito do mouse na solução para adicionar um projeto e em u1n projeto para a opção de
removê-lo da solução atual)

Class View
Como parte da discussão sobre o Solution Explorer, expliquei que poderia haver n1uitos arqui-
vos diferentes envolvidos e1n tun único projeto ou solução. Esses arquivos en1 geral correspon-
dem às classes criadas (como uma classe Veículo ou Conta), mas não há um requisito para que a
organização do arquivo se pareça com a organização conceituai das classes no projeto. A janela
Class View (veja a Figura 2.18) foi projetada para pertnitir que você visualize a estrutura do ob-
jeto de seu projeto e use essa visualizaçã.o para navegar em seu código.
Dentro desta janela, você pode minin1izar e expandir os objetos exibidos, para acessar as diver-
sas propriedades e n1étodos que eles expõem. Dar um clique duplo e1n um item específico de
Class View o levará para essa classe, 1nétodo, evento, propriedade ou procediinento. Se o item
sobre o qual houve o clique duplo não estiver disponível co1no parte de seu código, Class View o
conduzirá para a definição dessa parte da classe dentro do Object Bro\.vser (veja a próxi1na se-
ção). A janela Class View é útil como uma maneira de exa1ninar seu projeto através das classes
definidas nele, ignorando os detalhes físicos dos arquivos reais.
48 Dia 2

·~. Jllr-r · Mlu~oR Yl1..md O.tt.l<.M J [dt:'"\lgn) · Rodlul)uttWK.vb (DMJOn] l!lr;] EJ


FIGURA 2. 18
A janela C/ass Vieiv
l;4e tdt ~ ~ ·'""
'
I i.i · tJ · ~ lil 11:11
~ l!«<>J -

• 1 Y te e r, •
.. lools 1!L'ldow ti't>
· · J: · c.1 , -
'
· "'•
mostra seu projeto 1.;!!' •

1~ . I"' ~. l'.l .... .,, "" 1~ l:1- t f.?.l ... !": '!'!' ~ ,., f : *; ê! ~ ~ 'tl "' .

organizado por seus ·: ·,,...,-
e I ~ ~ - ~ - - ,,~
objetos e não por seus e- O F&!<
arquivos fisicos, e r G.~Ol!l , ,: f ;, e -<>i; f,fl!'R!r
1j1 º ; ..... ,,,11,....1""'
.fornece acesso direto ... .......
(' A<1dc8\Alonl
"l'
... .. . . . .. .
r-Raóc&clon2
.
•• : • , ,• •,

:: : :··:· ;; ;:
iá• boY:opy_Od(c»,..,,E
IJJ• bb'Oelcte_Cld(Ob;ed,,E
ao interior e/esses
e.
(" R,ddl..,..,:J ; :: .... ~· Wl..,,._06(Cbl0(.l,E_.,.
à• CopyCl<l(Cble<t,-
... CisPO~!ltdcon)
~o ) ,
objetos.
. .. :·:..:! .: .
• $•
.. f"R,ck&aoM ::::
' Lt ::zA
l!'i!t'!t , 62:.:w ' ,;;r;s;;ç.;, m!.:,!!, , •
OoEv~ O bllC<t.f
~• w 1o1• ~ 0
• :...

... - -, - ----:
r .., !".. • r~w()
....... . . .... . . . . .. . ... ..... ..
: -
, '
t~l'; btN:(ipy
yl) W'Oclcte
t/>btrl"ove
... .. . . . . .. . . . . . . . . . . . . . .
... . .
..... .
. .
"
'
' '
. . . . '
'
' r,/;

IÍ'
e,h\;O\>ffllrio
'""'«-,
,/; l'G>~
• • ~<"; tlSou·ce
./ >txtO~
,{I b:\SOwce
l!J ~ -
~ =;=~-------------~·~·.__________.__..!.!
....., E) "'""

Object Browser
Toda a prograrnação na plataforrna .NET é baseada ern objetos - os objetos fornecidos como
parte do .NET Frame\-vork, os que você criar e até os que outros participantes de sua própria
equipe desenvolverern. Todos esses objetos possuern propriedades e 1nétodos por meio dos quais é
possível interagir corn eles, ,nas co1no saber o que está disponível? O Object Browser foi proje-
tado para ajudá-lo no trabalho corn todos esses objetos, permitindo que você navegue e pesquise
e1n utn catálogo de objetos disponíveis. Esse catálogo inclui os objetos (classes) expostos por
qualquer biblioteca de classes que for referenciada, alé1n das classes contidas e1n seu próprio
projeto. Sen1elhante em alguns aspectos à Class Yiew, o Object Browser vai além da funcionali-
dade dessa. outra janela, incluindo objetos externos ao seu projeto. Essa janela é n1ais útil corno
urna 1naneira de documentação ou referência, pennitindo que classes seja1n encontradas dentro
do .NET Framework ou outras bibliotecas de classes e seus detalhes visualizados, coino suas
propriedades e rnétodos. Na Figura 2. 19, podernos ver o Object Browser sendo usado para pes-
quisar o conteúdo da biblioteca System.Data, exibindo infon11ações detalhadas que vão até o ní-
vel dos parâmetros necessários para uma. certa cha.rnada de método.

Lista de Tarefas
E1n qualquer projeto de desenvolvimento, 1n.es1no os concluídos, há a probabilidade de ficaren1
várias tarefas pendentes para serern completadas. As seções do prograrna podem precisar de
ajuste no desempenho. Pode haver erros conhecidos ou recursos que necessiten1 ser re,nediados.
Quando as tarefas pendentes podem ser relacionadas em u1na área do código, urna prática. co-
mu1n entre os prograrnadores é marcar essa área corn con1entários. Quando os programadores in-
cluem consistentemente certas palavras-chave como TODO ou BUG nesses con1entários, é mais
Trabalhando com o Visual Basic .NET 49

fácil varrer o código procurando-as para encontrar os trechos apropriados. O Visual Studio .NET
formalizou esse processo fornecendo uma lista real de tarefas que é preenchida de modo automá-
tico con1 referências a qualquer seção de seu código que contenha uma das várias palavras-chave
como TODO (1nas, você pode especificar a palavra-chave que quiser). Cada comentário encontra-
do será, en1 seguida, relacionado em uma lista fácil de usar, detalhando não so1nente o próprio
comentário, ,nas ta1nbé111 o arquivo e a linha onde foi encontrado (veja a Figura 2.20).

·~. f llf'r · 1'111lrowrt Vttuol 0-Mk..NE f (dttlon) · Ob)fi:t BtOWltt l!lr;] Ei


FIGURA 2.19 tGe ~ fiew ero;ec;t ~ ~ O!t.o Iodf ~ ~

O Object Broivser 1~·lli·~ "i3' 1~ 1Q ~l· ~·&'.·r..1


1!t , ... ,$ -1 -; oi) - 1 ~ "'"
1

+! ffi .,. >:=: P.'


,:°&"""i: ê: · i1!ll,___ q, ... .
~ ê: ~
pernlite que seja,11 ijj: (ll>jcd _ _ _ _ _ _ _..,..._..,.._..,...

exa,ninadas as classes ~ Sel«tedC ~ .• t ~ ··· I tl · 1;: · I~ . :,. .;~ ., __,_____


., _
fornecidas pelo .,VET

Frame111ork e de
qualquer outra t~ ".J Svstem
S .Q Systcm.D.,to
biblioteca que você ~ 1> $y,t.n.~t...
'• C) Svstffll.Dõto.CCffl'lO"I
tenha criado ou
~~--
-!!:, C) Syst- .Data.Oiit«,
S (} Srsteca,.Data,s,j::ktt

~---·
referenciado. (+) ~ , Corne<t5!>rPOOLCÇU"(Or

.....
~-""'
8 '>i; sct.:am~

9-
~~-.,.-,~~~ --·-
~ Sd(oo,,,<too
t>i; $ql'.).at,nA~ «

.. ~r~-----.==~=-------------......c
~
~~~

Você pode adicionar suas próprias palavras-chave à lista de símbolos reconhe-


NOTA cidos por meio da caixa de diálogo Options. Na sua seção Environment\Task
List, é possível acrescentar novos símbolos e especificar configurações para a
tarefa, que serão criadas quando essa palavra-chave for encontrada. As
palavras-chave só serão consideradas quando forem encontradas nos comentá-
rios de seu código.

Co1n u1n rápido clique duplo em u1na tarefa pendente, você será levado de imediato para o códi-
go, no qual poderá trabalhar no que ela indicar. Alé1n dessa funcionalidade - por si só bastante
útil - , a lista de tarefas pode conter várias outras espécies de tarefas. O Visual Studio adiciona
outras tarefas automatica1nente, co1no a referência a erros co1npilados e outros itens perceptíveis.
Mas você ta1nbém pode acrescentar dois tipos de tarefa a essa lista: atalhos de código e tarefas
definidas pelo usuário.
50 Dia 2

FIGURA 2.20
Cada co111entário -~l l!i!il·-
'f,I ;... ••
marcado con, unia frmf....vtt•
palavra-chave especial
é 111ostrado e111 11111a Q
lista de tarefas ben1 ...J ~

organizada. Prtvate Sub CopyC l ic~ (ByVal sender 1.5 Syste.m. ObJ eet; _ f
BVVal e As Sy!llt-etn. r:ventJ.rg:,) füUl(ll~ bt.l\'COP'S'. Cllc.~
'TODO: Conn,e:n~ tht~'

:tc:,:,agcBox , S ho11 ('"CopyC l t c k'")


to.d Sub


• •
-
~ • TC:00: Comment Ui$! O:\Dc<~s aid ...\Flct\fn:Re,.>A) 135
• PERF: QtJ,::1'.tr to delM,e fie as POIHI ccoy O:\DOC~ ~ .. ,\Flet'l,frnffer,.'fb 192
1 • HAO:::. AssumMIM msts O:\Ooc~ «111 ...\,Fle,\f,l'fff!!r,vb 1,3

Os atalhos de código são se1nelhantes às tarefas co1n base e1n con1entários, 1nas são uma referên-
cia a alguma linha do código. Não precisan1 de nenhuma palavra-chave especial. Para adicionar
un1 atalho de código à lista de tarefas, dê u1n clique co1n o botão direito do 1nouse na.janela de
edição de códigos e selecione o item Add Task List Shortcut no .1nenu.
Uma nova tarefa será adicionada a sua Iista, com o padrão para a descrição sendo a linha de códi-
go selecionada (embora você possa, e provavehnente deva, alterar isso para outra descrição que
queira usar). En1 seguida, você poderá retornar rapidamente para essa linha apenas co1n u1n cli-
que duplo nessa tarefa. Quando um atalho é criado, uma seta
,
azul é posicionada na margem es-
querda da janela do código próxitna à linha apropriada. E possível remover o atalho dando um
clique com o botão direito do 1nouse na linha do código e selecionando Reinove Task List Short-
cut ou selecionando o ite1n novo da lista de tarefas e excluindo-o diretan1ente.
O outro tipo de tarefa que você pode criar é u1na tarefa do usuário, que não está associada a ne-
nhum trecho e,n pa1iicular do código, se1nelhante a urna tarefa-padrão do Outlook. U,na tarefa.
do usuário é adicionada com u1n clique na seção Click Here to Add a Nev.1Task da lista de tarefas
e preenchendo-se os detalhes. Observe que, diferente das outras tarefas, essa não possui campos
de arquivo/linha preenchidos e, portanto, só tê1n dois ca1npos disponíveis, a descrição e a priori-
dade (baixa, nonnal ou alta). Se quiser criar u,na observação sobre u1na área específica do códi-
go, você com certeza achará mais útil gerar um atalho de código e alterar a prioridade e a
descrição para. fornecer ,nais detalhes sobre a questão real.

Soluções e Projetos
Como discutimos na seção "Solution Explorer", existe1n vários níveis nos quais seus códigos
podem ser agrupados. O primeiro, a solução, representa o sistema completo que está sendo cria-
Trabalhando com o Visual Basic .NET 51

do, enquanto os componentes individuais dele são representados por projetos separados. Antes
que você possa desenvolver qualquer código no IDE do Visual Studio, precisa configurar a solu-
ção e pelo n1enos u1n projeto. Nesta seção, percorrere1nos os princípios básicos da organização
do código, criando novos projetos e trabalhando com projetos e arquivos existentes. A seguir
apresento um resumo desses tópicos, 1nas, na seção logo a seguir, passaren1os a praticar essas ha-
bilidades gerando un1 exe1nplo con1pleto de um aplicativo.

Criando um Novo Projeto


Existem algumas maneiras de criar um novo projeto, ,nas o método ,nais con1u1n usa as opções
Fi !e, Ne"v e Project do ,nenu. Essas opções apresenta,n u1na caixa de diálogo que 1nostra todos os
diferentes tipos de projetos que o fDE pode gerar (veja a Figura 2.21 ). Já que o JDE do Visual Stu-
dio trabalha com várias linguagens, a caixa de diálogo n1ostra as opções cotn base nas liJ1guagens
que você te1n instaladas e podem apresentar tuna aparência diferente da exibida na Figura 2.21.
Por enquanto, desenvolveremos projetos co1n base nas opções da pasta Visual Basic Projects.

New Project E!
FIGURA 2.21
Proj,!(t Typi,s: Tetrc,hte~: ltt.§J
::::
O Visual Studio possui -ti .. •
urna caixa de diálogo D \llswl ( 6 P1ojccts
-O 'v1sual C++ Pro)'!cts ~
Yhldows
~
Oassl/Naty
~
Whdows
chan1ada Ne111 Prqject, -D Setup .n:I Dct=l0>ment Pro,ects Jlj)j>li<,tlOI\ Cet\tr'OI Ltlr'51'(
13..Q Othtr PtoJc<U
que per111ite que novos
~ ~ ~
Cl Od.<Dase Projocts
l'E-0 f MCfí,lÕSé T~ tc Pro)Cds
projetos seja,11 CJ ~ StudoAno!y: or PrO)OCtS ASP.t\El'Web ASP.,V Web Wt't>Corittd
~ ?t~.~ty..R~jeC~ •- ._, ~ A.pplk.aUcn !erv",:e Utv«y ~
acrescentados quando IAp-o~t f0t cre«lng 41"\ l(>Plc.ation "'th a ~ s·use, uu.i ~ i
você instala ,nodelos Narr~ ( WindowsApçkaticn9
ou linguagens Loeati:n: ~I0-,\1)-00,-,.....-.,- . n-d5'<
- l!no<
_ \P_""
_•_nm-a\r,ty
_ Oo<
_ u,,.
- n!-.,,~:::J Brcmse...
adicionais. (". Add to Sc:lw:in C: Oose-Sol!&n
,.,.SolJtlcn_, l w,ndow-..-«>tl"'9 í-7 er..,to d<octoiy f«SOUlon
Pro)l'?d: wn be aeat:ed at0:\ ...\\f1sool Stucfü Projects\WndowsApf::6t.aoon9\\li.'indowsAçpkation9.

Ok C.ncd

Para criar um aplicativo que seja executado locahnente en1 sua 1náquina e usar utna interface
com o usuário co1n base no Windows (coro caixas de diálogo e outros elementos UI do Win-
dows), selecione Windo,vs Application na lista de tipos de projetos. Para concluir o processo de
criação, digite um no1ne para seu novo aplicativo e, se quiser, altere o ca1ninho sugerido. Dê um
clique em OK, e o Visual Studio gerará seu novo projeto. E' u1na boa idéia dar a seus projetos no-
mes significativos, 1nesn10 quando você estiver apenas fazendo testes; caso contrário, logo have-
rá todo um grupo de projetos co1n os no,nes WindowsApplication 1 e Windo\vsApplication2,
dificultando a localização de algo etn que tenha estado trabalhando.

Abrindo um Projeto Existente


Quando o Visual Studio for encerrado, ele perguntará se você deseja salvar o que esteve usando
e fechará tudo de ,nodo autotnático. Para que se possa voltar a u1n projeto anterior, esse precisará
152 Dia 2

ser aberto no IDE. O Visual Studio fornece algumas 1naneiras fáceis de abrir projetos passados.
U1n 1nétodo é usar o menu através de File, Open e Projectou diretamente pela opção Recent Pro-
jects próxitna à parte inferior do n1enu File. Outro método é por meio da seção Get Started da pá-
gina inicial do Visual Studio, uma página HTML que lista os últÍ!nos projetos utilizados. Nesse
local, é possível dar um clique no projeto específico que se quer abrir ou até criar um novo atra-
vés de u1n link adicional. Abrir um projeto novo faz con1 que qualquer outro projeto que já esteja
sendo usado seja fechado, a menos que seja1n e1npregadas as opções File e Add Project do rnenu,
que adicionam un1 projeto novo ou existente à solução aberta recenten1ente.

Arquivos
As soluções e projetos existem quase apenas para fins de organização; o código efetivo reside
e1n u1n ou 1nais arquivos individuais. Quando você cria urn projeto novo, ern geral são gerados
certos arquivos, como u1n novo formu lário Windows (Forml. vb) ao ser criado um aplicativo
Windows e um novo 1nódulo (Modul el. vb) para um aplicativo do console. Esses arquivos são ge-
rados em disco e existen1 independentemente de seu projeto, pennitindo que um único arquivo
seja compartilhado por vários projetos se isso for desejado.

Adicionando Arquivos a um Projeto


Além dos arquivos que são criados de inodo auton1ático corT\O parte de seu novo projeto, você
ta1nbé1n pode querer adicionar módulos, classes e fonnulários co1nplementares ou outros tipos
de arquivos de código. Por meio do menu Project ou do que surge com um clique no botão direito
do 1nouse sobre o projeto da janela Solution Explorer, é possível optar por acrescentar qualquer
arquivo de vários tipos. Tndependente1nente da opção específica do 1nenu que foi escolhida, co1n
exceção de Add Existing lte111, todas o conduzirão à caixa de diálogo Add Nev.1 lte1n (veja a Fi-
gura 2.22). Se, em vez de criar um novo item, você quiser adicionar u1n arquivo existente ao dis-
co, a opção Add New Existing !tem do menu apresentará, para esse fim, uma caixa de diálogo
para abertura de un1 arquivo-padrão.

Add N~ n rm - r iln E'f


FIGURA 2.22
Da mes,na 11,aneira que Cateçoiies:
sD
Ten:plate,s: m:~
::::

~ ~
Locôlf:"lo·o,ect Ui'M
a caixa de diálogo l\'e111 a u,
!-CJ Codo>
éEl
HUILPq Ft~t 2yle 51"-.eet
Project, a inteiface º lll!I
º"º
K:J
para adicionar itens
~ ~
D utll:y

novos ao prqjeto é >1>\. Rio XSLT Ffo

expansível.

[11n H'fM.. ptllJe thd: cõn hd>:le crcot"9de codc

N,3111C: 1HTl'LP°"'e l.ttJn


Trabalhando com o Visual Basic .NET 53

Salvando Tudo
Corn todos esses grupos diferentes (soluções, projetos e arquivos), é importante saber como sal-
var os trabalhos que fora1n executados, mesmo se estiverem localizados em mais de um arquivo.
No IDE do Visual Studio, isso é feito através de dois cornandos diferentes: Save e Save Ali.
Esses co1nandos, situados no tnenu file e na barra de ferramentas, pennitem que seja salvo ape-
nas o arquivo selecionado no 1no1nento (selecionado najanelaServer Explorer) co1n o uso do co-
mando Save ou, por meio do co1nando Save Ali, todos os arquivos abertos que tenham sido
alterados.
Se você tem 1nedo de perder seu trabalho, co1no eu, ficará especiahnente interessado etn uma das
opções do IDE. Na caixa de diálogo Options (acessada por 1neio dos itens Tools e Options do
menu), é possível expandir o grupo Environ1nent e selecionar o ite1n Projects and Solutions para
ver um conjunto de três botões de opção sob o cabeçalho On Build/Run (veja a Figura 2.23).
Essas opções controlam se o IDE salvará algurn arquivo alterado antes de cotneçar a executar um
projeto. Essa é tuna configuração importante porque, se o IDE falhar e,n algu1n 1no1nento, é be1n
mais provável que isso aconteça quando seu código estiver em execução. Essa opção fornece
tuna maneira fácil de assegurar que todas as suas alterações seja1n se1npre salvas antes da execu-
ção de seu código.

FIGURA 2.23 ~ 'º"' D


a fll\•i, onmef't ... settln.gs- - - - - - - - - - - - -
Ao usar u111 Genetol v,sual Studio proje(ts '°'4Uon:
Docurre<b 10:1p.x,.tnents êlf'ld Soetth9>\0i.n:in'lla\My OONrrents\V6Ua Browse .•• 1
conzputador Dyrw d: Het>
Fonts êtdcoto,s P' Show O\t,:,k w'ndow when buld sto,ts
novo, verifique se,npre Hei> P' Show Tosklist l'indow 1 build fnshes Mthenors
essas configurações JN:êf",WJoMI SêlU'IQi
1:ev~d Bufd ..-.d IM Optlons- - -
1' r. save chêrloes to open documeru
para salvar no ,;.
hskU:st ~1 ~ompt to SIWO chonJe,s to opeo dxu'nérts

1110,nento do r Ooo't uive <hon,Jes toopen dxunents


O !cttce Corbol
desenvolvitnento, de DfCl<tEdt o,
D.,,.,,.,.,
modo que evite a perda CJ oa(,;,base TQCA~
de alg11111as horas de CJ O<buoohi
~HlMLDes~ ~
codificação.
OK Cancel

Criando Nosso Primeiro Aplicativo Windows


Agora que você aprendeu alguns princípios básicos relativos ao uso do TDE do Visual Studio,
pode usar essas infonnações para desenvolver um aplicativo sem precisar codificar muito. Esse
exercício se concentrará no uso do próprio IDE, o que significa que irernos gerar um aplicativo
relativamente si1nples. No exemplo, criaretnos um aplicativo Windov.rs (u1n aplicativo que usa a
interface co1n o usuário do Windows e é executado locahnente e1n sua máquina) que pennite ao
usuário inserir dois números. Em seguida, o aplicativo adicionará os números, exibindo o resul-
tado final.
54 Dia 2

Crie o Projeto
Nos 1nenus, selecione os con1andos File, New e Project, apresentando assim a caixa de diálogo
New Project. Na categoria Visual Basic, selecione o ícone Windows Application e altere o nome
do projeto de Wi ndowsApp 1 i cat i on (x) - o nome-padrão numerado - para Adder (a menos que
você seja Ílnportunado por intro,netidos, situação na qual poderá no,near o projeto da ,naneira
que quiser). O novo projeto já terá um formulário, que é tudo de que você precisa para começar a
trabalhar no aplicativo. O Visual Studio criará auton1atican1ente u1na pasta Solution para anna-
zenar seu projeto novo, também dando o nome de Adder a ela. Dê u,n clique em OK depois que
tiver inserido os nomes corretos do projeto e da solução.

Desenvolva a Interface com o Usuário


Você precisa de três caixas de texto e apenas u,n botão no formulário. A posição não é assi,n tão
i,nportante, ,nas você pode desejar que sua interface tenha u,na aparência se,nelhante àda Figu-
ra 2.24. Dê um clique duplo e1n Form I no Server Explorer, trazendo-o para a janela de projeto no
centro do IDE. Agora, co1n o formulário no modo Design, selecione ou abra a janela Toolbox.
Essa janela, que 1nostrará todos os objetos disponíveis que pode,n ser colocados e,n seu fonnulá-
rio, conté,n um controle TextBox e um controle Button. Para inserir tun desses controles em seu
formulário, dê u,n cl ique nele e arraste-o para a posição correta. Quando ele estiver no fonnulá-
rio, selecione o controle e use suas alças para redimensioná-lo até a forma e ta1nanho desejados.
Trabalhe co,n o redi,nensionamento e a posição desses controles até que consiga que todas as
três caixas de texto e o único botão esteja,n no formulário com a aparência do exe1nplo (Figura
2.24). Depois que tudo estiver posicionado, altere algu,nas propriedades desses controles.

- lf X
FIGURA 2.24
Organize as três caixas
de texto e o único
botão e111 seu • • • i • •

for111ulário para que D D •

tenha111 uma aparência


se,nelhante a esta
figura. . . ....

jFJo

• • •
.. c;J t.oca1s •· · · r========. Oi©Ft311Ãi'ffl&·+%'m fJBiorí!,WllãlPtRfi 0 1.stt0st
...... !
Trabalhando com o Visual Basic .NET 55

Selecione a pri1neira caixa de texto (a mais próxi1na da parte superior do fonnulário) e exiba aja-
nela Properties (pressione F4 ou selecione View e Properties Window no menu, se a janela já
não estiver visível). Várias propriedades diferentes serão listadas, 1nas você só irá alterar duas
delas:
• Text (no grupo Appearance) Representa o conteúdo da caixa de texto. Exclua o conteú-
do desta propriedade para fazer con1 que a caixa de texto fique vazia quando o progra1na
for iniciado.
• (Na,ne) (no grupo Design) No código, você se referirá a essa caixa de texto usando o
nome desta propriedade, que tem co,no padrão u,n no1ne relativa,nente irrelevante, como
Text2 ou Textl. Neste exemplo, altere para txtFirstValue.
Continue com as outras duas caixas de texto, deixando sua propriedade Text e,n branco e alte-
rando seus nomes para txtSecondVa l ue e txtResul t , respectivamente.
Agora selecione o botão para exibir seus atributos na janela Properties. Você também alterará
son1ente dois valores desse objeto, (Name) para btnAdd e Text para Add.
Para concluir, só porque tem esse recurso, você alterará uma das propriedades do próprio formu-
lário. Selecione o for1nu lário (dê um clique em algu1n local dele que não seja outro objeto) e role
pela lista de propriedades para encontrar a propriedade Text no grupo Appearance. Para tnn for-
mulário, essa propriedade representa seu título (o texto exibido na barra de título), o qual podere-
tnos configurar como Simple Adder no exen1plo.

Executando o Projeto
Mesmo se você não tiver inserido um código, o projeto poderá ser executado da 1naneira coino se
encontra. O TDE do Visual Studio permite que o progra1na seja processado dentro dele, se1n a
existência de um progra1na executável (u1n arquivo .exe, por exemplo). É possível processar ra-
pida1nente o trecho de código necessário durante o desenvolvin1ento e, o que é mais importante,
executar várias tarefas de depuração enquanto o progra1na estiver sendo processado. Mais infor-
mações sobre os apl icativos de depuração serão fornecidas no Dia 6, 1nas, por enquanto, é essen-
cial observar que há uma diferença entre processar seu código no IDE e gerar um arquivo
executável real. A criação de um executável, ou outro tipo de arquivo de resultado de seu proje-
to, é cha1nada de construção e será abordada na próxi1na seção.
Para executar um projeto no JDE, selecione Start no menu Debug, pressione f5 ou use o botão da
barra de ferramentas que se parece con1 un1a seta para a direita (ou con1 o botão de reprodução de
um videocassete). Tente isso agora, co1n o projeto Adder que você já abriu, e verá o formu lário
sobre o IDE do Visual Studio. Mesmo se1n que tenha sido escrita uma única linha de código, o
fonn ulário parecerá bern funcional. Ele poderá ser arrastado pela tela e 1nini1nizado, tudo por causa
do .NET Fra,nework e do IDE subjacentes que perrnitem a criação visual de u1na interface coi.n o
usuário e produzem o código necessário para fazê-la func ionar.
156 Dia 2

E1nbora você nã.o tenha escrito nenhum código, uma coditicação extensa já foi gerada pelo IDE,
e é ela que é executada quando o projeto é processado.

Construindo o Projeto
Construir um projeto é a criação de u,n executável ou outros arquivos de resultado. Para un, apli-
cativo Windo'vvs co1no o do exemplo, isso significa a co,npilação de seu código em u1n arquivo
.exe que possa ser executado fora do IDE do Visual Studio. Essa é u,na etapa essencial se você
pretende que um projeto seja usado por outras pessoas que não sejatn desenvolvedores, embora
possa ser evitada durante o desenvolviinento pela execução dentro do JDE.

Configurações para a Construção de Projetos


Para construir utn projeto, selecione Build no menu Build (não são nomes tnuito criativos para
os menus, mas são fáceis de entender), que parecerá ser de muito pouca utilidade. Sem fornecer
1nuito em tern,os de infonnação, as configurações-padrão de Build criaran, um arquivo
Adder. exe, inserindo-o no subdiretório bit1 da pasta de seu projeto. A ,nenos que você tenha op-
tado por personal izar o ca1ninho exibido quando criou este projeto, ele deve estar localizado e,n
My Documents \ Visual Studi o Projects \Adder, e o arquivo executável em \bi n\Adder. exe den-
tro desse diretório. Para exan, inar todas essa configurações-padrão, e, quetn sabe, alterá-las, dê
um clique coin o botão direito do mouse en1 seu projeto na janela Solution Explorer e selecione
Propetties no ,nenu suspenso que aparecerá. A caixa de diálogo das propriedades de seu projeto
contém várias configurações, ,nas as que são relevantes para o processo de construção estão des-
critas a seguir.
En1 Co1n1non Properties\General:
• Assernbly na1ne Este valor fornece a pritneira par1e do notne do arquivo de seu arquivo
de resultado. No caso do exe,nplo, ele é Adder, portanto, Adder. exe fo i criado. Altere-o
para MyAdder, e MyAdder. exe será criado quando você iniciar a construção.
• Output type Informa ao ID.E que tipo de arquivo será criado na construção deste proje-
to, com a extensão .exe se Windows Application ou Console Application for selecionado,
ou .dll, se Class Library for selecionado.
• Startup object Indica a parte do projeto que deve ser executada por padrão quando o
aplicativo for processado. No exen1plo, ela deve ser Adder. Forml para indicar que o for-
1nulário deve ser executado de 1naneira automática. Observe que, se você alterar·, n1esmo
temporariamente, Output Type de Windows Application para qualquer outra opção, essa
propriedade também será 1nodificada e pode acabar configurada de modo incorreto.
Cancele todo o processan1ento da caixa de diálogo de propriedades do projeto (dando u1n clique
no botão Cancel na parte inferior do formulário) se você perceber que alterou algo que não sabe
. .
como corr1g1r.
Todas as configurações de Co1nmon Properties\Version são armazenadas nos arquivos de saída
quando o projeto é construído, e ficarn visíveis como parte das infonnações das propriedades do
Trabalhando com o Visual Basic .NET 57

arquivo executável final (veja a Figura 2.25). Enquanto você estiver aprendendo o Visual Basic,
as infonnações inseridas nessa caixa de diálogo pode1n ser irrelevantes, 1nas, quando criar u1n
aplicativo que será distribuído para os usuários, é recomendável levar em consideração as infor-
mações dessa página con, muito cuidado. No mínirno, ce1tifique-se de que inseriu os nún1eros
corretos das versões na página porque eles fornece1n um n1étodo conclusivo para os usuários ve-
rificaren, que versão de um aplicativo possuen,.

Accesslbllity.dll Propc:rtles 6 EI
FIGURA 2.25
Quando você visualizar
I
Genc,ol Ve,,ion Soourly j S""'""'? j

as propriedades de uni Fie venicn: 1.0.2914.16

arquivo executável ou
DLL, poderá exa,ninar
todas as informações Other vewsion irlonnalbn
especificadas antes ele
sua construção.
Í Item name:
COfl"fTICflts
Value:
..,,..---,-,::---.--~
Miero.sofl CClfporbtion

Internal Name
L""ll°*
LogolT1odcmOl1<,
Orígnal File""""'
ProdJct Name
Procb:.IVei,ion

E1n Co1nn1on Properties\Build, apesar do nome, encontramos apenas uma propriedade que é cla-
ra,nente relevante para o processo de construção. O valor de Application lcon determina a apa-
rência do arquivo final .exe no Windows e pennite que você selecione o arquivo de ícones (.ico)
que desejar.
En1bora não sejam as únicas configurações adicionais que afetan1 a construção, os últi1nos itens
que mencionarei estão em Configuration Properties\Build. Nesse local você encontrará várias
configurações relacionadas com a depuração, assim como a configuração de Output Directory,
que determina onde o arquivo executável ou outros que forem criados serão posicionados.

Outras Configurações de Construção


Na pa1te superior da caixa de diálogo Project se encontra un,a lista suspensa chamada Configu-
ration. O Solution Configurations é utn recurso útil do l DE do Visual Studio, que permite que
você crie 111ais de u1n grupo de configurações para o 1nes1no projeto. Por padrão, duas configura-
ções são fornecidas (Release e Debug), projetadas para indicar se estão sendo construídos resul-
tados para fins de teste (Debug) ou para desenvolvi1nento real (Release). As definições para
essas configurações-padrão são um botn exemplo da finalidade do Solution Configurations, que
define o status de vários recursos de depuração e até de u1n local diferente de resultado para cada
um deles.
158 Dia 2

Com o Configuration Manager (veja a Figura 2.26), você poderá criar quantos grupos diferentes
de configuração ou até 1nes1no retnover u,na existente. Por enquanto, será preferível deixar as
configurações co1no estão, selecionando a versão Release do resultado quando estiver itnplan-
tando o projeto, e Debug no teste.

Conflguration Manager E3
FIGURA 2.26
Active Solution ConRguratlon:
O Configuration
Al/anager per111ite que jOebug 3
Project Cootexts (checkthe projed conligurations to búld or deploy):
você crie co,?figurações
Pro ect Conf ation Pl&tform Build
diferentes para
Adder
.finalidades distintas
(1es1e, depuração,
aceitação do usuário,
liberação e outras),
cada urna podendo ter
configurações
diferentes no ,nenu dose I Help
Build.

Criando um Arquivo Executável


A 1nelhor n1.aneira de entender um recurso do IDE é usando-o, o que significa que é hora de cons-
truir o projeto do exemplo e produzir um arquivo executável. Dê um clique na opção Build do
menu de mesmo no1ne, e verá uma informação piscar rapidamente na janela Output (exibida na
parte inferior de sua tela, se você não a tiver 1nudado de lugar). Se tudo correr bem e não houver
erros em nenhum código que tenha sido adicionado ou alterado, o processo de construção produ-
zirá um arquivo executável. Esse arquivo, que foi chamado de Adder . exe, será criado no subdire-
tório bin da pasta de seu projeto (por padrão, My Documents\Visual Studio Projects\Adder).
Minimize o IDE do Visual Studio, use o Windo'vvs Explorer para encontrar o arquivo e, en1 se-
guida, dê u1n clique duplo nele para executar seu aplicativo Windows recém-criado. O forrnulá-
rio, com suas diversas caixas de texto e botões, aparecerá para mostrar que o progra1na está
sendo processado e continuará a ser até que esse mesrno formulário seja fechado. Esse arquivo
executável, junto com o .NET Frainework, é tudo que é necessário para fazer a distribuição para
a 1náquina de u1n usuário de 1nodo que esse possa executar seu progran1a.

Adicionando Seu Próprio Código


Até aqui, o exe1nplo do projeto e1n que você esteve trabalhando continha apenas o código gerado
pelo lDE do Visual Studio, que tem sido ótimo para mostrar o fonnulário, mas não faz mais
nada. Como já deve ter sido percebido pelos nomes e layout do forn1 uiário, esse aplicativo adi-
cionará valores à primeira e segunda caixas de texto e colocará o resultado ern uma terceira e úl-
ti1na. Para tanto, será preciso acrescentar um código ao projeto que será executado quando o
usuário der um clique no botão Add.
Trabalhando com o Visual Basic .NET 59

O uso do IDE faz com que esse processo seja 1nuito direto: dê un1 clique duplo no formulário do
Solution Explorer para assegurar que a visualização do projeto esteja ativada e, em seguida, dê
um clique duplo no botão Add. lsso o conduzirá para a visualização do código do formulário e a
uma sub-rotina que fo i ad icionada pelo IDE. U1n controle, como esse botão, caixas de texto ou
outros componentes do formu lário, pode ter eventos associados a ele. A maioria dos eventos de
un1 controle representa ações
,
executadas neles como serem clicados, clicados duas vezes, selecio-
nados e desmarcados. E possível criar procedünentos que serão executados quando uLn desses
eventos ocorrer e, por padrão, esses procedi1nentos são designados pelo seu nome (o no1ne do
controle, btnAdd, seguido do evento, Cl i ck). Poden1-se associar procedimentos a eventos, inde-
pendente1nente de seus nomes, mas neste caso, o procedimento bt nAdd _Cl i ck será executado se
o usuário der um clique no botão. É fácil testar essa funcionalidade usando utn recurso 1nuito útil
do .NET Fra1nework que fornece os fonnulários, botões, caixas de texto e outros elementos de
interface, e, po1tanto, está disponível para qualquer projeto no qual se esteja usando esses obje-
tos. A classe MessageBox permite que uma 1nensagem seja exibida em uma caixa de diálogo com
u1na única linha de código, como esta:
MessageBox . Show(''O bot ão fo i clicado'' )
Esse código exibe tuna caixa de diálogo como a mostrada na Figura 2.27. A si,nplicidade do uso
dessa classe a torna perfeita para ser e1npregada como u1na ferramenta de teste ou de depuração.
Adicione a li nha de código anterior à sub-rotina btnAdd_ Cl i ck e, e1n seguida, execute o projeto
pressionando FS. Depois que o formulário aparecer, tente dar um clique no botão. Cada clique
deve provocar o aparecimento da caixa de 1nensage1n, mostrando a você que o código de
btnAdd _Cl i ck é executado se1npre que o botão é pressionado.

FIGURA 2.27
A classe MessageBox
fornece urna 1naneira
fácil de exibir
! TestMessage !
long Process Ei
infor,nações na tela e é
8bd <tuff hoppened
e,n geral usada nas
fases de Abort ! Retoy lgna,e

depuração/ teste.

Agora que você já sabe como executar un1 código que responde ao clique em u,n botão, poderá
criar o código efetivo de seu projeto. Ele tem de sornar dois valores para produzir u.rn resultado, o
que soa 1nais fácil do que é na realidade. Os valores que quere1nos são os conteúdos de suas cai-
xas de texto, disponíveis por meio da propriedade Text desses controles, 1nas antes que possa-
mos usá-los em u1na equação n1ate1nática (so1nando-os ), ten1os de convertê-los de strings (texto)
160 Dia 2

para números. O código a seguir, se colocado no lugar da cha1nada de MessageBox, adicionada


anteriormente, fará o que precisamos:
txtResult.Text =(Cint (txtFirstValue.Text)
+Cint(txtSecondValue.Text)).ToString
Esse código converte o conteúdo das duas caixas de texto e1n números (inteiros, neste caso), faz
a soma e, e1n seguida, converte o resultado de novo para u1na string (texto) de ,nodo que ele pos-
sa ser inserido na terceira caixa de texto. São necessárias algu1nas etapas para fazer algo que apa-
rentemente é n1 uito fácil quando descrito pela primeira vez, e o resultado final pode parecer um
pouco confuso. Tudo ficará 1nais claro ao dannos prosseguimento no Dia 3, "Introdução à Pro-
grainação com o Visual Basic .NET".

Resumo
O objetivo do IDE é fornecer um ambiente no qual você possa escrever, editar, executar e depu-
rar seus progra,nas, e o do Visual Studio fornece todos esses recursos e mais. Esta lição abordou
os recursos básicos do IDE e a finalidade de cada u,na de suas janelas principais. Tambétn o con-
duziu pela criação de um aplicativo Windows simples. Daqui em diante, estare1nos usando o
IDE freqüentemente, apesar de nem se1npre trabalharmos co1n ele1nentos visuais (co1no formu-
lários e controles). Po11anto, aprendere1nos ,nais sobre ele e seus recursos o te,npo todo. .Etnbora
possa parecer um pouco confuso e cansativo agora, o IDE é a ferramenta que você usará pai·a fa-
zer sua progra1nação de 1nodo que, com o tempo, ela se tornará fa1niliar.

P&R
P Preciso usar o IDE ou posso apenas empregar um editor de texto e a linha de co-
mando?
R No Visual Basic .NET, é possível fazer qualquer coisa usando apenas a linha de co1nan-
do e u1n editor de texto, 1nas o IDE fornece u1na grande quantidade de recursos para tor-
nar o desenvolvimento u1n. processo 1nuito 1nais fácil. O lntelliSense, a estrutura das
instruções e a edição codificada e,n cores, tudo faz com que a criação de códigos seja
1nais agradável, além de ser difícil ficar se1n os recursos de depuração.
P Posso adicionar meus próprios recursos ao IDE do Visual Studio?
R Co,n certeza! O IDE dá supo1te à personalização por meio de vários métodos diferentes,
incluindo macros e complementos. Não abordarei a personalização do IDE neste livro,
,nas, por hora, exa1nine os óti1nos exemplos de 1nacros nas opções Tools, Macros e Ma-
cros lDE do 1nenu.
Trabalhando com o Visual Basic .NET 61

Workshop
O Workshop foi planejado para ajudá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e coineçar a pensar e1n como colocar seu conheci1nento em prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".

Teste
1. Se você quisesse ver todos os arquivos que fazem parte de seu projeto, que janela do IDE
. ?
usaria.
2. Qual é o local-padrão dos novos projetos do Visual Studio?
3. Como você pode escolher un1 ícone para un1 aplicativo que esteja desenvolvendo no Vi-
sual Studio?
4. Se a janela Comn1and estiver no modo lmmediate, como posso passar para o modo Com-
1nand e depois voltar?

Exercícios
Exata1nente co1no você fez nesta lição, use a classe MessageBox para adicionar mensagens ao
procedimento de outros eventos e verifique quando forem chamados. Tente selecionar txtRe-
sul t na primeira lista suspensa da janela de edição de códigos e, etn seguida, TextChanged, na
segunda lista para trabalhar co1n esse evento.
SEMANA 1

DIA

Introdução à Programação com o


Visual Basic .NET
Agora que você se fa1niliarizou com o ambiente .NET de desenvolvi1nento, é hora de começar a
escrever códigos. E1nbora co1n o Visual Basic .NET seja fác il escrever um progra1na sin1ples
sem o uso de muita codificação, 1nesmo se for 1nais simples que uma versão de demonstração,
ele precisará manter o registro das informações e executar cálculos elementares e tarefas se1ne-
lhantes. Para escrever códigos que executem essas tarefas, será necessário um bo1n conheci1nen-
to sobre variáveis. Por meio da co,npreensão do emprego e dos tipos de variáveis, é criada a base
para assi1nilação do Visual Basic .NET. De maneira parecida, exata1nente como quando inicia-
1nos o aprendizado da arittnética simples, precisare1nos aprender alguns operadores funda1nen-
tais que podem ser utilizados no trabalho com variáveis nu,néricas e alfanuméricas. Nesta lição,
você aprenderá:
• Os tipos de variáveis que pode criar co1n o Visual Basic .NET.
• Alguns operadores e funções si1nples disponíveis no Vi.s uai Basic .NET.
• Os princípios básicos para escrever códigos no Visual Basic .NET, inclusive co1no desen-
volver procedimentos.
64 Dia 3

Variáveis e Atribuição
Variáveis e atribuição são a base de toda Iinguagern de programação. As variáveis pertnitetn que
você annazene infonnações para uso posterior e a atribuição é a rnaneira de inserir informações
., .
nas vanave1s.
,
O Que E uma Variável?
U1na variável é um depósito. E' um local para guardar as informações até que sejam necessárias.
Você usará variáveis e1n toda a extensão de seus programas para reter valores temporários du-
rante os cálculos, annazenar entradas do usuário e preparar as infonnações que serão exibidas
posteriormente para eles.

Tipos de Variáveis Disponíveis


Exata1nente co1no acontece com as calças, só um tamanho não atende a todas as variáveis.
Embora seja possível criar,
e usar u1na variável que seja capaz de conter o que for, essa netn sem-
pre é a n1elhor solução. E fácil deduzir que u1na variável que conté1n strings deve executar algo
diferente de outra criada para annazenar nú1neros. Além disso, mesmo tipos diferentes de nú1ne-
ros requeren, tipos distintos de variáveis. Alguns nú1neros, como l ou 5280, não possuem casas
decimais, enquanto 3, 14159265358979 e 16,50 apresentan1 essa característica. Uma variável
gerada para conter u1n nú1nero deciinal deve ter uma maneira específica de 1nanter o registro dos
valores depois da vírgula. ·E' claro, que isso significa que os nú1neros decimais provavebnente
consu1nirão tnais me1nória. Sempre que un, co1nputador ou programa realiza um trabalho 1naior,
e1n geral precisa de 1nais me1nória. Portanto, é impo11ante le1nbrar não só do tipo de informação
que você precisa arn1azenar, 1nas trunbém do espaço da 1nernória que o computador terá de rnani-
pular para registrar a variável.
f-lá três tipos abrangentes de variáveis que você pode criar co1n o Visual Basic .NET. O primeiro
conjunto engloba as variáveis que armazena1n valores sitnples, como números ou strings. Há
muitas desse tipo, cada uma foi projetada para conter valores de vários ta1nanhos. A segunda ca-
tegoria é a das variáveis complexas, que contêrn alguma con1binação de variáveis simples e in-
cluem arrays e tipos definidos pelo usuário. Os arraJ1s são variáveis que annazenrun muitas
outras, e os tipos definidos pelo usuário pennite1n que o usuário crie novos tipos de variáveis. A
terceira categoria é a das variáveis de objeto.
Os tipos definidos pelo usuário (também conhecidos como estruturas) e as variáveis de objeto
serão abordados no Dia 7, "Trabalhando com Objetos". A discussão desta lição se concentrará
nas variáveis si1nples e arrays.
Introdução à Programação com o Visua l Basic .NET 65

Variáveis Simples
Como descrito anterionnente, os tipos simples de variáveis 'armazena,n ' valores como nún1eros
e palavras. Po11anto, você pode achar que só é necessário existir dois tipos de variáveis: de nú-
1neros e de palavras. Porém, na verdade, há vários tipos diferentes de variáveis simples - cada
um criado para annazenar ta1nanhos ou tipos distintos de nú,neros ou strings.
Tente usar o melhor tipo de variável para a situação. Etn algu,nas vezes, só será preciso ,nanter o
registro de um número pequeno - por exemplo, se estiver armazenando os 1neses do ano. Em ou-
tras, terá de trabalhar co,n nú1neros grandes - por exen1plo, se estiver escrevendo um programa
que execute cálculos científicos ou de engenharia.
As variáveis simples pode1n ser divididas em quatro subgrupos. O primeiro e maior é o dos intei-
ros, números que não possuern casas decimais. O segundo grupo é usado para n(uneros com ca-
sas deci1nais. As strings e os caracteres compõem o terceiro grupo, e o quarto seria melhor
descrito co1no 'diversos'. Exam inemos cada u,n desses grupos e veja,nos quando qual é apro-
priado usar e,n que situação.

Variáveis de Inteiros

Novo TERMO
As variáveis de inteiros (integer) armazena1n os conhecidos núrneros inteiros (isto é,
nún1eros sern casas decilnais). Essas variáveis são as que você usará com 1nais fre-
qüência nos progra,nas e as mais fáceis para os con1putadores tratar. Por causa dessa co,nodidade,
elas deve1n ser seu tipo preferido quando for preciso trabalhar com números. A Tabela 3.1 rnostra
diversas variáveis de inteiros diferentes, cada uma foi criada para annazenar núrneros de tama-
nhos distintos e para e,npregar quantidades diferentes de me,nória. A quantidade de me1nória uti-
Iizada é ,nedida en1 bytes. (Un, byte contém oito bits, o que é apenas u,na n1aneira técnica de dizer
que cada byte possui oito algarismos um ou zero, ou uma combinação de uns e zeros.) Embora
não haja problema em usar uma variável projetada para conter valores maiores do que o necessá-
rio, ela consu1nirá mais memória. Alé.m disso, pode fazer com que seu progran1a seja executado
1nais lentamente porque teria de manter registros de seções maiores da 1nemória, mesrno que es-
sas nunca fossem utilizadas.
1 66 Dia 3

TABELA 3.1 Tipos de Variável de Inteiros

Tipo Tamanho
Abrangência Comentários
de Dado (Bytes)
Byte 1 O a 255 Um pouco limitado e, diferente dos ou-
tros tipos de dados inteiros; o Byte não
dá suporte a números negativos. Isso
acontece porque ele representa o valor
que o con1putador realmente arn1azena
en1 cada byte da me1nória. Para armaze-
nar números negativos, o computador
usa utna parte de cada byte para guardar a
porção 'negativa' . Útil quando se man-
têm registros de nú1neros pequenos que
nunca são negativos, como os dias de u1n
1nês ou os 1neses de um ano.
Curto 2 -32.768 Uma variável de inteiros pequena e práti-
(Short) a ca. Você pode usar u1n tipo curto sempre
32.767 que não precisar de todo o intervalo de um
tipo inteiro, por exetnplo, se estivesse es-
crevendo uin programa para contar a quan-
tidade de empregados de uma empresa que
só tivesse alguns miU1ares de funcionários.
Inteiro 4 -2.147.483.648 A variável de inteiros-padrão. En1 geral, o
(Integer) a inteiro é o tipo 1nais veloz de variável para
2.147.483.647 se usar, já que ele requer menos traball10
do con1putador. Utn en1prego para esse
tipo de variável seria registrar a quantida-
de de ovelhas da Nova Zelândia (aproxi-
1nadan1ente 47.394.000 em 1997).
Longo 8 - 9.223 .3 72.036. O tipo de variável perfeito para esta épo-
(Long) 854.775.808 ca en1 que estamos trabalhando com nú-
a meros 1nuito, n1uito grandes (isso
9.223.372.036.8 sign ifica -9 quintilhões a +9 quintiU1ões
54.775.807 ou aproximadan1ente 9 x 10 18 para a n1a-
nutenção de registros). Um tipo longo se-
ria útil se você estivesse annazenando a
quantidade de estrelas no universo (esti-
mada em cerca de 1022).

Números com Casas Decimais


U1na grande quantidade de processan1ento nu1nérico é realizada sern casas decimais. No entan-
to, mais cálculos, principalmente ern engenharia, finanças e ciências, requerem que você tam-
bém possa arn1azenar valores decin1ais. A Tabela 3.2 descreve os dois principais tipos de
variáveis decimais. Decidir qual usar depende do grau de precisão que for necessário n1anter, ern
vez do tamanho dos valores, já que todos eles pode1n ter nú1neros bastante grandes. Caso não se
Introdução à Programação com o Visua l Basic .NET 67

lembre da notação científica que aprendeu na escola, o número sobrescrito acima do algaris1no
1Oé a quantidade de vezes que é preciso 1nultiplicar por 10 (se positivo) ou dividir por 1O(se ne-
gativo). Portanto, 106 é l O seis vezes ou 1.000.000, e l o·6 é igual a 0,000001.

T ABELA 3.2 Tipos de Variável Decimal

Tipo Tamanho
Abrangência Comentários
de Dado (Bytes)
Simples 4 - 3 402823 x 1O'~a Não se preocupe muito co1n o ta-
' 5
(Single) - 1,401298 X 10"' manho desses nú1neros do interva-
para números negativos; lo. O tipo si1nples pode manter o
1,401298 x lO"'s a registro de números 1nuito grandes
3,402823 x l0 3i (ou muito pequenos). O importante
para nú1neros positivos para este tipo de dado é a precisão.
O nome 'sirnples' quer dizer que
este tipo de variável é para nú,neros
con1 ponto flutuante de prec;são
sin1ples. Esse é o significado do jar-
gão da infom1ática: "Ele só é real-
mente bom para am,azenar sete
dígitos in.1po1tantes". Examine cada
urn dos números do intervalo.
Observe que possuem um nún1ero
antes da casa deci1nal e seis a se-
guir, mais o expoente (o número
aci1na do algarismo IO). Portanto,
embora o tipo si1nples seja bom
para armazenar tanto números
grandes quanto pequenos, não é tão
preciso quanto os outros, e poderia
causar e1Tos de an·edonda1nento se
você fizesse n1uitos cálculos com
valores realmente altos ou muito
baixos. O tipo de variável simples
seria útil em u1n progra1na em que
menos exatidão fosse necessária.
Duplo 8 - 1,7976931348623 l X O tipo duplo é uma variável de
(Double) 10308 a-4,94065645841247 'ponto flutuante com precisão du-
x 10··12• para nútneros nega- pla', portanto, armazena duas ve-
tivos; 4,94065645841247 zes mais dígitos significativos que
12
X 10· •a) ,79769313486232 o tipo sin1ples ou 15 casas deci1na-
x 10308 para nú1neros is. Use um tipo duplo sempre que
positivos você fizer cálculos com números
grandes ou quando quiser evitar os
erros de arredonda1nento que podem
acontecer no tipo si1nples, como ao
efetuar cálculos em aplicativos cien-
tíficos ou de engenharia.
168 Dia 3

Strings e Caracteres
Os números são adequados se você precisa annazenar quantidades ou espaços de te1npo, mas
con1 freqüência também é necessário lidar com palavras na programação. O Visual Basic .NET
fornece variáveis para annazena1nento de strings: os tipos de dado Char e String. O tipo Char é
apropriado para o annazenan1ento de apenas u1n caractere (daí o norne), enquanto o tipo String
pode conter strings de co1nprimento 1naior. A Tabela 3.3 descreve os dois tipos de dados co1n
mais detalhes.

TABELA 3.3 Tipos de Variáveis de Strings

Tipo Tamanho
(Bytes) Abrangência Comentários
de Dado
Char 2 Um caractere Adequado para armazenar um único carac-
tere.
String 10 + 2 Até dois Use um tipo String para annazenar aquele
por bilhões de romance que sen,pre quis escrever. Se esti-
caractere caracteres ver calculando cinco caracteres em média
por palavra e 250 palavras por página, sai-
ba que uma única variável alfanumérica
pode conter 1,7 1nilhão de páginas de texto.

Por que cada tipo Cha r e cada caractere de um tipo String ocupa1n dois bytes? Afinal , há apenas
25 caracteres usados no idio1na português, alén1 dos n(nneros e símbolos-decerto, você não pre-
cisa de dois bytes (65.536 valores possíveis). Não precisaria, se todas as linguagens empregas-
se1n o mesmo conjunto de caracteres.

Novo TERMO O cenário é o que o conjunto de caracteresASC// (ou ANSI), popular no passado, de-
finiu. E111 ASCll, wn byte é igual a u1n caractere, e todos os con1putadores que usa-
van1 essa linguagem sen1pre dispunham os mesinos caracteres na mesma posição da lista.
Portanto, o valor 65 e1n ASCif era sempre a letra 'A', e o sín1bolo '@' possuía valor igual a 64. Se
você quisesse fazer o 1nesmo com todos os outros símbolos que as pessoas usam na escrita, no en-
tanto, precisaria de 1nais caracteres. Para resolver esse problema, um novo sistema fo i desenvolvi-
do, chamado Unicode.

No Unicode, cada caractere é representado por dois bytes. Isso pennite o armazena1nento de to-
dos os caracteres da lista ASCII, bem como os dos idio1nas russo, grego, japonês e tailandês, os
dos matemáticos e assim por diante. E1n Unicode, 65 ainda representa a letra ' A' , 1nas 8800 é o
caractere Imi . O caractere japonês Hiranaga "ID'>}• ('não') é representado por 12398. O Visual
Basic .NET usa os valores Unicode para todos os caracteres, po1tanto o tipo Cha r usa do.is bytes,
e cada caractere de u1n tipo String acrescenta dois bytes de espaço co1nple1nentar de annazena,.
mento.
Introdução à Programação com o Visua l Basic .NET 69

Outros Tipos de Variável Simples


Nunca falha quando se tenta categorizar as coisas. Algo sen1pre desafia a categorização (apenas
imagine o primeiro zoólogo que se deparou com o ornitorrinco). Da mesma 1naneira, há algumas
variáveis que não se encaixa,n ben1 nas categorias descritas anteriorn1ente. No Visual Basic
.NET, existem dois desses tipos de variáveis 'diversas', o tipo booleano (Boolean) e a data
(Date). Eles são descritos co1n 1nais detalhes na Tabela 3.4.

T ABELA 3.4 Tipos Diversos de Variáveis Simples

Tipo Tamanho
Abrangência Comentários
de Dado (Bytes)
Booleano 2 Verdadeiro Se está annazenando apenas verdadeiro ou
(Boolean) (True) ou falso falso, para que dois bytes? O Visual Basic
(Fa 1se) tem usado tradicionahnente Oe - 1 para falso
e verdadeiro. Definir esses dois valores re-
quer dois bytes.
Data 8 1° de janeiro Esta variável pode conter a maioria das datas
(Date) de 100 a 31 de com as quais você lidará (a menos que seja
deze,nbro de um hjstoriador ou geólogo). Ela tambén1 se-
9999 gue todas as regras do calendário (co1no adi-
cionar u1n dia em anos bissextos), po1tanto,
se acrescentannos 1 ao valor '28 de feverei-
ro de 2000' da variável de data, obteren1os
'29 de fevereiro de 2000', ,nas se fizennos o
1nes1n.o para '28 de fevereiro de 2001 ', ares-
posta será ' 1º de n1arço de 2001 ' . A única li-
1nitação efetiva da variável de data é seu
ta1nanho.

Você poderia usar outro tipo de dado para armazenar datas como strings ou in-
NOTA teiro representando o período em dias após alguma data específica.

Declarando Variáveis
Agora que você conhece os tipos de variáveis disponíveis, co1no criá-las em seus progra,nas? A
1naneira 1nais sitnples é com a palavra-chave Oi m (abreviatura de 'Dimensão'), seguida pelo
no1ne da variável, a palavra-chave As e, por fi1n, pelo tipo da variável. A aparência é a seguinte:
Dim iAl gumNumero As Integer
Isso criaria a nova variável i Al gumNumero, que possui quatro bytes e pode an11azenar u1n nú1nero
com um ta,nanho aproximado a 2 bilhões. Veja algumas declarações de variáveis possíveis:
70 Dia 3

Dim sPrimeiroNome As String


Dim dblProdutointernoBruto As Double
Dim bAprendido As Bool ean
U1n recurso novo no Visual Basic .NET é a capacidade de fornecer um valor à variável quando
ela estiver sendo criada. Faça isso usando a mesma linha da instrução Dim:
Dim dtDataDeAssinaturaDaCartaMagna As Date =#June 15,1215#
Dim lPessoasNaTerra As Long = 6000000000
Examinare1nos algu1nas outras maneiras de declarar variáveis posterionnente, quando discutir-
mos o escopo.

Arrays
A capacidade de uma variável de annazenar qualquer coisa é prática e até rnesrno essencial em
progra1nação. No entanto, você pode precisar armazenar vários itens relacionados. Por exernplo,
se estivesse escrevendo urn prograrna de jogo de xadrez, os quadrados do tabuleiro precisariam
ser representados co1no um conjunto de itens relacionados. Use os arrays para criar variáveis
que annazene1n juntos todos os itens relacionados. No programa do jogo de xadrez, o tabuleiro
provavelmente seria armazenado como um array de posições, cada un1a contendo o tipo de peça
(ou nenl1uma) dessa posição. Se não fosse usada u1na variável de array, teriam de ser e1nprega-
das 64 variáveis separadas. Tambén1 pode ser preciso 1nanter o registro de urna lista de strings,
por exernplo, dos no1nes dos alunos de uma sala. Se1npre que for 11ecessário ar1nazenar uma lista
de itens, use um array.
Como na declaração das variáveis si1nples, a de urn array é feita con1 a palavra-chave Oi m. No
entanto, há algu1nas diferenças entre declarações de variáveis siinples e declarações de arrays
porque esses são conjuntos de variáveis. A Listagem 3.1 mostra três 1naneiras possíveis de de-
clarar arrays.

CÓDIGO LISTAGEM 3.1 Dec 1arando Arrays


1 ' Declaração simples
2 Dim iValues(3)As Integer
3 Dim dtDates()As Date
4 Dim I As Integer
5 For I =l To 3
6 iValues(I-l)=I
7 Next

8 ' Alterando o tamanho de um array existente


9 ReDim dtDates(4)
10 'preencha a lista de datas
11 dt0ates(O)=''l5/6/1215'' 'Assinatura da Carta Magna
12 dtDates(l)=''28/8/1962'' 'Martin Luther King Jr. pronuncia ''Tenho um sonho''
Introdução à Programação com o Visua l Basic .NET 71

CóDIGO LISTAGEM 3.1 Declarando Arrays (continuação)


13 dtDates(2)=''20/7/1969'' 'A Apollo 11 aterrissa na Lua
14 dtDates(3)=''14/2/1946'' 'ENIAC revelado ao püblico
15 'Declaração com Inicialização
16 Dim sMonths()As String ={''Jan'', ''Fev'',''Mar'' ,''Ab r'',''Maio'', ''Jun'',
17 "Jul ", "Ago", "Set", "Out", "Nov" , "Dez"}

18 ' Usando arrays


19 Console . Writeline('''' )
20 Console . Writeline(''Segundo valor em iValues = {O}'',iVa lues( l))
21 Console . Writeline(''Terceira date em dtDates = {O}'',dtDates(2))
22 Console . Writeline("Décimo primeiro mês do ano= {O}" ,sMonths(lO))

ANÁLISE No primeiro exemplo, i Va 1ues foi declarada como un1 array de três me,nbros. To-
dos os itens do array são inteiros (I nteger). Tudo faz sentido. A pa1te potencialmen-
te confusa está na 1naneira usada para fazer referência a cada 1ne1n bro do array. lsso é mostrado no
laço For ... Next que vai da linha 5 à 7 (abordare,nos o laço For ... Next no próxi1no capítulo).
Observe que os três membros do array estão numerados de Oa 2. Portanto, o segundo tnembro do
array está na posição l, e não 2.

NOTA
- Vale a pena ressaltar que os computadores, diferente das pessoas, sempre co-
meçam sua contagem com o zero. É melhor deixar a verdadeira razão disso
nos recônditos de suas minúsculas mentes de silicone, mas precisamos estar
conscientes desse detalhe, principalmente no que diz respeito a arrays.

O segundo array criado, co1n os 1neses do ano, foi declarado e inicializado. Exatamente cotno
você pode inicial izar variáveis si1nples quando as declara, é possível fazer o 1nesmo co,n arrays.
Nesse caso, no entanto, coloque cada ele1nento do array em uma lista delimitada por vírgulas,
envolvida e1n chaves, cotno 1nostrado na linha 16. Isso criará um array de 12 membros, com cada
ele1nento contendo u1na string. Le1nbre-se, contudo, de que se quiser se referir a cada um, eles
estarão nun1erados de O a 11 - portanto, sMonths(lO) seria "Nov" , e não "Out".
A últi1na declaração é de Lnn array dina1nica1nente di1nensionado. Esse array pode depois serre-
di1nensionado para o tamanho correto com a palavra-chave ReDim co1no 1nostrado na linha IO.
Co1no nos outros tipos, os itens do array dinâ1nico estão nun1erados de zero a I menos 1. Depois
que o array for dimensionado, você poderá usá-lo co1no qualquer outro. Esse tipo de declaração
é útil se o ta1nanho do array depender do valor de outra variável, portanto, isso não seria conheci-
do até o te1npo de execução.
72 Dia 3

Tenho repetido o fato de que todos os arrays começam com O no Visual Basic
ALERTA .NET porque, anteriormente, o Visual Basic podia não ser operado dessa ma-
neira. Em suas versões anteriores ao Visual Basic .NET, você poderia usar a de-
claração Opt i on Base 1 no início de um módulo para assegurar que todos os
arrays criados nele começassem em 1. De modo alternativo, ao declarar ar-
rays, seria possível definir os membros inicial e final do array, como será mos-
trado na declaração a seguir. Nenhuma dessas opções está disponível para os
arrays do Visual Basic .NET.
Portanto, a linha de código a seguir não é válida no Visual Basic .NET:
Oim sngValues(l5 To 5l)As Single

Atribuição
A atribuição foi simplificada no Visual Basic .NET. Versões mais antigas do Visual Basic (Vi-
sual Basic 4.0 a 6.0) possue1n duas 1naneiras diferentes de atribuir urn valor a urna variável -
uma para variáveis si1nples (incluindo estruturas e arrays) e outra para variáveis de objeto. Feliz-
rnente, os desenvolvedores do Visual Basic .NET decidirarn rernover o 1nétodo de atribuição
usado para as variáveis de objeto e ernpregar apenas o utilizado para variáveis simples. Você vai
atribuir valores às variáveis (simples ou de objeto) colocando-as à esquerda de um sinal de igual-
dade, como mostra o código a seguir:
iSomeVar =1234
oObjectVar =New Something()

Da versão 4.0 à 6.0 do Visual Basic, as linhas de atribuição mostradas anterior-


NOTA mente teriam aparecido com a seguinte forma:
iSomeVar =1234
Set oObjectVar =New Something
Contudo, as regras de quando usar Set eram confusas, e a Microsoft removeu
a necessidade dessa palavra-chave.

Constantes
As constantes são outra classe de valores que você pode usar em seus programas do Visual Basic
.NET. Constantes são valores que não se alteram nunca ou durante a vida útil de seu progra1na.
Por exernplo, os meses de u,n ano, o valor de pi e o servidor de banco de dados a partir do qual
seu progran1a recupera dados, todos são valores constantes. E' possível definir u1n valor co1no
constante quando ele for declarado. Qualquer tentativa de alterar o valor de urna constante será
assinalada corno um erro enquanto você ainda estiver no IDE (lntegrated Developrnent Environ-
rnent) e antes de tentar executar o aplicativo. As constantes são declaradas usando-se as duas for-
mas mostradas no código a seguir:
Introdução à Programação com o Visua l Basic .NET 73

CóDIGO Const PI = 3.1415 As Double


Const DSN As String= ''Randorn''

ANÂLISE Se o tipo da constante não for descrito e1n u1na declaração, o co1npilador terá de usar
o tipo de valor que meU1or se encaixar. No entanto, ele ne1n se1npre seleciona orne-
lhor tipo possível. E1n geral, quando constantes são declaradas, se o tipo do valor não é incluído, o
Visual Basic .NET cria os tipos de variáveis a seguir:

• Longo (Long) Para qualquer número inteiro declarado.


• Duplo (Doub l e) Para qualquer nún1ero decin1al declarado. (Observação: se o valor
for efetivamente muito grande para um tipo duplo, ele será truncado.)
• String Para qualquer valor com caracteres.

Defina o tipo que quiser quando declarar constantes, exatamente como faz
NOTA com as variáveis.

Algumas Sugestões para os Padrões de


Nomeação
Com todos esses tipos diferentes de variáveis e tantos programadores usando-os, há rnuitos no-
mes que pode1n ser empregados ao declará-las. Isso pode levar a u1n proble1na quando as exami-
nannos posteriormente. A menos que a declaração esteja visível, poderão existir dificuldades
para se conhecer o tipo da variável. De 1naneira semelhante, se o código for herdado de um escri-
to por outro desenvolvedor, pode ser preciso algu1n tempo para compreender como ele non1eou
suas variáveis. As convenções de nomeação, de preferê11cia co1npa1tilhadas, reduzem essas duas
espécies de dificuldade pela identificação do tipo da variável.
U1na convenção de nomeação nonnahnente usada é adicionar u1n prefixo e1n 1ninúsculas aos no-
mes das variáveis. O prefixo identifica o tipo de variável. A Tabela 3.5 1nostra sugestões para un1
conjunto de prefixos.

TABELA 3.5 Convenções de Nomeação Sugeridas

Tipo de Variável Prefixo Exemplo


Byte byt bytidade
Curto (Short) sht shtContagem
Inteiro (integer) i ou i nt iOvelhas
Longo (Long) I ou l ng lPopulacao
Simples (Single) sng sngGolpe
74 Dia 3

TABELA 3.5 Convenções de Nomeação Sugeridas (continuação)

Tipo de Variável Prefixo Exemplo


Duplo (doub l e) d ou dbl dblJuros
Char e clniciaislntermediarias
String s ou str sNome
Booleano b bEstaAberto
Data (Date) dt dtOataAluguel
Tipos defmidos Dois ou três caracteres iin- Variáveis criadas, co1n base em estru-
pelo usuário portantes do norne da es- turas equivalentes a u1n ponto ou retân-
tJutura gulo poderiatn ser cha1nadas de
ptloca l e retTamanho
Constantes Nenhu1n prefixo. O nome é PI, TAXA IMPOSTO
todo em maiúsculas, com
cada palavra separada pelo
caractere sublinhado U
Enurnerações Dois ou três caracteres sig- disOiaSemana, corCorFundo
nificativos

NOTA Por que essa confusão de um, dois e três caracteres? Tenho de admitir que al-
terei os prefixos que uso com o passar dos anos. Minha filosofia básica era ori-
ginalmente empregar só um caractere, para limitar a desordem que os
prefixos causam. No entanto, alguns deles só iriam provocar mais conf usão.
Por exemplo, qual seria o tipo de dado de sVa1ue? Poderia ser o curto (Short), sim-
ples (Si ngl e) ou String. Para tipos de dados que começam com a mesma letra, es-
tendi o prefixo em alguns caracteres. Devo admitir, contudo, que ainda tendo a
usar a letra s para strings porque tem sido empregada com f reqüência. (Você
tem de fazer alguns sacrifícios para evitar a síndrome do esforço repetitivo.)
Quando começar a usar esses prefixos, você pode achar que são um pouco
confusos. No entanto, eles logo se tornam familiares, e as informações que
fornecem são inestimáveis.

Cálculos Simples
Apenas
,
ter alguns valores definidos não produz um programa. Você precisa fazer algo com eles.
E necessário efetuar cálculos 1natemáticos com os valores ou gerar algo mais substancial. De
1naneira se1nelhante, para tornar seus programas mais compreensíveis, co1n freqüência será pre-
ciso usar ou criar procedimentos. O Visual Basic .NET fornecerá alguns deles; outros terão de
ser escritos. Esses proceditnentos vão de operadores, que executam muitos dos cálculos 1nate-
máticos comuns, a funções n1ais co1nplexas que poderiam afetar strings ou nú1neros.
Introdução à Programação com o Visua l Basic .NET 75

Usando Operadores
No Visual Basic .NET, os operadores executam cálculos simples e ' funções' se1nelhantes. A
maioria dos operadores deve ser fa,nifiar a você como símbolos algébricos comuns. No entanto,
alguns deles são exclusivos da progratnação. A Tabela 3.6 lista os operadores mais usados.

TABELA 3.6 Operadores Comuns do Visual Basic .NET

Operador Uso Exemplo


= Atribui uni valor a outro X =6
+ Soma dois valores Y = X + 7 (Y é igual a 13)
Subtrai um valor de outro Y = X - 4 (Y é igual a 2)
* Multiplica dois valores Y = X * 2 (Y é igual a 12)
/ Divide um valor por outro Y = X / 2 (Y é igual a 3)
\ Divide um valor por outro, n1as só retoma Y = X \ 3 (Y é igual a 1)
lUn número inteiro
Mod Abreviatura de módulo; retorna o resto de Y = X Mod 3 (Y é igual a 2)
u1na divisão
& Associa duas strings S = "Olá " & "Mundo" (S é
igual a "Olá Mundo")
+= Sí1nbolo para adicionar um valor e atribuir X += 2 (X é igual a 8)
o resultado
- Sí1nbolo para subtrair um valor e atribuir o X - = 3 (X é igual a 5)
resultado
,._
.- SinJbolo para multiplicar um valor e atribuir X *= 6 (X é igual a 30)
o resultado
/= Sín1bolo para dividir por u1n valor e atribuir X /= 5 (X é igual a 6)
o resultado
&= Shnbolo para acréscilnos a strings e atribui- S &= " , John" (S é igual a
ção do resultado "Olá Mundo, John")
A
Eleva u,n valor a potência de un1 expoente 3A4 (3 elevado a 4, retorna 81)

Funções Internas
Além das fornecidas pelo .N.ET Framework, o Visual Basic .N-ET possui 1nuitas funções inter-
nas. Essas funções gera,n vários recursos úteis, incluindo a conversão de um tipo de dado em ou-
tro, cálculos rnatemáticos, rnanipulação de strings e asshn por diante. Você deve conhecer
algu1nas delas para poder prosseguir com o estudo do Visual Basic .NET.
76 Dia 3

Funções de Conversão
Algumas das funções rnais irnportantes disponíveis no Visual Basic .NET são as de conversão.
Elas pennitem que u1n tipo de dado seja convertido em outro. As funções de conversão se torna-
ra1n ainda n1ais importantes nessa versão do Visual Basic porque ela é n1uito mais restrita com
relação aos tipos de dados, e não converte auton1aticarnente um tipo ern outro corno as anteriores
fazia,n.

ALERTA
- Se você quiser que o Visual Basic .NET converta de modo automático os tipos
de dados, poderá desativar a verificação restrita de tipos adicionando Option
Strict Off no início de seus arquivos. É bom saber, no entanto, que isso pode-
ria levar a resultados inesperados em seu código (ou seja, erros) se o Visual
Basic .NET converter uma variável quando essa operação não for esperada.

Todas as funções de conversão do Visual Basic .NET co1neça1n com a letra 'C' (como na palavra
conversão) e tennina1n corn urna fonna abreviada do novo tipo. Alé1n disso, há tuna função ge-
nérica, Ctype, que pode efetuar conversões para qualquer tipo. A Tabela 3.7 descreve as princi-
pais fu nções de conversão.

TABELA 3.7 Funções de Conversão


Função Descrição
CBool Converte para um booleano (Boo 1ean). O que for avaliado co1no falso (Fa 1se)
ou O será configurado con10 falso (F a1se); caso contrário, será definido como
verdadeiro (True).
CByte Converte para un1 tipo Byte. Todos os valores 1naiores do que 255 ou informa-
ções frac ionárias serão perdidos.
CChar Converte para um único caractere. Se o valor for maior do que 65, 535, ele será
perdido. Se você converter u.n1a String, só o primeiro caractere será alterado.
CDate Converte para uma data (Date). U1na das funções mais avançadas de conver-
são, CDate pode reconhecer alguns dos fonnatos mais comuns de inserção de
datas.
CDbl Converte para um tipo duplo (Doubl e).
Ci nt Converte para u1n inteiro (Integer). As frações são arredondadas para o valor
,na.is próxirno.
Clng Converte para um tipo longo (Long). As frações são arredondadas para o valor
1nais próxiJno.
CSht Converte para um tipo curto (Short). As frações são arredondadas para o valor
1nais próxiJno.
CStr Converte para urna String. Se o valor for urna data (Date), apresentará o for-
mato abreviado.
Introdução à Programação com o Visua l Basic .NET 77

T ABELA 3.7 Funções de Conversão (continuação)

Função Descrição
CType Converte para qualquer tipo. E' un1a função poderosa que permite a conversão
de qualquer tipo de dado e1n outro. Po1tanto, a sintaxe dessa função é u1n pouco
diferente das outras.

SINTAXE A sintaxe de CType é


oNovaVariavel = CType(oVariavelAnterior, NovoTipo)

onde oNovaVariave l e oVariave lAnterior são lugares reservados para as variáveis


resultante e original da conversão, respectiva1nente. O tipo que surgirá após a con-
versão será o inserido e1n tlovoTipo. 'Ele pode ser qualquer variável aceita depois de
As en1 urna declaração, portanto, é possível usar essa função para efetuar conversões
para tipos de objeto, enurnerações e estruturas, assim como para tipos si1nples.

Funções de Manipulação de Strings


A 1naioria das funções anteriores relacionadas a stings no Visual Basic foi substituída no Visual
Basic .NET pela funcionalidade interna da classe String (exarninaremos a classe String com
detalhes no Dia 7). No entanto, você pode ver algurnas das funções do código anterior listadas na
Tabela 3.8 para se fa1niliarizar com elas.

TABELA 3.8 Funções de Manipulação de Strings

Função Descrição Exemplo


Len Retorna o comprimento de urna IVal ue = Len( '' Olã'') ('IValue é
string. igual a 3).
Chr Retorna o caractere co,n base no valor sVa 1ue = Chr(56) (' sVa l ue é igual a
ASCII ou Unicode inserido. letra A).
Ase Retorna o valor ASCII ou Unicode iVal ue = Asc("A") (' iValue é igual a
56).
Left Retorna caracteres de uma string, co- sValue = Left(''Olã Mundo'', 2)
meçando com o da extren1a esquerda. ('sValue é igual a O).
Tan1bé1n precisa da quantidade de ca-
racteres a retornar.
Rlght Retorna caracteres de urna string, co- sValue = Righ(''Olã Mundo'', 4)
meçando com o da extrema direita (o ('sValue é igual a undo).
oposto de Left). Também precisa da
quantidade de caracteres a retornar.
178 Dia 3

T ABELA 3.8 Funções de Manipulação de Strings (continuação)

Função Descrição Exemplo


Mid Retorna caracteres que não estão e1n sVal ue = Mid("Ol á Mundo ", 3, 5))
nenhuma das extre,nidades de uma (' sVal ue é igual a á Mun).
string. Mi d retorna qualquer número
sVal ue = Mid( "Olá Mundo ", 4)
de caracteres. Sua sintaxe é sReturn =
('sValue é igual a Mundo).
Mid(String, Início, Comprimento)
onde Início é o caractere a partir do
qual retornar, e Comprimento é a quan-
tidade de caracteres (incluindo Iní-
cio) a retomar. U,n recurso
interessante é que se você omitir Com-
primento, produzirá o retorno de to-
dos os caracteres desde ln ício .
Instr Encontra urna string dentro de outra. iValue = Instr(l, "Olá Mundo" , "1")
E' útil quando se procura algu1na ('iValue é igual a 2). Le,nbre-se de
string em tun arquivo. A sintaxe da que a string que você está procurando
função Instr é pode ter vários caracteres, portanto,
iReturn = Instr(Caracterelnicial, em uma busca por "Mundo", como a de
StringPesquisada, ItemProcurodo, iVal ue = Instr(l, '' Ol á Mundo'' ,
TipoCorrespondência) "Mundo")) 'iValue é igual a 5.
Caracterelnicial é a posição na
StringPesquisada, onde o progra1na
iniciará a busca (a contagem começa
em l). StringPesquisada é onde será
executada a busca e ItemProcurado é
a string que se quer encontrar.
TipoCorrespondência detennina se a
busca irá diferenciar maiúsculas de
minúsculas. Se estiver configurado
co1no O (con·espondência binária), a
pesquisa diferenciará maiúsculas de
minúsculas. Se for ignorado ou confi-
gurado como 1 (correspondência tex-
tual), não diferenciará. A variável
i Return seria igual a posição na
StringPesquisada onde o ItemProcu-
rado co1neça. Se a string procurada
não for encontrada, i Return será
igual a O.
Introdução à Programação com o Visua l Basic .NET 79

T ABELA 3.8 Funções de Manipulação de Strings (continuação)

Função Descrição Exemplo


InstrRev pesquisa do lado direito da
string; no resto, é idêntica a Instr.
InstrRev será útil quando você estiver
pesquisando uma string que apresen-
te um camin110 de diretório e quiser
visualizar
. pri1neiro os diretórios infe-
nores.
iVal ue = InstrRev( ''Olá Mundo'' ,
"o") ' ; val ue é igual a 9.
Lcase Converte uma string em minúsculas. sVal ue = LCase("Olá Mundo")
'sValue é igual a olá mundo
Ucase Converte unia string em maiúsculas. sValue = UCase( "Olá Mundo")
I sVa l ue é igual a OLÁ MUNDO
LTrim Remove todos os espaços que prece- Value = Ltrim('' Olá Mundo '')
detn u1na string
'sValue é igual a "Olá Mundo li

Rtrim Ren1ove todos os espaços que suce- sVal ue = Rtrim{ " Olá Mundo ")
de,n unia string
'sValue é igual a " Olá Mundo"
Trim Remove todos os espaços que antece- sValue = Trim(" Olá Mundo ")
detn e sucedetn u1na string
'sVa 1ue é igual a "01 á Mundo"

,
Outras Funções Uteis
Finalizaremos com algu,nas funções geralmente úteis que não se enquadran, nas outras categorias.
Aqui encontrare1nos as que pennitem a detem,inação do tipo de u1na variável , assi1n como fun-
ções de manipulação de datas. A Tabela 3.9 descreve algumas dessas funções.

T ABELA 3.9 Funções Internas Diversas

Função Descrição
IsArray Retorna True (verdadeiro) se o parâmetro for uni array.
IsDate Retorna True se o parâtnetro for reconhecido co,no uma data.
I sNumeri e Retorna True se o parâmetro for reconhecido como um número.
I sObj ect Retoma True se o parâmetro for alguni tipo de objeto.
TypeName Retoma o nome do tipo de dado do parâ1netro, por exe,nplo, TypeNa-
me(sName) retornaria "String ".
I ªº Dia 3

T ABELA 3.9 Funções Internas Diversas (continuação)

Função Descrição
Now Retorna a data e a hora atual.
Today Retorna a data atual, co1n a hora configurada co1no 0:00:00 a.m.
(n1eia-noite).

Escrevendo Suas Próprias Rotinas


En1bora as funções internas sejam bastante úteis, sen1pre haverá vezes e1n que você precisará
criar suas rotinas. Pode ter de selecionar utn conjunto de funções internas que seja1n chatnadas
da 1nes1na 1naneira ou talvez gerar alguma funcionalidade exclusiva. De q uai quer n1odo, o Visu-
al Basic .NET tornará fác il a criação de suas rotinas.
l-lá dois tipos de rotinas usadas no Visual Basic .NET. U1n deles é a rotina que executa algo, mas
não retorna nenhutn valor. São as cha1nadas sub-rotinas (ou, na abreviatura, sub). O outro tipo
de procedünento executa algo, poré1n retornando um valor. Essas são deno1ninadas funções.

Sub-Rotinas
U1na sub-rotina é um bloco de código do Visual Basic .NET que executa algu1na tarefa - por exe1n-
plo, o 1nétodo Cansol e .Wri tel i ne que você vê e1n n1uitos dos exen1plos. Ele exibe informações na
tela, mas não retorna nenhum valor. Use as sub-rotinas para executar tarefas e1n seus prograinas.
Em geral é aconselhável inserir en1 uma sub-rotina um código que será executado mais de uma
vez. De maneira sen1elhante, se tiver de usar u1n código em vários aplicativos, é bom que trun-
bé1n o coloque em u1na sub-rotina. As sub-rotinas pennitem que um pequeno trecho de seu pro-
gra1na seja isolado, de 1nodo que, en1 vez de repetir todo o bloco de código, só seja preciso
referenciá-lo pelo nome. Isso não significa que a sub-rotina sempre executará exata1nente as
mesmas etapas, mas que realizará algu1na tarefa. Por exe1nplo, um receita pode instruir, "Adicione
u1na porção de vinagre a três de óleo". Em um 1nomento pode-se misturar uma xícara de vinagre
a três de óleo, enquanto em outro, podem ser so1nente três colheres de sopa de vinagre para nove
de óleo. De qualquer 1nodo, foi executada a sub-rotina CrieVinagrete. Siln, estou cozinhando o
jantar enquanto escrevo isso.
Para criar suas sub-rotinas, use a palavra-chave Sub:

SINTAXE Sub NomeSubRotina(Parametrol As Type,Parametro2 As Type, ...


• ParametroN As Type)
'Insira o que quiser aqui
End Sub

Nessa sintaxe, cada parâ1netro define um valor que ten1 de ser passado para a rotina.
A Listagem 3.2 mostra a declaração e o uso de uma sub-rotina.
Introd ução à Program ação com o Visual Basic .NET 81

CôDIGO LISTAGEM 3.2 Cri ando e Usando uma Sub- rotina


1 Sub ShowMessage(ByVal Message As String)
2 Console.Writeline(Message)
3 End Sub

4 ShowMessage(''Olá Mundo do Vis ual Basic .NET'')

ANÁLISE Nossa sub-rotina começa corn a palavra-chave Sub, como vemos na linha 1. A
sub-rotina se chama ShowMessage e usa um parâmetro quando é chamada. Ela tern1i-
na com a palavra-chave End Sub (linha 3). No interior está o código real executado pela sub-rotina.
Nesse caso, ela apenas exibe o conteúdo do parârnetro na janela do console. A linha 4 mostra uma
maneira possível de chamar a sub-rotina, passando a string "01 á Mundo do Vi sual Basi e . NET" .

Funções
Criar suas funções pennitirá que você insira novos recursos em seus aplicativos. Gerar uma fun-
ção é semelhante a definir novas sub-rotinas, exceto por ter de ser definido o tipo de valor retor-
nado. Dentro do procedi1nento, identifique o valor a ser retomado, como mostrado abaixo:

SINTAXE Funct ion Nome Função (Parãmetrol As Type , ... ParametroN As Type) As TipoRe -
tornado
'I nsi ra o que quiser aqui
Return ValorRetornado
End Funct ion

Nessa sintaxe, cada parâmetro defme um valor que terá de ser passado para a rotina;
TipoRetornado é o tipo de dado que a função retorna, e ValorRetornado, o valor que
será retomado pela ft.1nção. A Listagem 3 .3 mostra a declaração e o uso de uma fun-
ção simples.

CôDIGO LISTAGEM 3.3 Cri ando e Usando uma Função


1 Function Vol ume(ByVa l Length As Integer, _
2 ByVal ~lidth As Integer , ByVal Height As Integer) As Int eger
3 Return Length *Width *Height
4 End Function
5
6 Consol e.Writeline(Volume (3,4,5))

Escopo

Novo TERMO
Escopo é u1na dessas palavras adoráveis do jargão da informática que significa
"Quem mais pode me ver?". Formaln1ente, o escopo define a visibi lidade das variá-
82 Dia 3

veis de un1 progra1na, isto é, que rotinas poderiam usar uma certa variável. Você pode não querer
que todas as rotinas acessem todas as variáveis. Pennitir que todas as rotinas conheça,u todas as
variáveis poderia levar u1na rotina a 'acidentalmente' alterar o valor de uma variável, introduzin-
do u1n erro em seu progra1na.

Até agora, te1nos em geral declarado as variáveis por meio da palavra-chave Oim dentro dos pro-
cedimentos. No entanto, você ta1nbé1n pode declarar as variáveis externamente para torná-las
disponíveis a vários procedimentos. Se fizer isso, poderá usar duas outras palavras-chave, Pu-
bl ice Private:
• As variáveis Pub li e fica1n disponíveis e1n todo o aplicativo. Elas são variáveis globais,
que existe1n global,nente, ou, por todo o aplicativo. Deven1 ser usadas parci1noniosa1nen-
te, mas serão úteis quando você precisar de algu1n valor que será e1npregado en1 muitos
pontos de seu progra1na, co1no a conexão a um banco de dados, ou um arquivo.
• As variáveis Pri vate fica1n disponíveis no 1nódulo ou classe onde são declaradas. Elas
são usadas co1n freqüência em aplicativos quando se precisa de tuna única variável que
possa ser empregada e1n vários procedimentos. Criando-a con1 a palavra-chave Pri vate,
estaremos pennitindo que todos os procedin1entos de u1n módulo ou classe acesse1n ava-
riável. As variáveis Priva te são úteis para compa11ilhar infonnações con1uns necessárias
a uma tarefa, como um valor intermediário que possa ser utilizado por funções diferentes
para executar um cálculo.

D I CA
-- Quando for criar uma variável, é bom declará-la o mais próxim o possível de
onde ela for necessária. Se você só for usar uma variável em um procedimen-
to, declare-a dentro dele.
Use as variáveis Private e Publ ic no nível de módulos com moderação.

Por Que o Escopo É Importante?


O escopo permite que você isole os dados usados pelos procedi111entos de seu aplicativo. Muitas
versões 1nais antigas do BASIC não tinJ1a111 o recurso do escopo, e todas as variáveis podia1n ser
acessadas e alteradas de qualquer parte do progra1na. Imagine escrever um programa naquela
época - você poderia reutilizar com freqüência (propositada ou acidentalmente) uma variável
em qualquer local de urn progra1na. Isso poderia levar a u111a falha se o valor fosse alterado en1
algum ponto, só para que se co,netesse o erro de ler posteriormente o novo valor, quando o pre-
tendido fosse o original.

O Escopo e os Procedimentos
Exatarnente co,no as variáveis podem ter um escopo, os procedimentos (sub-rotinas e funções)
ta1nbén1 possuem u,n. O escopo para os proceditnentos significa o mes1no que para as variáveis:
Introdução à Programação com o Visua l Basic .NET 83

ele descreve em que outro local de seu programa você pode usar o procedimento (ou fora de seu
progra1na, como veremos quando começarmos a criar objetos).
O escopo do procedimento é definido com o uso das mesmas palavras-chave empregadas para o
das variáveis. E1n geral, ele também possui o 1nes1no significado.
• Pub 1i c O procedilnento pode ser chrunado de qualquer parte do aplicativo. Esse é o
padrão se você não adicionar nenhuma outra palavra-chave.
• Pri vate O procedimento só pode ser cha,nado a partir de outro que esteja situado
dentro do mes1no 1nódulo ou classe onde foram definidos. Isso será útil quando você esti-
ver escrevendo várias rotinas de suporte usadas no decorrer de um cálculo, n1as as outras
não precisariam usá-lo.
Do 1nes1no 1nodo que co1n as variáveis, as palavras-chave adicionais de escopo serão aplicadas
quando você estiver criando objetos no Visual Basic .NET. Exa1ninare1nos essas palavras-chave
posteriormente.

Exemplo de Aplicativo: Calculando um Valor


Futuro
Agora que você já explorou
. a criação e uso de variáveis e procedimentos, poderá gerar u.m apli-
.
cativo que execute o cálculo de u1n investi1nento. Esse aplicativo pertnitirá a análise dos benefi-
cios maravilhosos do investimento regular e dos juros compostos. Neste exemplo de aplicativo
do console evitaremos a co,nplexidade que uma interface gráfica co,n o usuário adicionaria. A
Listage1n 3.4 mostra o código de uma execução do progratna.

CÓDIGO/ LISTAGEM 3.4 O Programa de Cál cul o de Investimentos


RESULTADO

1 InvestCalc .exe
2 Saldo Inicial: 10000
3 Juros Anuais (por exemplo, para 5%, insira 5):5
4 Depósito Mensal: 200
5 Período do Investimento em Anos: 30
6
7 Se você começar com US$10.000,00
8 e investir US$200,00 por mês
9 durante 30 anos
10 a 5% de juros.
11 Seu saldo final será: $211.129,17

Aqui vernos o resultado de se começar com utn saldo de US$ l 0.000 adicionando US$200 por
mês durante 30 anos, con1 juros fixos de 5 o/o.
l ª4 Dia 3

O progra1na requer que o usuário insira os quatro valores (Sal do Inicial , Juros Anuais, Depôs i -
to Mensal e Período do Investimento em Anos). Por sua vez, ele calculará o saldo final. Essa
operação é conJ1ecida co1no cálculo do valor futuro (FV), e o Visual Basic .NET a inclui co1no
uma de suas funções internas. A fórrnula do Valor Futuro é
FV = OepositoMensal *((l + JurosMensais) A Meses - 1)
.,. /JurosMensais )+ Saldolnicial * ( 1 + JurosMensais) A Meses
As etapas a seguir descrevem esse procedirnento para que você possa compreender 1nelhor como
funciona:
1. Comece criando um novo projeto no Visual Basic .NET. Selecione u1n novo aplicativo
do console. O visual Basic .NET criará um projeto com um n1ódulo.
2. Feche a janela do arquivo e o reno1neie usando o Solution Explorer. Dê u1n clique com o
botão direito do 1nouse no non,e do arquivo, Modu l el. vb, no Solution Explorer e selecio-
ne Rena,ne. Altere o no1ne do arquivo para mod I nves t. vb.
3. Altere o nome de Sta1iup Object ta1nbé1n. Dê um clique co1n o botão direito do 1nouse no
projeto do Solution Explorer e selecione Properties. Na página General, altere o Startup
Object para Invest. Ele deve estar na lista suspensa.
4. Você está pronto para co1neçar a codificar. Precisa de ao menos quatro variáveis para ar-
1nazenar a entrada do usuário. Declare-as co1no n1ostra a Listagem 3.5. A maioria desses
valores é de números de ponto flutuante, co1n exceção de Peri odo. Essas declarações de-
vem ocorrer entre as linhas Module e Sub Ma i n ( ) porque as variáveis estarão no nível do
1nódulo.

CôDIGO LISTAGEM 3.5 Declarações para o Cálculo do Valor Futuro


1 Private dblJurosAnuais As Double =O
2 Priva te iPeriodo As Integer =O
3 Private decSaldoinicial As Oouble = o
4 Private decOepositoMensal As Oouble =o

5. Use a rotina Ma i n para cha1nar as rotinas de obtenção das entradas do usuário, execução
dos cálculos e exibição do resultado, como na Listagem 3.6.

CôDIGO LISTAGEM 3.6 Rotina Main

1 Shared Sub Main()


2 Dim decResultado As Oouble
3 'obtencao dos valores das entradas
4 GetlnputVal ues()
5 ' calculo
6 decResultado = CalculateFV(dblJurosAnuais,
Introdução à Programação com o Visua l Basic .NET 85

CÓDIGO LISTAGEM 3.6 Rotina Main (continuação)

7 i Periodo,_
8 decOepositoMensal,
9 decSaldolnicial)
10 ' exibicao do resultado
11 DisplayResults(decResultado)
12 End Sub

Na Listagem 3 .7, cada função principal do aplicativo é un1a sub-rotina ou função separa-
da. Isso pennitirá que você altere mais rapidarnente as técnicas para obter as entradas ou
exibir o resultado posteriormente.
6. Adicione o código da Listagen1 3.7 para pennitir ao usuário inserir informações. O pro-
cedi,nento não usa nenhum parâmetro, nem retorna urn valor. Já que esse é u,n aplicativo
do console, você e1npregará a rotina Console. Read para obter valores.

CóDIGO LISTAGEM 3.7 A Rotina das Entradas Console.Read

1 Private Sub GetlnputValues()


2 Console.Writeline()
3 decSaldolnicial = COec(_
4 GetValue(''Saldo Inicial: '' ))
5 dblJurosAnuais = CObl(_
6 GetValue(''Juros Anuais (por exemplo.para 5% ,i nsira 5): ''))
7 decOepositoMensal =COec(GetValue(''Oepõsito mensal: ''))
8 iPeriodo = Cint(GetValue(''Perfodo do investimento em anos: ''))
9 Console.Writel ine()
10 End Sub
11
12 Private Function GetValue(ByVal Prompt As String) As String
13 Console.Write(Prompt)
14 Return Console.Readline
15 End Funct i on

Observe que a sub-rotina GetinputVa l ues chama a função GetVa l ue. Esse é um exemplo da cria-
ção de rotinas de suporte. E1n vez de reescrever o código para sol icitar inforn1ações ao usuário
várias vezes, isole-o e crie um procedi1nento para executar a tarefa. Dessa 1naneira, o código re-
sultante para GetinputVa l ues será simplificado.
86 Dia 3

7. Escreva a rotina que exibirá a saída quando for calculada. No final , ela poderá ser exibida
em uma janela, rnas por enquanto, use o procedi1nento Console. Wri tel i ne, mostrado na
Listagem 3.8, para exibir as infonnações. Esse procedimento deve pegar o valor a ser
exibido e não retornar nada.

CôOIGO LISTAGEM 3.8 A Rotina de Saí da Console. \~ri tel i ne

1 Private Sub DisplayResults(ByVal Resultado As Double)


2 Console.Writeline()
3 Console.Writeline(''Se você começar com {O:c}, '', decSaldolnicial)
4 Console.Writeline('' e investir {O:c} por mês'', decDepositoMensal)
5 Console.Writeline('' durante {O} anos'', iPeriodo)
6 Console.Writeline('' a {0}% de juros.'', dblJurosAnuais)
7 Console.Writeline()
8 Console.Writeline(''Seu saldo final serã: {O :c}'', Resul tado)
9 End Sub

Essa é u1na rotina simples, co1nposta de várias chamadas a Console. Wri tel i ne para exi-
bir os valores inseridos e o resultado do cálculo.
8. Execute a cálculo do valor futuro. Essa rotina deve usar os quatros valores co1no parâ1ne-
tros e retornar o resultado do cálculo. Como possui um valor de retorno, esse procedi-
1nento é uma função. A Listagem 3.9 1nostra a função CalculateFV.

CôDIGO LISTAGEM 3.9 A Função Cal cul ateFV


1 Private Function CalculateFV(ByVal JurosAnuais As Double,
2 ByVal Período As Integer, _
3 ByVal DepositoMensal As Double, _
4 ByVal Saldolnicial As Double) As Double
5 'divida por 1200 para tornã-lo um percentual mensal
6 Dim decJurosMensais As Double = CDec(Juros Anuais /1200)
7 Dim iMeses As Integer = Período* 12
8 Di m decTemp As Double
9 Dim decReturn As Double
10 'precisaremos desse valor em alguns locais
11 decTemp = CDec((l +decJurosMensais) A iMeses)
12 decReturn = CDec(DepositoMensal * _
13 ((decTemp - 1) / decJurosMensais)
14 + (Saldolnicial * decTemp))
15 Return decReturn
16 End Function
Introdução à Programação com o Visua l Basic .NET 87

Exatamente co1no em Get I nputVa l ues, você poderia ter isolado o código que calculou o valor de
decTemp. No entanto, já que só precisamos desse cálculo nessa rotina e é bem provável que ele
não seja mais necessário, foi melhor não fazê-lo.
A Listagem 3. l O mostra o código completo para o exen1plo do aplicativo.

CÓDIGO LISTAGEM 3.10 O Programa Completo de Cál culo de Investimentos


1 Module Invest
2
3 Private dblJurosAnuais As Double = O
4 Private iPeriodo As Integer = O
5 Private decSaldolnicial As Double = O
6 Private decDepositoMensal As Double = O
7
8 Sub Main()
9 Dim decResultado As Double
10 'obtenção dos valores das entradas
11 GetlnputValues()
12 'cálculo
13 decResultado = CalculateFV(dblJurosAnuais,
14 iPeriodo, _
15 decDepositoMensal, _
16 decSaldolnicial)
17 'exibição do resultado
18 DisplayResults(decResultado)
19 End Sub
20
21 Private Function CalculateVF(ByVal JurosAnuais As Double,
22 ByVal Periodo As Integer , _
23 ByVal DepositoMensal As Double,_
24 ByVal Saldolnicial As Double}As Double
25 'divida por 1200 para torná-lo um percentual mensal
26 Dim decJurosMensais As Doubl e = CDec(JurosAnuais / 1200)
27 Dim iMeses As lnteger = Periodo * 12
28 Dim decTemp As Double
29 Dim decReturn As Double
30 'precisaremos desse valor em alguns locais
31 decTemp = CDec((l + decJurosMensais) A iMeses)
32 decReturn = CDec(DepositoMensal * ((decTemp -1)
33 / decJurosMensais)_
34 + (Saldolnicial * decTemp))
35 Return decReturn
36 End Function
37
38 Private Function GetValue(ByVal Prompt As String) As String
39 Console.Write(Prompt)
88 Dia 3

CôDIGO LISTAGEM 3.10 O Programa Completo de Cálculo de Investimentos


(continuação)
40 Return Console . Readline
41 End Function
42
43 Private Sub Get i nputValues()
44 Console.Writeline()
45 decSaldoinicial = CDec(GetVal ue(''Saldo Inicial: ''))
46 dblJurosAnuais =
47 CDbl(GetValue(''Juros Anuais (para 5%,insira 5): ''))
48 decDepositoMensal = CDec(GetValue(''Depõsito mensal: ''))
49 iPeriodo = Cint(GetValue(''Perlodo do investimento em anos: ''))
50 Console.Writeline()
51 End Sub
52
53 Private Sub DisplayResults(ByVal Resultado As Double)
54 Console.Writeline()
55 Console.Writeline(''Se você começar com {O:c}, '', decSaldo Inicial)
56 Console.Writeline('' e investir {O:c} por mês '', decDepositoMensal)
57 Console.Writeline(''durante {O} anos'', iPeriodo)
58 Console.Writeline(''a {0}% de juros. '', dblJurosAnuais)
59 Console.Writeline()
60 Console.Writeline(''Seu saldo final será: {O:c}'', Resultado)
61 End Sub
62 End Module

9. Execute o aplicativo. O resultado deve ser semelhante ao 1nostrado no início desta seção.
Você pode executar o aplicativo a partir do IDE dando um clique no botão Play da barra
de ferramentas. No entanto, é provável que a janela exibida desapareça 1nuito rapida-
1nente para que se possa ver a resposta. Em vez disso, execute o progra111a a partir do
pron1pt de co,nando processando o executável criado.
Você pode tentar fazer tuna experiência surpreendente co,n esse progra1na de cálculo. Insira os va-
lores dos depósitos que representa,n quanto você costuma gastar e1n un1 hábito n1ensal (almoço no
trabalho, cigarros, dispositivos eletrônicos). O valor futuro resultante etn geral é perturbador.

Resumo
A lição de hoje avançou bastante, exan1inando os diversos tipos de variáveis que você pode criar
no Visual Basic .NET e como empregá-las. Alé1n disso, explorou o conceito de fu nções e
sub-rotinas, tanto as que estão embutidas no Visual Basic .NET quanto as que podetn ser criadas.
Esses dois tópicos são fundamentais para sua co1npreensão do Visual Basic .NET e serão usados
ern todos os tipos de aplicativo.
Introdução à Programação com o Visua l Basic .NET 89

No Dia 4, "Controlando o Fluxo dos Progra,nas", continuare,nos a explorar a criação de códigos


no Visual Basic .NET examinando co,no você pode gerenciar as decisões e,n seus programas.

P&R
P Li que o Visual Basic .Net dá suporte à programação ' sem tipos'. O que é isso?
R Quando você declara o tipo de uma variável ou função, define ceitas regras: que espécie
de informações ela representa, onde pode ser usada e assim por diante. A prograrnação
sern tipos ocorre quando o tipo não é declarado. Todas as variáveis são, então, objetos
que podem conter qualquer tipo de infonnação. O Visual Basic .N-E T é o único men1bro
da fa,nília Visual Studio que dá suporte a esse tipo de progra1nação.
P Quando quiser criar um procedimento, ele deve ser uma sub-rotina ou uma função?
R Uma resposta breve seria, "Depende". Você deve criar o tipo de procedimento que forne-
ça a funcionalidade necessária. Alguns são óbvios. Se for preciso gerar u,n procedimento
que execute alguns cálculos ou ,nanipulações e retorne o resultado, é bom usar uma fun-
ção. Outras rotinas - aquelas que pode1n ou não ter de retornar u1n valor - efetiva1nente
leva,n a uma escolha. Além disso, não há escolha correta, apenas preferências. Se for
evidente a inexistência de um valor a ser retomado, selecionar qual tipo de procedimento
será criado é uma questão de opinião pessoal e/ou e,npresarial. Algun,as pessoas e em-
presas se1npre usa1n funções; outras cria1n sub-rotinas quando necessário.
P Como posso encontrar a lista de todas as funções internas?
R Há duas ,naneiras pelas quais você pode encontrar informações sobre as funções internas:
• Ajuda on-line A ajuda on-line conté,n descrições e exemplos de código de todas as fun-
ções internas. Você pode encontrá-los (on-line) procurando por Visual Basic Language
Reference.
• Object Browser Se tudo que você precisa é de uma descrição breve de uma função in-
terna, poderá encontrá-la no Object Browser. Abra-o selecionando View, Other Win-
dO\VS e Object Browser. As funções internas se encontra,n na seção Microsoft. VisualBa-
sic.dll.

Workshop
O Workshop foi planejado para ajudá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e começar a pensar e,n co,no colocar seu conheci,nento em prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".
90 Dia 3

Teste
1. Como devo decidir que tipo de variável usar quando estiver trabalhando com n(uneros?
2. Qual a maneira correta de chamar esta sub-rotina?
Function RaiseToPower(ByVal Number As Integer, ByVal Power As Integer)As
Long
A: Dim l Value = RaiseToPower(3,4)
B: RaiseToPower 3,4
C: Console.Writeline(RaiseToPower(3,4))
O: Dim lValue =RaiseToPower 3,4
3. Se u.ma variável for declarada com o uso da palavra-chave Priva te, onde poderá ser usa-
da e1n u1n progra1na?

Exercícios
1. Reescreva o exe1nplo do aplicativo para cálculo do valor futuro de modo que represente
o pagamento de um e1nprésti1no em vez de um investimento. Ele deve solicitar a quantia
do empréstimo, os juros anuais, o período e1n 1neses e calcular o valor de seus pagamen-
tos. A fór1nula para esse cálculo é
Pagamento= QuantiaEmprestimo * (JurosMensais * ((1 + JurosMensais) A

Meses)/ (((1 + JurosMensais) A Meses) - 1))


SEMANA 1

DIA

Controlando o Fluxo dos


Programas
Até agora, este livro abordou a criação de programas de co1nputador, mas para escrever um que
seja reahnente útil, você precisa de 1nais alguns elementos essenciais. Até o mo1nento, estive-
mos desenvolvendo progra1nas co1npostos de uma série linear de instruções; cada linha era exe-
cutada em ordem quando o programa era processado. Para que un1 progratna seja realn1ente
interativo, para que use ca1ninhos diferentes no decorrer do código dependendo das entradas que
receber, é preciso u1n novo tipo de instrução, tuna instrução de controle. Quase toda linguagem
de progra1nação possui instruções de controle, e o Visual Basic .NET não é u1na exceção. Nesta
lição você aprenderá sobre as duas categorias de instruções de controle:
• Instruções cond.icionais
• Instruções de laço
En1 cada categoria, abordarei diversas variações dos tipos, e você aprenderá que instrução espe-
cífica é melhor para uma sjtuação em particular.

Tomando Decisões com as Instruções de


Controle
As instruções de controle são aquelas partes de uma linguagen1 de programação que existem
apenas para determinar que outras partes do progra1na serão executadas. A determinação ocorre
192 Dia 4

por causa do valor de algumas variáveis ou outra circunstância, permitindo q11e o programa aja
diferente,nente dependendo da situação. A necessidade desse tipo de comportamento é evidente
quando você percorre a maioria dos progra1nas que usa1n pseudocódigo.

Novo TERMO
Quando descrevemos um problema por meio de uina linguage,n que é algo entre
nossa maneira habitual de falar e códigos de co1nputador, cha1na1nos essa descrição
'quase em código' de pseudocódigo. Esta lição fornece vários exemplos do uso desse tipo de lin-
guage,n para descrever o que seus programas devem fazer. Muitas pessoas, incluindo os autores
deste livro, acham essa maneira útil para planejar o fluxo de seus programas de u,n ,nodo que lei-
gos tan1bém possa1n co1npreender. Pode ser 1nuito 1nais fácil descrever wn progra1na inteiro em
pseudocódigo antes de con1por o código real (isso se tornará excessivamente i1npo1tante quando
você lidar co1n programas mais co,nplicados).

Por exe1nplo, considere1nos um código que consistiria apenas em un1a pequena parcela de um
aplicativo, a saudação na hora da conexão. Usando a linguage,n co,num para descrever o que
esse código faz, você poderia dizer, "Dá as boas-vindas ao usuário que iniciou o progra1na, usan-
do a saudação apropriada dependendo da hora do dia". Para un1 trecho tão pequeno de código,
essa provavelmente seria a descrição integral fornecida, e a codificação poderia ser iniciada exa-
tamente nesse ponto. Co1n relação a essa tarefa específica, o pseudocódigo poderia ter a aparên-
. .
c1a a seguir:
Quando o programa for iniciado ...

Se for antes do meio-dia, exiba ''Bom Dia !''


Se for depois do meio-dia, porêm antes das 6 da tarde, exiba ''Boa Tarde!''
Para qualquer outra hora, exiba ''Boa Noite!''

Continue com o restante do programa ...


Mesmo esse exemplo sitnples mostra a necessidade de tomar algu,nas decisões no código, para
per1nitir que o prograina exiba un1a mensagem diferente dependendo da hora do dia. Para trans-
fonnar isso em código, use lnna instrução de controle a fim de que possa verificar u1na condição
(nesse caso, a hora) e, em seguida, escolha que ação to1nar.

A Instrução I f
A instrução de controle I fé a 1nais simples, e é a mais co1nu.1n em quase toda linguagem de pro-
grainação. Ela possui vários fonnatos diferentes, 1nas basica1nente tem a seguinte aparência:
If <condição >Then
Código a ser executado se a condição for verdadeira
End If
A <condição> é a parte essencial dessa instrução; ela determina se o bloco de código interno será
executado ou não. Essa condição toma a fonna de u1na expressão, que é uma combinação deva-
lores e operadores aval iada no tetnpo de execução para gerar utn único valor. Já que a instrução
Controlando o Fluxo dos Programas

I f dá suporte a apenas duas ações possíveis - o código é executado ou não-, a expressão só deve
ter dois valores. Isso significa que qualquer expressão usada como u1na condição te1n de apre-
sentar u1n resultado definitivo " si1n ou não" (Verdadeiro ou Falso), como estes exen1plos:
• Esta1nos e1n um horário antes do 1neio-dia.
• Estamos e1n utn horário depois do 1neio-dia, porém antes das 6 da tarde.
• A quantidade de alunos excede à de cadeiras.

Cada uma dessas expressões é verdadeira ou não. Não há meio tenno e, portanto, elas se enqua-
dra1n co1no a condição de u1na instrução I f. Se você tiver algu1na dúvida sobre a confonnidade
de uma expre,s são etn particular, apenas teste-a no pseudocódigo. Por exemplo, considere estas
expressões:
• 3+5
• John
• Quarta-feira

Agora, teste u1na dessas expressões en1 seu pseudocódigo: "Se 3 + 5, então, encerre o progra-
ma". O que isso significa? A expressão "3 + 5" não te1n u1n resultado que possa ser avaliado
con10 verdadeiro ou falso e, portanto, a instrução I f não faz nenhum sentido. Expressões que re-
tornam verdadeiro ou fa lso são conhecidas co1no booleanas; abordarei esse assunto co1n mais
detalhes ainda nesta lição.
A seguir, iren1os voltar ao exemplo original do pseudocódigo, exibindo tnna saudação no i11ício
de um progra1na.
Quando o programa for iniciado ...

Se for antes do mei o-d ia, exiba ''Bom Dia! ''


Se for depois do meio-dia, porêm antes das 6 da tarde, exiba ''Boa Tarde ! ''
Para qualquer outra hora, exiba ''Boa Noite!''

Continue com o restante do programa ...


Antes de você converter esse pseudocódigo em um programa do Visual Basic .NET, pode valer a
pena aproxi1nar essas mesmas li nhas (legíveis pelo usuário) u1n pouco mais do que seria u1n có-
digo. Isso pode ser feito apenas pela reforrnulação do texto para fornecer mais detalhes:
Quando o programa for iniciado ...

Se a hora atual no sistema for menor que meio-dia


então, exiba ''Bom Dia ! ''

Se a hora atual no sistema for igual ou maior que meio-dia


e a hora atual do sistema tambêm for menor que 6 da tarde
então, exiba ''Boa Tarde!''
Se a hora atual no sistema for igual ou maior que 6 da tarde
194 Dia 4

entao, exiba ''Boa Noite!''

Continue com o restante do programa ...


Agora, para escrever esse progra1na, tudo que você precisa saber é como obter a hora atual do
sistema; o resto não deve ser tão difícil. A hora atual do sisten1a está disponível no objeto Now ( ) ,
que tambén1 inclui infonnações sobre a data atual e exibe várias propriedades úteis como Hour,
Minute, DayofWeek e Seconds. Para nossa finalidade, podemos nos dar por satisfeitos usando ape-
nas Hour, que retornará a hora atual representada e,n u,n período de 24 horas (valores de Oa 23).
Traduzir da ,nane ira mais literal possível do pseudocódigo para o Visual Basic .NET produzirá o
progra1na da Listagetn 4.1.

LISTAGEM 4.1 Greeting.vb


1 Imports System
2
3 Public Cl ass Greeting
4 'Execute o aplicativo
5 Shared Sub Main()
6 Dim dtCurrent As System.OateTime
7 Oim i Hour As Integer
8
9 dtCurrent = dtCurrent.Now()
10 iHour = dtCurrent.Hour
11
12 I f (iHour < 12)Then
13 Console.Writeline(''Bom Dia! '')
14 End If
15 I f (iHour > = 12)And (iHour < 18)Then
16 Console . Writeline(''Boa Tarde!'')
17 End If
18 I f (iHour >= 18}Then
19 Console.Writeline(''Boa Noite!'')
20 End If
21 End Sub
22
23 End Class

Você pode fazer o dov,rnload de Greeti ng. vb na página deste livro na Web e testá-lo. Para compilar
esse progran1a, e a maioria dos exen1plos desta lição, faça o download desse arquivo ou crie um ar-
quivo de texto, insira o código da Listagem 4.1 nele e, en1 seguida, salve-o como Greet i ng. vb. Vá
para o console de co,nando (promptdo DOS), use o co1nando cd (change directory, alterar diretório)
para se assegurar de que está trabalhando no mesmo diretório do arquivo Greeti ng. vb e co,npi le
o programa digitando vbc r: Syst em. dll t: exe Greet i ng. vb. O compi lador criará, por pa-
drão, u1n progra,na executável cotn o n1es1no no1ne do arquivo-fonte, portanto, nesse caso,
Controlando o Fl uxo dos Programas

tenninaremos co1n u1n arquivo novo, no 1nesn10 diretório, chamado Greeting.exe. A execução
do programa executável recém-criado produzirá o resultado apropriado, dependendo da hora do
dia em que ele for processado.
Para compreender n1elhor co,no essas três condições I f funcionaram, percorreremos o código e
examinare,nos o que aconteceu. Você poderia fazer isso dentro do IDE do Visual Studio, mas
usare,nos o papel para deixar todo esse esforço da máquina para mais tarde.

ANÁLISE A priJneira linha executada foi a 9, que inicializa a variável de data cotn a hora e data
atuais; e,n seguida, a linha IOsalva a hora atual em outra variável, i Hour. A pri1neira
instrução If é executada na linha 12. Nesse ponto, a expressão (i Hour < 12) é avaliada. A variá-
vel i Hour é igual ao valor da hora atual, que é 13 (de acordo com o relógio do sistema, para os fins
deste exemplo, apenas suponha que a décirna terceira hora é I da tarde). Agora, a expressão, que
foi reduz.ida a 13 < 12, será reduzida ainda mais para urn sin1ples valor booleano Fa l se (13 não é
menor do que 12, ao n1enos não pelo que aprendi em matemática). Portanto, u,n valor falso infor-
ma à instrução I f para não executar seu bloco de código, e o processame.nto imediatamente passa
para a Iinha 14, End I f . Essa instrução na verdade é apenas um espaço reservado, portanto, nada
acontece até a linha 15, a próxilna instrução I f . Nesse caso, a instrução I f , (i Hour >= 12) And
(iHour < 18),primeiroéreduzidapara (13 >= 12) And (13 < 18) e,e,n seguida, para True And
True (Verdadeiro e Verdadeiro). Quando co1nbinamos (And) dois valores booleanos, só consegui-
mos um resultado verdadeiro se ambos o forem , o que parece ser o caso aqui. Assi,n, a instrução
If tern1ina com un1a condição verdadeira, o bloco de código é executado (linha 16), e a tão esti-
mulante mensagetn Boa Tarde! é exibida no console. Agora, nosso progra,na executou todo o seu
trabalho; exibi,nos a mensagem correta para essa hora do dia. O código não encerrou sua execução,
no entanto; não há nada que o infonne que não há motivos para continuar, portanto, a execução
prosseguirá e111 End I f e, depois, na últi111a instrução da linha 18. Essa instrução te1n a expressão
(iHour >= 18) como sua condição, que se torna (13 >= 18) e termina como falsa. Felizmente a
execução passa para a últi,na instrução End I f na Iinha 20 e, e1n seguida, encerra o progra,na.

Estendendo a Instrução I f
Embora a Listagem 4.1 seja be1n direta e dece1to não é o prograrna mais complicado do mundo,
efetivamente levanta un1a questão: por que se preocupar com a execução de u1n código depois
que você tiver obtido sua resposta? .Esse é u1n bom ponto . .M.esroo que as linbas 18 a 20 da Lista-
ge,n 4. 1 fosse,n apenas algu,nas linhas adicionais de execução, poderia haver 1nuitas outras so-
brando no final de u1n progratna no inundo real. Nesse programa, a intenção era realmente passar
para a próxilna instrução I f , só se a atual fosse falsa. Poderia ter sido mais claro en11neu pseudo-
código escrevendo-o da maneira a seguir:
Quando o progr ama for i nic iado ...

Se a hora atual no sistema for menor que meio-dia


então , exiba ''Bom Dia!''
caso contrário
196 Dia 4

Se a hora atual no sistema for igual ou maior que meio-dia


e a hora atual do sistema também for menor que 6 da tarde
então, exiba "Boa Tarde!"
caso contrário
Se a hora atual no sistema for igual ou maior que 6 da tarde
então, exiba ''Boa Noite!''

Continue com o restante do programa ...


Esse exemplo é quase o mesmo que o do código anterior, mas agora está claro que você só passa-
rá para a próxi1na instrução I f quando o valor da expressão não atender à condição da atual.
Como já deve ter sido percebido, a capacidade de aninhar instruções I f , co1no aqui, é un1a neces-
sidade comum na programação de computadores, portanto, o Visual Basice a maioria das outras
linguagens fornecem utna maneira de expressar exatamente esse conceito coin a instrução If.
Estiven1os exatninando a fonna si1nples desta instrução:
If <condição> Then
bloco de código
End If
Se a avaliação da condição apresentar como resultado True, então, o bloco de código será execu-
tado; se obtiver Fa 1se, o bloco será ignorado, e a execução continuará depois de End I f. Você
pode tornar isso u1n pouco mais complexo adicionando u1na nova cláusula, El se. Agora, a sinta-
xe se parecerá com a descrita a seguir:
If <condição> Then
bloco de código #1
Else
bloco de código #2
End If
Nessa nova estrutura, se a condição encontrar u,n resultado True, o bloco de código# 1 será exe-
cutado, e o programa continuará depois de End I f. No entanto, se a condição obtiver Fa 1se, en-
tão, o bloco de código #2 será executado, e o programa continuará depois de End I f. Já que a
condição deve ser u1na expressão booleana e todas elas são verdadeiras ou falsas, u1n dos dois
blocos de código terá de ser processado; essa instrução nunca fará com que os dois ou nenhutn
deles sejan1 executados ao mesmo tempo.
Reescrever o código para se beneficiar dessa nova instrução I f aperfeiçoada produzirá a Lista-
gem 4.3.

LISTAG EM 4.2 Greeting_IFELSE.vb


1 Imports System
2
3 Public Class Greeting
4 'Execute o aplicativo
Controlando o Fluxo dos Programas

LISTAGEM 4.2 Greeting_lFELSE.vb (continuação)


5 Shared Sub Main()
6 Dim dtCurrent As System.DateTime
7 Dim iHour As Integer
8
9 dtCurrent =dtCurrent.Now
10 iHour =dtCurrent.Hour
11
12 If (iHour <12)Then
13 Console.Writeline(''Bom Dia!'')
14 El se
15 If (iHour >= 12)And (iHour <18)Then
16 Console.l~riteline("Boa Tarde!")
17 Else
18 Console.l•lriteline("Boa Noite!")
19 End If
20 End If
21 End Sub
22
23 End Class

Mais simples? Não, nen1 tanto, mas a Listagern 4.2 é mais eficiente que a 4.1. Nessa nova versão
da solução, depois que a saudação correta foi exibida, o programa foi encerrado. Nenhum código
desnecessário foi executado.
Nesse progra,na específico, aninhei outra instrução I f dentro de cada cláusula El se, para testar
mais u,na condição caso a anterior fosse falsa. Não é só utn código desse tipo que pode ser inseri-
do ern uma cláusula El se, mas como essas instruções I f aninhadas são freqüentes, o Visual Ba-
sic acrescentou 1nais uma 1nelhoria, a instrução El se! f. Essa instrução cornbina a funcionalidade
de El se, com a possibilidade de outra instrução I f ser aninhada ou aparecer imediatamente a se-
guir. Sua sintaxe é uma condensação do que você teria de escrever se usasse I f e El se. A seguir,
ve,nos a sintaxe de u1na instrução I f ern que a cláusula El se contérn outra instrução I f aninhada,
seguida pela sintaxe que seria usada com a instrução Eles I f:
If <condição #1> Then
bloco de código #1
Else
If <condição #2> then
bloco de código #2
End lf
End If
passa a ser
If <condição #1> Then
bloco de código #1
198 Dia 4

Elself <condi ção #2> Then


bloco de código #2
End If
Observe que falta lnna instrução End I f con1plementar na segunda sinta,'{e do exernplo. A instru-
ção El self é considerada apenas u1na cláusula e, po11anto, tambérn faz parte da instrução If ori-
ginal. Ainda seria possível inserir uma cláusula El se naquela segunda condição ou até mesmo
outra cláusula El sei f. Esses dois exeinplos são mostrados aqui:
If <condição #1> Then
bloco de código #1
Elself <condi ção #2> Then
bloco de código #2
Else
bloco de código #3
End If

If <condição #1> Then


bloco de código #1
Elself <condição #2> Then
bloco de código #2
Elself <condição #3> Then
bloco de código #3
End If
Mesmo con1 outra cláusula El self, todo o bloco é considerado parte da instrução If original, e
só uma instrução End I fé necessária. Voltando ao primeiro exemplo, a exibição da saudação
apropriada dependerá da hora do dia, e a cláusula El sei f (veja a Listage1n 4.3) permitirá que
você si1nplifique bastante o código.

LISTAGEM 4.3 Greetings_Elself.vb


1 Imports System
2
3 Public Class Greeting
4 ' Execute o aplicativo
5 Shared Sub Main()
6 Dim dtCurrent As System.DateTime
7 Dim iHour As Integer
8
9 dtCurrent = dtCurrent.Now
10 iHour = dtCurrent.Hour
11
12 If (iHour < 12)Then
13 Console . Writeline(''Bom Dia!'')
14 Elself (iHour >= 12)And (iHour < 18)Then
Controlando o Fluxo dos Programas 99

LISTAGEM 4.3 Greetings_Elself.vb (continuação)


15 Console.Writeline(''Boa Tarde !'')
16 Else

17 Console. Writeline( '' Boa Noite!'')


18 End If
19 End Sub
20
21 End Class

Instruções If em Seqüência na Mesma Linha


Alé1n da fonna em bloco apresentada anteriorrnente, na qual um conjunto interno de código é in-
serido entre as instruções If e End If, também é possível expressar urna instrução If em urna
única linha. Aqui está un1 exemplo, e1n que u,na condição é verificada e uma ação ton1ada, tudo
e1n apenas uma linha:
If iHour > 11 Then System.Console.Writeline(''Nâo ê de manhã !'')

Esse conceito da linha única pode ser ampliado com a introdução de uma cláusula El se:
If iHour > 11 Then DoSomething() Else DoSomethingElse()

Ele pode até ser usado co1n mais de uma instrução a ser executada em blocos de código verdadei-
ros ou falsos (ou em ambos) já que instruções n1últiplas pode1n ser separadas com o uso de dois-
pontos, co1n.o na linha a seguir:
If iHour > 11 Then DoSomething() : DoMore() Else DoSomethingElse()

Incluí essa instrução 1nais para fins de con1ple1nentaridade do que por algu,na necessidade real.
Não há nada que você possa fazer com a instrução If em apenas uma linha que não seja possível
fazer co,n a fom1a habitual e1n bloco. Colocar todo o código em uma linha não fará co,n que seja
executado ,nais rápido. Tudo que se consegue, na n1aioria das vezes, é produzir um código-fonte
que ocupa rnenos espaço em disco e é tnuito mais difícil de entender. Ocasionalmente, essa ver-
são de linha única pode dar a seu código uma aparência melhor, como 1nostramos na Listage,n
4.4. Nessa listage1n, várias instruções I f foram necessárias, todas executando um código sim-
ples se suas condições forem verdadeiras. Essas situações são 1nuito raras parajustificar o uso de
outra sinta'<e ern uma instrução tão sirnples. Recomendo a adoção da outra fonna dessa instrução
para que não provoque1nos dores de cabeça e,n nossos colegas progra1nadores.

LISTAGEM 4.4 Instruções If em uma Única Linha Podem Dar ao Código uma
Aparência Melhor
1 If X=5 Then strChar = ''A''
2 If X=23 Then strChar = ''B''
1100 Dia 4

LISTAGEM 4.4 I nstruções If em uma Única Linha Podem Dar ao Código uma
Aparência Melhor (continuação)

3 If X=2 Then strChar = ''C''


4 ...

Expressões e Lógica Booleana


Todas as instruções de controle dependem, de algun1a 1naneira, de toinada de decisão, com base
no valor de uma variável, constante ou fato relacionado con1 a situação atual. Independente1nen-
te de que valor esteja sendo verificado, o resultado só pode ser verdadeiro ou falso. Como já dis-
cutimos, todas as expressões booleanas geram uma entre duas respostas: sim ou não, verdadeiro
ou falso. No Dia 3, "Introdução à Progra1nação co1n o Visual Basic .NET", você aprendeu sobre
as variáveis booleanas, u1n tipo de variável que só pode conter valores verdadeiros ou falsos.
Esses são os únicos tipos de expressão e valores pennitidos como pa1te de uma instrução de con-
trole porque e.la precisa tomar uma decisão co1n base nesse valor. Expressões que não são boo-
leanas apenas não funciona1n; não produziria1n uma resposta positiva/negativa ou verdadei-
ra/falsa, e o progra1na não saberia o que fazer.
Os dois estados 1nais simples das expressões booleanas são verdadeiro e falso; todas as expres-
sões booleanas, quando avaliadas, terminam com um desses dois valores. No entanto, não há
muitos programas que os usem direta1nente. E1n vez disso, são criadas expressões mais com-
plicadas que são co1nparações entre dois valores não booleanos, operações lógicas co1n valores
booleanos ou u1na co1nbinação desses dois tipos de expressões.

Operadores de Comparação
O tipo 1nais comum de expressão usado ern programas é urna co,nparação, duas expressões não
booleanas com u1n operador no meio. Os operadores de co1nparação a seguir estão disponíveis
para sere1n usados em expressões:
.
• >, n1a1or que
• < , menor que
• =, igual a
• <>, diferente de
• >=, 1naior ou igual a
• <=, 1nenor ou igual a
Todos esses operadores funciona1n tanto com strings quanto com valores numéricos. Um opera-
dor de co1nparação adicional, Li ke, ta1nbém está disponível para verificar a correspondência de
padrões nas strings. O operador Li ke pern1ite que você co1npare u1na variável de string co1n pa-
Controlando o Fluxo dos Programas 101 1

drões que empregue,n caracteres especiais e comuns. Entre os caracteres especiais que podem
ser usados corn Li ke estão:
• *, para indicar a quantidade de caracteres adicionais
• ? , para representar um caractere
• #, para representar um dígito (0-9)
• Intervalos ( [a-g] ), por exe,nplo) para especificar que qualquer caractere dentro dele deve
ser considerado urna correspondência
Desenvolveremos u,n pequeno progra1na para testarmos a instrução I f e o operador Li ke. Esse
progra,na (veja a Listage1n 4.5) aceitará um valor de teste e um padrão como entradas e, e1n se-
guida, verificará se o valor de teste coincide corn o padrão.

LISTAGEM 4.5 PatternMatcher. vb


1 Public Class PatternMatcher
2 Shared Sub Main()
3 Dim slnput As String
4 Dim sPattern As String
5 Dim sMatch As String
6
7 System.Console.Write(''Insira um padrão:'')
8 slnput = System.Console. Readline()
9 sPattern = slnput
10
11 System.Console.\~rite("Insira uma string para a comparação:")
12 slnput = System.Console . Readline()
13 sMatch = slnput
14
15 If sMatch Like sPattern Then
16 System.Console.\•lriteLine(sMatch & " Matched with " & sPattern)
17 El se
18 System. Console .\•lriteline(sMatch & " não coincidiu com "& sPattern)
19 End I f
20 End Sub
21 End Class

Depois de inseri-lo e1n u,n arquivo de texto (ou fazer seu dov,nload) e compilar (vbc /t :exe Pat-
ternMatcher. vb), tente executar esse programa co,n várias entradas. Por exe,nplo, você poderia
usar um padrão co1no C*T e tentar testar valores como CAT, coat, ct e assi1n por diante.

Operadores Lógicos
O outro tipo de expressão que pode ser usada como booleana é a que emprega operadores lógi-
cos. Esses operadores trabalha,n co,n expressões ou valores booleanos e produze,n u1n resultado
1102 Dia 4

booleano. Já que os valores booleanos são n1uito se1nelhantes aos bits (valores binários, 1 ou O),
os operadores lógicos são freqüentemente chamados de coniparações bit a bit. Os operadores
dessa categoria são ANO, OR e XOR, que con1para1n dois valores ou expressões, e NOT, que usa um
único valor ou expressão booleana.

Ao usar o operador ANO entre dois valores booleanos, você só obté1n um resultado igual a verda-
deiro se os dois o forem. Co1n OR, se u1n dos valores for verdadeiro, então o resultado ta1nbé1n
será. O operador XOR, tainbétn chamado de exclusive OR, gera um resultado verdadeiro, se u1n dos
valores for verdadeiro e o outro for falso. NOT é ape11as u1n operador de negação: retoma o oposto
de qualquer valor que for usado co1n ele. A Tabela 4.1 lista todas as combinações possíveis de
valores e o que os diversos operadores lógicos produziriam em cada caso. En1 todos os exem-
plos, seria possível substituir os valores True (verdadeiro) e Fa l se (falso) por expressões que pu-
dessem ser avaliadas até chegar a um valor booleano.

TABELA 4.1 Combinações Booleanas

Expressão Resultado
TRUE ANO TRUE TRUE
FALSE ANO TRUE FALSE
TRUE ANO FALSE FALSE
FALSE ANO FALSE FALSE
TRUE OR TRUE TRUE
TRUE OR FALSE TRUE
FALSE OR TRUE TRUE
FALSE OR FALSE FALSE
TRUE XOR TRUE FALSE
TRUE XOR FALSE TRUE
FALSE XOR TRUE TRUE
FALSE XOR FALSE FALSE
NOT TRUE FALSE
NOT FALSE TRUE

A disponibilidade dos operadores lógicos permite que você combine outras expressões e valores
para produzir expressões booleanas mais complicadas, como : I f X > 3 ANO X < 8 Then, ou I f
(((X+3) * 5) > {Y*3)) ANO (SystemlsRunning() OR iHour < 5) Then. Usaren1ososdoistiposde
expressões, de comparação e lógica, posteriormente em alguns exercícios envolvendo instru-
ções I f.
Controlando o Fl uxo dos Prog ram as

Avaliação Abreviada
De maneira setn.elhante ao resultado de uma eleição, o de utna expressão booleana em geral é co-
nhecido antes que ela tenha sido integralmente avaliada. Considere esta expressão booleana: (X
> 1) ANO (X <10). Se X for igual a 1, então, assiln que você avaliar o lado esquerdo da expressão
(obtendo fàlso), saberá que o direito é irrelevante. Devido à natureza da instrução ANO, não há ne-
cessidade de avaliar o outro lado. A expressão inteira será falsa, independentemente de que valor
for retomado pela outra extre1nidade. Chegaríamos a essa conclusão sem precisar pensar muito
ao avaliannos as expressões booleanas, rnas nem setnpre está tão claro para o computador.

Novo TERMO O co1nportan1ento que esperamos, não avaliando partes desnecessárias de un1a ex-
pressão, é chamado abreviação (short-circuiting), 1nas o Visual Basic .NET, por pa-
drão, não trabalha desse modo. Para fazê-lo abreviar uma expressão booleana, você precisa usar
forn1as alternativas dos operadores ANO e OR, ANOALSO e ORELSE. No entanto, não é bom apenas
confiar que ele se comportará dessa 1naneira; um programa simples de teste (veja a Listage1n 4.6)
pode ser usado para que examu1emos exatamente o que acontecerá.

LISTAGEM 4.6 ShortCi rcui ti ng. vb


1 Public Class ShortCircuiting
2
3 Shared Sub Main()
4 If Test(''Esquerda'')ANOALSO Test(''Oireita '')Then
5 'execute algo
6 End If
7 End Sub
8
9 Shared Function Test(slnput As String) As Boolean
10 System.Console.Writeline(slnput)
11 Test = FALSE
12 End Function
13
14 End Class

Se a função Test ( ) retornar falso, co1no fez na Listagetn 4.6, então, você saberá o resultado da
expressão inteira apenas avaliando o lado esquerdo. A execução do código da Listage1n 4.6 pro-
duzirá só tuna linha de resultado, nesse caso, "Esquerda" . Se Test ( ) retornar verdadeiro, os dois
lados precisarão ser executados, e o progra1na exibirá tanto "Esquerda" quanto "Oi rei ta" . Para
testar o co1npo1ta1nento-padrão dos operadores booleanos, tente alterar ANOALSO para somente
ANO, e veja que resultado obteve.
104 Dia 4

Lidando com Múltiplas Possibilidades: A


Instrução Se 1ect Case
A instrução I f pode manipular quase todo tipo de requisito para tomada de decisões, mas na ver-
dade, foi criada para lidar com opções de apenas umara1nificação. Se diversos valores diferentes
precisarem ser verificados e urna ação d istinta for tornada para cada urn, as instruções I f poderão
se tornar inadequadas. Considere o exemplo de um programa para inserção de dados de imposto
de renda co1n rotinas separadas para n1anipular cinco categorias diferentes de clientes. A catego-
ria do cliente é baseada na quantidade de pessoas e.1n um en.dereço domiciliar. Você prefere dire-
cionar os usuários para a rotina correta com base nesse valor. Com o uso das instruções If, o
código pode ficar com a aparência da Listagern 4.7.

LrSTAGEM4.7 Usando Muitas Instruções If Ani nhadas


1 .. .
2 If lngQuantidadePessoas = 1 Then
3 Call RetornalmpostoPerCapta ()
4 Elsel f lngQuantidadePessoas = 2 Then
5 Call RetornalmpostoDuasPessoas ()
6 Elself l ngQuantidadePessoas = 3 OR lngQuantidadePessoas = 4 Then
7 Cal l RetornalmpostoDomicílioMédio ()
8 Elself lngQuantidadePessoas > 4 ANO lngQuantidadePessoas < 10 Then
9 Call RetornalmpostoDomicílioGrande()
10 Else
11 Cal l RetornalmpostoDomicílioMuitoGrande ()
12 End If
13 . . .

Quando você começar a testar mais do que algumas opções possíveis, todas as diversas cláusulas
I f se tornarão excessiva1nente co1nplexas. Para 1nanipular o teste co1n tnúltiplos valores ou vários
conjuntos de valores, o Visual Basic incluiu a instrução Se l ect Case, que tem a sintaxe a seguir:
Select Case <variável ou expressão sendo comparada>
Case <valor ou intervalo de valores>
bloco de código
Case <valor ou intervalo de valores>
bloco de código
Case Else
bl oco de código
End Select
Controlando o Fluxo dos Programas

O uso da instrução Se l ect Case no lugar das instruções I f da Listage1n 4.7 produzirá o código
alternativo 1nostrado na Listagem 4.8.

LISTAGEM 4.8 O Comando Select Case Pode Simplificar Muito Seu Código
1 Select Case lngQuantidadePessoas
2 Case 1
3 Call RetornalrnpostoPerCapta ()
4 Case 2
5 Call RetornalrnpostoDuasPessoas ()
6 Case 3,4
7 Call RetornalrnpostoDocrnicílioMédio()
8 Case 5 to 9
9 Call RetornalrnpostoDornicílioGrande ()
10 Case Else
11 Call RetornalrnpostoDornicílioMuitoGrande ()
12 End Select

A cláusula Case El se é usada exata1nente como a cláusula El se e1n tuna instrução I f, exceto por,
nesse exemplo, ser executada se nenhuma das condições for atendida. Observe que, na Listagem
4.8, apenas uma das condições poderia ser verdadeira a cada vez. Não há sobreposição entre as
diversas condições Case, o que faz muito sentido. Na verdade, as sobreposições não são evitadas
de ,nodo algum pelo Visual Basic; é possível ter condições sobrepostas nas quais ,nais de u,na
condição Case pode coincidir com u1n valor específico. Se esse for o caso, só a primeira condição
que tiver u1na correspondência será executada porque o prograrna sai da instrução Sel ect Case
depois que tuna correspondência foi encontrada e o bloco de código apropriado foi processado.
En1bora não cause u,n erro, a sobreposição de condições pode ser confusa para o programador, e
é 1nelhor evitá-la apenas por isso.

Faça
1
Aborde sempre toda condição possível incluin- Não use múltiplas condições em sua instrução
do uma cláusula Case El se. Isso capturará Se l ect Case se um único valor puder ter cor-
toda entrada inesperada para as quais você respondência com mais de uma delas. Esse
não usou outra instrução Case. Seu programa tipo de código não é um erro para o Visual Ba-
ficará mais consistente. sic, mas será difícil de entender o que não é
muito desejável.

Laços
Até agora, nesta lição, você aprer1deu a controlar que código será executado co1n o uso das ins-
truções If e Select, ,nas há outra necessidade muito comu1n -a de processar o mesrno código
1106 Dia 4

várias vezes. Esse requisito é 1nanipulado por meio de outra espécie de instrução de controle, o
laço (loop).
Vários tipos diferentes de laços estão disponíveis no Visual Basic, todos pode1n executar a maio-
ria das taretàs, ,nas cada um foi projetado para atender a uma finalidade específica. Começare-
1nos nosso estudo da repetição examinando o 1nais básico dos laços, For .. . Next.

For ... Next


O objetivo do laço é executar um bloco de código várias vezes, e1n geral parando quando alguma
condição é verdadeira. (Embora uin laço não tenha de parar realmente; essa situação é chan1ada
de laço infinito.) O laço For executa u1n bloco de código u1n nún1ero específico de vezes. A sin-
taxe desse controle é
For <variável do contador>= <valor inicial> to <valor final>
Código a ser executado
Next <variável do contador>
A inclusão da variável do contador depois da instrução Next final é opcional, mas ela ajuda a in-
dicar à que laço For essa instrução Next pertence e é boa prática de progra1nação.

A Variável do Contador
A variável do contador é incre,nentada a cada passagem pelo laço, do valor inicial ao final.
Quando esse valor final é atingido, o laço encerra sua execução, e o programa continua na linha i1ne-
diatamente após a instrução Next. Para visualizar esse conceito co1n alguns valores reais, criaremos
un1a versão no Visual Basic .NET do primeiro progra1na que escrevi (veja a Listage1n 4.9).

LISTAGEM 4.9 Exibindo Seu Nome Repeti damente


1 Dim iCounter As Integer
2 Fo r iCounter = 1 to 10
3 System.Console.Writeline(''Duncan Mackenzie'')
4 Next iCounter

E' claro que em geral uso valores na casa dos milhares ... pois adoro ver 1neu nome rolando na tela!
A variável do contador é real e, exata1nente con10 na Listage1n 4.9, deve ser declarada antes de
você usá-la co1no parte de seu laço. Também é i1nportante se ce1tificar de e1npregar o tipo de
dado correto para essa variável. Na Listagem 4.9, a variável i Counter seria utilizada para ar1na-
zenar valores de 1 a 10, o que torna os tipos de dado inteiro (Integer) e byte os 1nais adequados.
En1 outras situações, podería1nos estar lidando com nún1eros muito maiores e, portanto, precisar
de u1n inteiro longo (Long I nteger). Para obter mais informações sobre os diversos tipos de da-
dos, incluindo que intervalo de valores cada un1 pode conter, recorra ao Dia 3. Como já meneio-
Controlando o Fluxo dos Programas

nado, a variável do contador é incrementada a cada passagem pelo laço, o que com freqüência é
útil porque ela pode ser usada e1n seu código.

Faça •
1
Use o tipo de dado mais apropriado para a si- Não altere o valor da variável do contador
tuação; não empregue o inteiro longo se o in- dentro do laço. A funcionalidade interna do
teiro puder atender bem. Sendo o intervalo laço For aumenta o valor da variável do conta-
fechado ou podendo crescer muito, certifi- dor sempre que o código do laço é executado,
que-se de usar o tipo de dado que melhor ma- mas você não tem impedimentos para alterar
nipule o maior intervalo possível para o por sua própria conta esse valor. Resista à ten-
contador. tação, ela só resultará em erros desconheci-
dos e em um código incompreensível.

A Listagen1 4.1 Omostra como você poderia usar a variável do contador como pa1ie de seu códi-
go. U1na pequena função cha1nada WeekDayName produz uma listagern dos dias úteis da semana.

LISTAGEM 4.10 Usando a Variável do Contador


1 Public Class OaysOfTheWeek
2
3 Shared Sub Main()
4 Oim sOayName As String
5 Oim iFirstOay As Integer
6 Oim ilastOay As Integer
7 Oim iCurrentOay As Integer
8
9 iFirstOay = 2
10 ilastDay = 6
11 For iCurrentDay = iFirstOay to ilastOay
12 System.Console.Writeline(WeekdayName(iCurrentOay))
13 Next iCurrentOay
14
15 End Sub
16
17 Shared Function WeekdayName(ByVal iOayNumber As Integer)As String
18 Oim sWeekdayName As String
19
20 Select Case iOayNumber
21 Case 1
22 sWeekdayName = Sunday
11 II

23 Case 2
24 sWeekdayName = Monday
11 II

25 Case 3
26 sWeekdayName = 11 Tuesday 11
1 108 Dia 4

LISTAGEM 4.10 (continuação)

27 Case 4
28 sWeekdayName = "Wednesday"
29 Case 5
30 sWeekdayName = "Thursday"
31 Case 6
32 sWeekdayName = "Friday"
33 Case 7
34 sWeekdayName = "Saturday"
35
36 Case Else
37 sWeekdayName = ''Invalid Day Number''
38 End Sel ect
39 Return sWeekdayName
40 End Function
41 End Class

Observe que na Listage1n 4.1 O, Sunday é considerado o pri1neiro dia, pottanto, esse código pro-
duziria os resultados a seguir:
Monday
Tuesday
Wednesday
Thursday
Friday

Esse exemplo ainda não está pronto para produção porque gerará a lista de
NOT A nomes apenas em inglês, não levando em consideração as configurações da
máquina. Há outras maneiras, um pouco mais complicadas, de conseguir essa
funcionalidade integral com o suporte a toda as configurações regionais dos
usuários. Retornaremos a esse tópico no Dia 8, "Introdução ao .NET Frame-
work".

Especificando o Valor do Incremento com o Uso de Step


Nos exemplos anteriores, a variável do contador era incrementada em 1 cada vez que o laço era
percorrido, 1nas é possível especificar o valor desse aumento. Depois do trecho com o valor final
da instrução For, você pode inserir Step <valor do aumento>, e a variável do contador será in-
cre1nentada com base no valor que for fornecido. Usando o exemplo do código na Listagem 4.11
co1no ponto de pa1tido, tente valores diferentes para Fi rs t, Last e Incremente veja os resultados.
Controlando o Fluxo dos Programas 109

LISTAGEM 4.11 ForExample. vb


1 Imports System
2 Public Class ForExample
3
4 Shared Sub Main()
5 Dim iCounter As Integer
6 Dim iFirstValue As Integer
7 Dim ilastValue As Integer
8 Dim ilncrement As Integer
9
10 iFirstValue = O
11 ilastValue = 100
12 ilncrement = 10
13 For iCounter = iFirstValue to i lastValue Step ilncrement
14 System. Censo l e. \•/ri tel i ne ( i Counter)
15 Next iCounter
16
17 End Sub
18 End Class

U,na característica interessante e útil de ter a opção Step no laço For é que ela pennite que você
percorra u,n intervalo de valores de maneira inve11ida. Tente os valores 10, O e 1 para as variá-
veis Fi rst, Last e Increment , respectivamente. Nada será exibido, porque Last já será menor
que Fi rst, ,nas se o valor de Increment for alterado de 1 para-1, algo interessante acontecerá
(não aceite simples,nente o que digo, tente!).
Ah, você conseguiu um laço que é executado o nú1nero exato de vezes que quiser, e agora os va-
lores são listados de trás para a frente. É difícil acreditar que possa ficar melhor do que está, mas
pode. Espere até chegannos ao laço Do!

hile ... End hile


O laço For, embora útil, é limitado. Foi projetado para situações nas quais você sabe quantas ve-
zes quer percorrê-lo, o que não é setnpre o caso. Por estar atualizado co,n relação a esse fato, o
Visual Basic possui dois laços mais flexíveis. O primeiro deles, Whi 1e ... End Whi 1e, continua
sendo executado enquanto u,na expressão booleana específica for verdadeira, como o descrito a
.
seguir:
While <expressão booleana>

Código a ser executado

End While
1 110 Dia 4

Qualquer expressão booleana válida pode ser usada, exatan1ente co1no e1n tuna instrução If e,
portanto, é possível dar suporte a condições co1nplexas. Por exemplo, um laço Whi l e pode forne-
cer com facilidade a mes1na funcionalidade do laço For, como den1onstra1nos na Listage1n 4.12.

LISTAGEM 4.12 WhileExample . vb


1 Imports System
2 Public Class WhileExample
3 Shared Sub Main()
4 Dim iCounter As Integer
5 Dim iFirstValue As Integer
6 Dim ilastValue As Integer
7 Dim ilncrement As Integer
8 iFirstValue = O
9 ilastValue = 100
10 ilncrement = 10
11 While iCounter <= ilastValue
12 '<Insira o bloco de código aqui>
13 iCounter = iCounter + ilncrement
14 End While
15 End Sub
16 End Class

'
E claro que reproduzir a funcionalidade do laço For não é u1na n1aneira útil de usar seu ten1po.
'
Não precisamos selecionar apenas um laço; te1nos de utilizar todos! E preferível empregar o laço
Whi lena execução de operações 1nais cornplicadas, como varrer urn array e1n busca de um tre-
cho específico de dados. Na Listage1n 4.13, você se preparará para essa pesquisa carregando un1
array com ai guinas strings. Em seguida, usando o laço Wh i l e, varrerá o array até ultrapassar a ex-
tensão dele ou encontrar a correspondência que procura.

LISTAGEM 4.13 WhileSearch.vb


1 Imports System
2 Public Class WhileExample
3 Shared Sub Main()
4 Dim iCounter As Integer = O
5 Dim arrlist(9)As String
6 Dim iMatch As Integer = -1
7 Dim sMatch As String
8 sMatch = ''Winnipeg''
9 arrlist(O) = ''San Diego ''
10 arrlist(l) = ''Toronto''
11 arrlist(2) - ''Seattle''
12 arrlist(3) - "Londres"
13 arrlist(4) = ''Nova York ''
Controlando o Fluxo dos Programas 111

LISTAGEM 4.13 WhileSearch.vb (continuação)

14 arrlist(S) = "Paris"
15 arrl i st (6) = "l~i nni peg"
16 arrlist(7) - "Sydney"
17 arrlist(8) - "Calgary"
18 arrlist(9) = "Orlando"
19 While iCounter <= 9 AND iMatch = -1
20 If arrlist(iCounter)Like sMatch Then
21 iMatch = iCounter
22 Else
23 iCounter = iCounter + 1
24 End If
25 End ~Jhi 1e
26 If iMatch -1 Then
27 System.Console.Writeline("Matched" & iMatch)
28 End If
29 End Sub
31 End Class
O operador de co1nparação Li ke é usado na Listagem 4.13, o que permite que as correspondên-
cias sejam examinadas co1n o uso de curingas. Ao percorrern1os esse código, poderemos perce-
ber que o progra1na passa para outra etapa logo depois que cada urna das condições de saída é
avaliada corno verdadeira. O laço Whi 1e é 1nuito útil, mas ainda há outro tipo de laço disponível,
Do. Se você for como eu, provavehnente esquecerá tudo que viu sobre a instrução Whi 1e, depois
de ter usado o laço Do.

Laço Do
O laço Do, além de ser rnais simples, apresenta a estrutura de laço mais flexível disponível no Vi-
sual Basic. Sua sintaxe, na forma mais básica, é :
Do
Código a ser executado
Loop
A sintaxe, contudo, não especifica nenhuma condição de saída, portanto, o código interno conti-
nuará a ser executado de modo infinito. Esse proble1na é facilmente contornado porque a instru-
ção Do dá supo1te a duas 1naneiras de iniciar as condições de saída. As opções disponíveis são
Whi 1e <condição>, que faz co1n que o laço seja executado enquanto a condição for verdadeira e
Unt i 1 <condição>, que permite a continuação do processa1nento do laço enquanto a condição for
falsa.
Qual deve ser usada, \~hi 1e ou Unt i 1? Tecnicarnente, não tern nenhuma in1portância; você pode
tranqüilan1ente empregar qualquer das duas opções apenas utilizando uma negação en1 sua con-
1 112 Dia 4

<lição de saída quando apropriado. Esses dois exemplos de código se comportarão da mesma 1na-
.
ne1ra:
Do While iMatch = 3

Loop

Do Unti l Not (iMatch = 3)


'iMatch 3 também funcionaria

Loop
Po1tanto, Whi l e ou Unt i l não são tão diferentes em seu efeito, ,nas o laço Do oferece outra opção
que fornece ainda ,nais flexibil idade. Você pode colocar a condição de saída (usando a cláusula
Unti l ou Whi le) no início (co,n Do) ou no final (com Loop) do laço. [sso significa que é possível
criar laços como o descrito a seguir:
Do

Loop Until bFound or iCounter > iTotal


Diferente de apenas escolher entre l~hi l e ou Unti l , a posição de sua condição de saída terá um
efeito 1naior sobre como seu laço será executado. Se você colocar a condição no início do laço,
então, ela será verificada antes de cada passagem pelo código, antes até da primeira vez que isso
acontecer. Se essa condição não for atendida, o laço não será iniciado, e o código não será execu-
tado nem rnesmo tuna vez. Ao contrário, se a condição for colocada na instrução Loop, então, ela
será verificada depois de cada passagem pelo código. Independente1nente do valor da condição,
o código se1npre será executado pelo rnenos uma vez.
Corn todas essas opções, há u1n total de quatro configurações diferentes para a instrução do laço
Do, tornando-a, de longe, o método mais flexível de executar laços. Você ainda terá de escolher
entre essas quatro opções, po1tanto, exa1ninare1nos alguns itens para ajudar nessa decisão:
• Você pode alternar entre Whi l e e Unti l apenas usando u1na negação na expressão booleana.
• Ao escolher entre Whi l e e Unti l , use a que não precisar de uma negação na instrução con-
dicional. Isso resultará em tuna expressão booleana um pouco mais simples, e em termos
de codificação, ,nais simples em geral é melhor.
• O posiciona,nento da instrução condicional é 1nuito importante. Se você colocá-la no iní-
cio do laço, então, ele não será executado de fonna alguma se essa condição não for aten-
dida. Se for inserida no fmal, o laço sempre será processado uma vez.
• Escolha entre as duas posições possíveis definindo se realn1ente não quer que o laço seja
executado caso a condição não seja atendida ou se quer que o processan1ento se,npre
ocorra pelo rnenos uma vez.
Controlando o Fluxo dos Programas

NOTA
- O laço Do Whi l e pode ser usado no lugar de ~lhi l e porque eles possuem exata-
mente o mesmo efeito. Não é raro ver os programadores deixarem o laço Whi 1e
de lado para empregar essa instrução.

Condições de Saída

Novo TERMO
A condição ele saída de qualquer laço é a expressão que será avaliada para detenni-
nar quando ele deve tern1inar. No caso de un1 laço Wh i l e ou Do, elas são claratnente
defmidas e aparecem no inicio ou no final dele. No laço For, a condição de saída é deduzida pela
configuração dos limites superior e inferior. Entretanto, para cada u1n desses tipos de laço há ou-
tra ,naneira de especificar quando sair deles com o uso da instrução Exi t. Há uma instrução Exi t
correspondente a cada laço (Exi t For, Exi t Do e Exi t Whi l e). Quando a instrução apropriada
for executada, ele será abandonado de imediato, e a execução do programa continuará na linha se-
guinte ao fi1n do laço.

E1nbora possam ser encontradas 1nuitas ocasiões e1n que essas instruções pareçam um n1eio per-
feito de fazer o programa se co,nportar correta1nente, elas são u,n dos 1n uitos exen1plos de práti-
ca imprópria de programação. Usando a instrução Exi t , você na verdade só terá especificado
uma parte complementar de sua condição de saída, mas de uma 1naneira mais do que óbvia. A
melhor forn1a de fazer isso seria adicionar essa segunda condição à condição principal de saída
de seu laço. Nos exemplos a seguir, veren1os algu,nas maneiras con1uns de e,npregar as instru-
ções Ex i t e o código correspondente que poderia ser usado como alternativa.

Exemplo 1: Usando um Laço For para Pesquisar um Array


Você poderia criar u1n laço For para executar u1na varredura em urn array de ta1nan.ho fixo, abor-
tando-o co1n Exi t For quando a correspondência fosse encontrada.
For i = 1 to 100
If arrNomes(i) = ''Joe'' Then
System .Console.Writeline(''Encontrado em#'' & i)
Exi t For
End lf
Next i
O problen1a existente aqui é que o laço For não devia de 1nodo algum ter sido usado, mas não sa-
be1nos antecipada1nente quantos laços tere1nos de executar. U1na 1naneira de tornar esse código
mais objetivo seria empregando u1n laço Do que controlasse a passagem pelo lin1ite superior e
procurasse a correspondência, como descrito a seguir:
i =l
Do Until i > 100 or arrNomes(i) = "Joe"
i = i + 1
Loop
1114 Dia 4

Exemplo 2: Procurando um Valor de Escape


Nos laços e1n que se quer capturar a entrada do usuário e ainda permitir que eles a cancelem,
duas condições de saída e un1a instrução Exi t em geral são usadas em um deles:
iCurrentGuess = O
iTarget = 5
Do Unti l iCurrentGuess = iTarget
iCurrentGuess = GetNextGuess()
If iCurrentGuess = - 1 Then
Exit Do
End If
Loop

Mais un1a vez, a condição efetiva de saída é mais complicada do que esse laço a faz parecer.
U1na solução apropriada seria:
iCurrentGuess = O
iTarget = 5
Do Unti 1 (iCurrentGuess = iTarget) Or (iCurrentGuess = -1)
iCurrentGuess = GetNextGuess()
Loop

Se essas instruções Exi t não são adequadas, você deve estar querendo entender por que as abor-
do. Bem, embora saiba que poderá evitá-las em um código de sua autoria, a maioria dos progra-
1nadores en1 geral trabalha com códigos escritos por outra pessoa, e é importante co,npreender o
que pode ser e11contrado neles.

Laços Infinitos
Qualquer laço pode ter erros, mas u1n incômodo e1n pa1ticular é quando ele é executado conti-
nuamente, forçando você a interro1nper o programa para encerrá-lo. O fato de não ser preciso es-
pecificar nenhu1na condição em seu laço Do o torna um pouco mais propenso a esse tipo de erro.
Se o progra1na for executado e parecer não tenninar nunca, e, se ele for baseado e1n DOS, use a
combinação de teclas Ctrl+C para causar sua interrupção. Se estiver utilizando o IDE do Visual
Basic, use a co,nbinação de teclas Ctrl+Break para ence1Tá-lo.

Faça ]
Certifique-se de ter uma condição de saída em Não torne sua condição de saída muito com-
qualquer laço que criar. plexa; ela precisa ser avaliada a cada passa-
gem pelo laço.

Algumas causas comuns dos laços infinitos são o esquecimento de que a variável do contador pre-
cisa ser au1nentada progressivamente (em laços diferentes de For), a reinicialização de uma variá-
vel que deveria ser crescente e o uso de uma condição de saída que nunca possa ser atingida.
Controlando o Fluxo dos Programas

Implicações sobre o Desempenho


1-lá várias dicas úteis para ajudá-lo a conseguir o melhor dese1npenho con1 os laços em seu códi-
go. Pri1neiro, le1nbre-se se,npre de que toda oti1nização do dese,npenho em um laço 1nuitas ve-
zes é mais benéfica do que e1n outro local do prograrna. Já que o código do laço é executado
repetida1nente, qualquer 1nelhoria no desempenJ10 desse código é incrementada pela quantidade
de iterações. Co1no exen1plo, considere o código da Listage1n 4.14.

LISTAGEM 4.14 LoopPerformance. vb


1 Public Class LoopPerformance
2
3 Shared Sub Main()
4 Dim i As Integer
56 For i = 1 to 1000
7 System.Console.Writeline(UserName())
8 Next 1
9 End Sub
10
11 Shared Function UserName() As String
12 Dim sName As String
13 sName = System.Environment.UserName
14 UserName = sName
15 End Function
16
17 End Cl ass

O no,ne do usuário é fornecido por meio de u1na pequena função que usa o .NET Fratne\vork
para obter suas infonnações atuais de segurança, n1as o ,nais impo1tante da Listagem 4.14 é que
ilustra erros co1nuns relacionados ao dese1npenho. A cha1nada à função UserName ocorre dentro
do laço, o que significa que ela será executada 1.000 vezes, cada uma provavelmente resultando
em alguma f onna de chamada do sistema operacional para obtenção do nome do usuário atual.
Já que não se espera que o usuário atual seja alterado nesse laço, é muito ,nais eficiente usar u,n
laço de sua autoria e,n vez disso, como mostra a Listagem 4. 15. O valor da função UserName não
é alterado e, portanto, não será incluído nessa segunda listagem.

LISTAGEM 4.15 LoopPerformance_Better.vb


1 Public Class LoopPerformance
2
3 Shared Sub Main()
4 Dim i As Integer
5 Dim sName As String
6 sName = UserName()
1116 Dia 4

LISTAGEM 4.15 LoopPerformance_Better. vb (continuação)

7
8 For i = 1 to 1000
9 System.Console.Writeline(sName)
10 Next 1
11
12 End Sub
13
14 Shared Function UserName() As String
15 Dim sName As String
16 sName = System.Environment.UserName
17 UserName = sName
18
19 End Function
20
21 End Class

Outra dica de desempenho i1npo1tante, ao usar expressões booleanas, é certificar-se de que as


partes mais sin1ples da expressão sejam colocadas e1n seu lado esquerdo e, e1n seguida, utilizar
as cláusulas de abreviação ANDALSO e ORELSE. Com essas versões dos operadores booleanos, é
possível que apenas o lado esquerdo da expressão seja avaliado, po1tanto é preferível que ele
contenha a 1nais rápida das duas cláusulas.

Aplicativos Que Farão Uso de Seu


Conhecimento Recém-Adquirido
Agora que você sabe como usar instruções condicionais, como I f e Se1ect Case, e vários tipos de
laços, poderá usar essas instruções para criar alguns exe1nplos interessantes de progran1as. Para
desenvolver esses exemplos, será necessário algo alé1n dos recursos do Visual Basic aprendidos
até agora; precisare1nos das classes do .NET Fra1nework. Presentes de alguma forma e1n todos os
exemplos anteriores, essas classes são conjuntos de códigos já existentes que foram e1npacotados e
disponibilizados para os programas pelo fato de o Visual Basic ser uina linguagern .NET. Esses
conj untos de código são fornecidos co1no objetos, o que é em essência uma1naneira de representar
un1 conceito ou entidade dentro de códigos. Sempre que un1 o~jeto co1no System.Console ou
System. Securi ty. Pri nci pa l for e111pregado, estare111os trabalhando co1n u1na parte do .NET Fra-
mework. Para fazer isso, em geral é preciso informar ao Visual Basic que se cogita utiJizá-lo in-
cluindo u.ma linhaco1no Imports System.Securi ty. Pri nci pa 1 em seu código. Considere esses ob-
jetos co1no pa1te da platafonna .NET; eles podem trazer para os programas u1n co1tjunto enorme
de recursos para que os prograinadores não precisem desenvolver essa funcionalidade individual-
mente. Esse é u1n conceito crítico do Visual Basic .NET, mas ainda o abordarei nos próxi1nos ca-
pítulos, portanto, não se preocupe se não parecer 1nuito claro neste momento.
Controlando o Fluxo dos Programas

Leitura de um Arquivo
Ler um arquivo no disco é u1na necessjdade co.1nun1 de muitos programas, po1tanto é fornecida
pelo .NET Fra1nework. Nesta lição, você usará dois objetos diferentes que são parte da seção
System. IO do Framework, System. IO. File e System. IO.StreamReader. Eles representam, res-
pectiva1nente, o arquivo real no disco e sua leitura na 1nen1ória.
O objeto St reamReader é criado com o uso do 1nétodo OpenFi ledo objeto File, sendo necessário
especificar o caminJ10 e o no1ne do arquivo que se deseja abrir. Você pode usar o objeto Stream-
Reader, para ler cada linha do arquivo, tnna por vez, através de seu 1nétodo Readl i ne até que al-
cance o final do arquivo. Para verificar se esse foi atingido, compare o último valor lido com a
constante especial Nothi ng, que é diferente de uma linha vazia e permite distinguir entre u1na li-
n.ha em branco em um arquivo e o fitn real de todos os dados. Já que Nothi ng é un, tipo especial
de valor, utilize o operador is para co1nparar sua sh·ing co1n ele, em vez de un1 operador co1nu1n
de igualdade. Na Listagem 4.16, a primeira etapa é inicializar todos, os seus objetos, enquanto
aponta o objeto StreamReader para o arquivo que você deseja ler. E necessário u1n arquivo de
texto para fazer este exercício, mas qualquer de seus outros exetnplos de arquivos de progratna
. vb deve servir.

LISTAGEM 4.16 Etapa 1: Configure


1 Public Class ReadFromFile
2
3 Shared Sub Main()
4 Dim sFileName As String
5 Dim srFileReader As System.IO.StreamReader
6 Dim slnputline As String
7
8 sFileName = "MySampleFile.txt"
9 srFileReader = System.IO.File.OpenText(sFileName)
10
11 End Sub
12 End Class

Depois de obter seu objeto StreamReader, que foi inicializado de 1nodo que apontasse para o ar-
quivo de teste, você poderá usar u1n laço Do Whi l e (veja a Listage1n 4.17) para ler o arquivo, uma
lin.ha por vez. Para que esse programa produza algu1na saída, a fim de tornar possível saber qual
sua função, ta1nbérn impri1niren1os cada uma das linhas ao sere1n lidas.

LISTAGEM 4.17 Etapa 2: Insira Este Código Acima da Instrução End Sub da
Listagem 4. 16
1 slnputline = ''algo''
2 Do Until sinputline is Nothing
1 118 Dia 4

L ISTA GEM 4.17 Etapa 2: Insira Este Código Acima da Instrução End Sub da
Listagem 4. 16 (continuação)
3 slnputline = srFileReader.Readline()
4 System.Console.Writeline(slnputline)
5 Loop

Antes de percorrer o laço pela primeira vez, é melhor certificar-se de que suas condições sejrun
atendidas, portanto, inicialize s Inputl i ne para assegurar que não seja Nothi ng. Na Listagem
4. 18, você tentará exibir s Inputl i ne mes1110 quando for Nothi ng, mas seria botn adicionar uma
instrução If para verificar essa possibilidade.

L ISTAGEM 4.18 Adicionado uma Verificação de Nothing


1 slnputline = ''algo''
2 Do Until slnputline is Nothing
3 slnputline = srFileReader.ReadLine()
4 If Not slnputline is Nothing Then
5 System.Console.Writeline(slnputline)
6 End If
7 Loop

Alternativatnente (veja a Listagen14.19), você poderia usar um método de laço um pouco diferen-
te e assegurar que un1a saída não seja exibida depois que o final do arquivo tenha sido atingido.

L ISTAGEM 4.19 Um Laço Me 1 hor


1 Public Class ReadFromFile
2
3 Shared Sub Main()
4 Dim sFileName As String
5 Dim srFileReader As System.10.StreamReader
6 Dim slnputline As String
7
8 sFileName = "MySampleFile.txt"
9 srFileReader = System. IO . Fil e.OpenText(sFileName)
10 slnputline = srFi leReader.Readline()
11 Do Until slnputline is Nothing
12 System.Console.Writeline(slnputline)
13 slnput l ine = srFileReader.ReadLine()
14 Loop
15 End Sub
16 End Class
Controlando o Fluxo dos Programas

Qualquer um dos métodos funcionará, mas o aplicativo fina] fornecido na Listagen1 4.19 produ-
ziu o código mais simples (e, portanto, melhor) dentro do laço. Se você quiser executar esse có-
digo, terá de criar u1n arquivo de texto co,n um conteúdo de teste no mes1no diretório que seu
progra,na executável co,npilado.

Um Jogo Simples
Outro uso comu,n para o laço é consultar repetida,nente o usuário solicitando tnna resposta, até
que se consiga a desejada. Isso pode soar incô1nodo (de algu1n modo, parecido co1n. as perguntas
de u1na criança), mas no tipo certo de progran1a, pode ser útil. Neste exemplo, você criará um
jogo si1nples de adivinhação de nú1neros. Esse jogo em pa1ticular foi a 1naneira que meu pai en-
controu para me manter ocupado enquanto esperávamos ser atendidos e1n restaurantes, etnbora
o jogássemos de un1a maneira menos tecnológica. Primeiro, ele escrevia utn litnite superior e utn
inferior nas extremidades de cima e de baixo de um guardanapo, l e 100, por exemplo, e, e1n se-
guida, selecionava utn nútnero aleatoriamente (a rnaneira aleatória de tneu pai, e não a dos co1n-
putadores) e o escrevia atrás do guardanapo. Eu cotneçava a dar palpites de números até que
encontrasse o correto, sendo infonnado a cada vez se meu palpite era muito alto ou muito baixo.
En1bora duvido que eu tenha sido rnetódico co1n relação a isso, essas infor1nações de certo facili-
tara1n bastante. Como parte da luta contínua para inforrnatizar tudo que não precisa ser infonna-
tizado, criaremos u1n progratna de cotnputador para jogar "Adivinhe o número!".
Os aspectos básicos deste progra,na fora,n esboçados acitna; poderíamos usar minha pequena
história co,no o pseudocódigo para o progran1a. Seria melhor refonnular rapidamente os deta-
lhes ern tnna definição mais clara do que o programa deve fazer:
1. Solicitar ao usuário um limite numérico superior e inferior.
2. Determinar utn número aleatório dentro desse intervalo; ele é o alvo.

3. Solicitar ao usuário utn palpite.


4. Se o palpite estiver correto, encerrar o jogo e informar ao usuário quantos palpites foram
' .
necessar,os.
5. Caso contrário, infonnar o usuário se o palpite é muito alto ou muito baixo e voltar à eta-
pa 3.
Esse pseudocódigo não é co1nplexo, mas há urn conceito novo nele que você ainda tem de apren-
der, a geração de nún1eros aleatórios . .Felizmente, o .N.ET Framework fornece tuna classe para
esse fi111, System. Random. Co,n esse objeto, é possível geraru,n número aleatório entre u1n li1nite
superior e um inferior com um código como o descrito a seguir:
Dim iTargetNumber,iUpperBound,iLowerBound As Integer
Dim objRandom As System.Random = New System.Random
iUpperBound = 100
i LowerBound = 1
iTargetNumber = objRandom.Next(ilowerBound,iUpperBound + 1)
120 Dia 4

NO T A
- Esse método de gerar números aleatórios retorna valores que são maiores ou
iguais ao limite inferior e menores que o superior (i LowerBound <= x < iUpper-
Bound). Você precisa especificar um valor superior que seja maior do que o mais
alto que deseja permitir. O código deste exemplo já faz isso.

Depois que o objeto Random tiver sido inicializado, você poderá chamar seu método Next se1npre
que desejar, e obterá um novo número aleatório a cada vez. Agora que sabe como obter um nú-
1nero aleatório, pode gravar o código 1nostrado na Listagein 4.20 para solicitar os limites ao
usuário e, em seguida, usar esses valores para obter seu alvo.

LISTAGEM 4.20 Obtendo as Informações Necessárias com o Usuário


1 Public Class NumberGuesser
2 Shared Sub Main()
3 Dim iTargetNumber As Integer
4 Dim iUpperBound As Integer
5 Dim ilowerBound As Integer
6 Dim iCurrentGuess As Integer
7 Dim iGuessCount As Integer
8 Dim slnput As String
9 Dim objRandom As System.Random = New System.Random()
10
11 System.Console.Write('' Insira o limite inferior: '')
12 sl nput = System.Console.Readli ne()
13 ilowerBound = Clnt(slnput)
14
15 System.Console.Write('' Insira o limite superior: '')
16 s l nput = System.Console.Readl ine()
17 iUpperBound = Clnt(slnput)
18
19 'Adivinhação do número
20 iTargetNumber = objRandom. Next(ilowerBound,iUpperBound + 1)
21 System.Console.Writeline(iTargetNumber)
22
23 End Sub
24 End Class

NaListage1n 4.20, você exibiu o número depois que o gerou. Isso é útil para testar seu progra1na,
rnas teria de ser rernovido ou isolado (marcado co1n um caractere de co1nentário no início ( ' )
para i_ndicar que não deve ser co1npilado) na versão final. E1n seguida, é preciso criar um laço
que solicitará repetida1nente u1n novo palpite até que o alvo seja adivinhado. Enquanto o progra-
ma estiver executando o laço, tan1bém precisaremos de outra variável para manter o registro da
quantidade de palpites que foram necessários para chegar ao alvo. Esse código ( v~ja a Listagem
4.21) teria de ser inserido antes da instrução End Sub para encerrar o progratna.
Controlando o Fluxo dos Programas 121

LISTAGEM 4.21 O Laço das Entradas de seu Jogo


1 iCurrentGuess = O
2 iGuessCount = O
3 Do While iCurrentGuess iTargetNumber
4 System.Console.Write(''Insira um palpite: '')
5 slnput = System.Console.Readline()
6 iGuessCount = iGuessCount + 1
7 iCurrentGuess = Clnt(slnput)
8
9 If i CurrentGuess < iTargetNumber Then
10 System.Console.Writeline( ''Seu palpite ê baixo!'')
11 Elself iCurrentGuess > iTargetNumber Then
12 System.Console.Writeline(''Seu palpite ê alto!'')
13 End If
14 Loop
15 System.Console.Writeline(''Você conseguiu em '' & iGuessCount & '' palpites'')

Combinadas, as duas listagens de código anteriores produze1n o jogo co1npleto que você poderá
compilar e tentar ganhar. E' bom remover o último comando 11ri tel i ne da Listage1n 4.21 antes
de jogar, ou pode ficar muito fácil. Há uma 1naneira bastante racional e, po11anto, chata de jogar,
que garante a obtenção da reposta correta com uma certa quantidade de palpites. Você pode ape-
nas fornecer a cada palpite u1n valor intermediário para o intervalo, por meio do critério alto/bai-
xo, para criar urn novo intervalo (com a metade da extensão) entre seu palpite e os lin1ites
inferior e superior. No jogo do exemplo, que usa de 1 a 100, esse 1nétodo assegura a descoberta
da solução em sete palpites (ou menos), com base em u1na fórmula 1nate1nática. Você sabe que
fór1nula informará a quantidade de palpites necessários para qualquer intervalo de valores? A
resposta estará na seção de exercícios desta lição.

Evitando Laços Complexos por Meio da


Recursão
Em geral, há mais de uma .maneira de resolver uin certo problema e, embora um laço-padrão pos-
sa funcionar, pode existir um modo mais si1nples. Se un1 problen1a for estruturado de 1nodo cor-
reto ou você puder reestruturá-lo da maneira certa, então, será possível usar a recursão co1no
alternativa aos laços cornuns. En1 prograrnação, a recursão ocorre quando um programa ou pro-
cedimento chama a ele próprio e.rn um esforço para resolver u1n problema. Os problemas que po-
dem ser solucionados por meio da recursão são aqueles nos quais um subconjunto deles te.1n
exatarnente a mesma estrutura que o seu todo. A 1nelhor rnaneira de explicar esse conceito é corn
um exemplo, o cálculo de u1n fatorial. A fó1111ula para o fatorial de um valor (n!) é
n(n-1 )(n-2) .. .(n-(n-1 ))( 1). Para urn valor como 1O, a fór1nula seria 1O* 9 * 8 * 7 * 6 * 5 * 4 * 3 *
1 122 Dia 4

2 * 1 = 3628800. (Observe que o resultado é be1n grande co1n relação ao valor de n.) Essa fónnu-
la pode ser expressa corn o uso de um laço For, corno vemos na Listagem 4.22.

LISTAGEM 4.22 Factori al . vb


1 Public Class Factorial
2 Shared Sub Main()
3 Dim slnput As String
4 Dim ilnput As Integer
5 Dim iCounter As Integer
6 Dim iFactorial As Integer
7 Sys tem.Console. Wri te ( 1ns ira um número:
11 11
)

8 slnput = System.Console. Readline()


9 ilnput = Clnt(slnput)
10 i Factori al = 1
11 For iCounter = O to (ilnput - 1)
12 iFactorial = (ilnput - iCounter) * iFactorial
13 Next iCounter
14 System.Console.Writeline(iFactorial)
15 End Sub
16 End Class

Quando experimentar esse programa, você precisará manter o valor de seu


NOTA teste ( 1Oem nosso exemplo) menor ou igual a 12. Qualquer valor maior produ-
zirá um fatorial que excederá o tamanho máximo de uma variável de inteiros
(veja o Dia 3). Se tiver de dar suporte a valores mais altos, use outros tipos de
variável como o longo.

No entanto, essa não é a única maneira de gerar urn fatorial já que essa fórmula também pode ser
expressa corno n * (n-1 )! , ou seja, n 1nultiplicado pelo fatorial de n-1. Essa expressão define a
fónnula recursiva1nente; a solução de um fatorial inclui outro fatorial. Po1tanto, essa é u1na defi-
nição 1nais clara que a da fór1nula n(n-1 )(n-2) ... (n-(n-1 ))(1) e, se você o escrever desse 1nodo
(veja a Listagem 4.23), produzirá utn código que ta1nbé1n será mais simples do que a rotina cor-
respondente da Listagem 4.22.

LISTAGEM 4.23 RecursiveFactorial .vb


1 Public Class RecursiveFactorial
2 Shared Sub Main()
3 Dim slnput As String
4 Dim ilnput As Integer
Controlando o Fluxo dos Programas

LISTAGEM 4.23 RecursiveFactorial .vb (continuação)

5 Dim iCounter As Integer


6 Dim iFactorial As Integer
7 System.Console.Write(''Insira um nümero: '')
8 slnput = System.Console.Readline()
9 ilnput = Clnt(slnput)
10 System.Console .Writeline(Factorial(ilnput))
11 End Sub
12
13 Shared Function Factorial(n as Integer)as Integer
14
15 If n = 1 Then
16 Return 1
17 El se
18 Return n * Factoria l( n-1)
19 End If
20
21 End Function
22 End Class

O código produzido pode não ser mais curto que o da Listagem 4.22, 1nas é 1nais siinples e, só
por isso, esse é um resultado válido. Observe que na função Facto ri a l ( ) , você procura n = 1.
Essa verificação assegura que as chan1adas recursivas finalmente seja1n encerradas, semelhante
ao que se consegue com a condição de saída em um laço. Sem ela, como no laço, o programa
nunca terá sua execução encerrada. A recursão pode ser usada para resolver muitos problemas, e
vere1nos códigos que a e1nprega1n em siste1nas de vários tipos (e espero que você escreva o seu).

Resumo
Nesta lição, examinamos as instruções de controle, a base de muitos dos progra1nas de computa-
dor que você criará no futuro. Com essas instruções, é possível co1neçar a converter processos
reais em progra1nas, priJneiro passando-os para pseudocódigo e, em seguida, usando esse recur-
so para gerar o código real necessário.

P&R
P Meu colega me disse que os laços hi l e são melhores que os laços Do e que nunca
devo usar o laço For! Que laço é o melhor?
R E1nbora seja possível usar apenas u1n laço e1n todos os seus progran1as, não se ganha
nada fazendo isso. No final, tudo que importa é que seu código seja o 1nais claro e sim-
ples que puder. Empregue o laço que 1nelhor resolver o problema. E1n geral, o laço For
124 Dia 4

funciona 1nelhor quando é preciso uma quantidade fixa de iterações; use un1 laço Do ou
Whi l e quando esse não for o caso.
P As instruções If de uma linha são mais rápidas que a forma If .. . End If?
R Não. O compilador do Visual Basic converte as duas fonnas no mes1no resultado, por-
tanto, não há diferença na velocidade de execução desses dois formatos. A diferença
principal está na facil idade de manutenção e leitw·a do código.
P Em versões anteriores do Visual Basice no Visual Basic for Application (VBA), usei
uma forma da instrução If chamada I nunediate If IIF . Ela existe no Visual Basic
.NET?
R Sim, existe. Mas só co1no eletnento de urn conjunto especial de objetos (Microsoft.Visu-
alBasic), projetado para fornecer acesso à instrução II F e muitas outras partes da últiina
versão do Visual Basic que não existem tnais no Visual Basic .NET. O fato de essas fun-
ções não estarem e1nbutidas na versão mais recente do Visual Basic pode significar que
elas reahnente não estarão disponíveis e1n fu turas versões. A variante II F é urna forma
1nuito útil da instrução If; como função, ela pode ser usada no 1neio de outra expressão,
por exemplo, quando u1na string é exibida. No entanto,já que as próxi1nas versões do Vi-
sual Basic poden1 não incluir a instrução II F, você deve evitar seu uso se possível.

Workshop
O Workshop foi planejado para aj udá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e começar a pensar e1n co1no colocar seu conhecirnento en1 prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".

Teste
1. Qual dos três métodos de laço disponíveis é mais adequado para un1 intervalo fixo deva-
lores?
2. Qual dos três 1nétodos de laço é o 1nais flexíve l?
3. Por que você deve tentar fazer com que o bloco de código interno e1n u1n laço seja o mais
sitnples possível?
4. Suponha1nos que você tivesse a expressão booleana a seguir e1n seu progra1na: Calcula-
tedTota l Net\~orth ( i CustomerID) < 10000 ANO dtCurrentDate.Hour > 12. O que poderia
fazer ser feito para assegurar que ela seja o mais eficiente possível?
Controlando o Fl uxo dos Prog ramas

Exercícios
1. Escreva o inverso do programa Nu1nberGuesser criado nesta lição - u1n progra1na com
limites superior e inferior que tente detenninar que valor foi selecionado pelo usuário.
Para cada palpite que o programa de co1nputador gerar, você terá de pennitir ao usuário
responder co1n "A" para 1nuito alto, "B" para muito baixo ou = para correto. Se preferir
usar o 1nétodo rac.ional nos palpites de seu progra.1n.a, então, a quantidade máxima de ten-
tativas necessárias poderá ser encontrada na resolução dessa equação: (2N>= Limite Su-
perior - Limite Inferior) onde N é a quantidade máxima de tentativas. Por exemplo, ern
utn intervalo de l a 100, a equação resultaria e1n 7 porque 26 = 64 e 2; = 128.
SEMANA 1

DIA

Arquitetura dos Aplicativos na


Plataforma .NET
No decorrer deste livro você está aprendendo a usar o Visual Basic .NET para criar aplicativos,
1nas as questões mais itnportantes se encontram na fase de projeto do processo de desenvolvi-
mento. Esta lição abordará
• O que é 'arquitetura do aplicativo' ?
• Que opções de arquitetura a plataforma .NET fornece?
• O que está envolvido na escolha de uma arquitetura de aplicativo?
Além da abordagem de alto nível desses tópicos, essa lição também inclui un1a discussão de al-
guns cenários e um estudo da determinação de arquiteturas para cada um deles.

O Que É a Arquitetura do Aplicativo?


Anterior à construção e 1nuito antes de um prédio estar pronto para ser usado, u1n arquiteto mani-
pulou a fase do projeto. Depois que se obteve urn consenso sobre sua concepção básica, são cria-
dos esboços que mostram as particularidades do edifício proposto com 1naior transparência e
forma1n a base do projeto detalhado que deve ser criado antes que qualquer trabalho de constru-
ção seja iniciado. No decorrer desse processo, não só no co1neço, o arquiteto com toda a equipe
do projeto, é responsável por produzir o resultado co1i-eto.
1128 Dia 5

O conceito de arquiteto, tanto o profissional quanto os aspectos do projeto pelo qual ele é respon-
sável, foi tomado e1nprestado pela indústria de desenvolvimento de soft\.vares. A semelhança su-
gerida entre as duas áreas não deve agradar aos verdadeiros arquitetos, e não os culpo por
ficare1n incomodados. Se os prédios fossern construídos da 1nesma 1naneira que a maioria dos
sistemas de software, então, passaria o resto de meus dias vivendo a céu aberto. Muito do que
está envolvido no desenvolvin1ento de softwares empresariais é feito se1n planeja1nento suficiente,
resultando em siste1nas que são instáveis, com tnanutenção dificil e quase sempre com um orça-
1nento 1nuito alto.

Função do Arquiteto de Softwares


Independenten1ente da apropriação do nome de uma profissão existente, as sen1elhanças podem
ser traçadas. Quando um edifício está em fase de projeto, os arquitetos usam seu conhecimento
avançado tanto da função quanto do projeto para idealizar e planejar sua estrutura e fundação ge-
ral co1n base nos requisitos que forneceran1 a eles. Com os softwares, o n1esrno processo ocorre.
Um arquiteto de softwares (ou sistemas) desenvolve urn planejan1ento para construir o sistema
co1n base en1 requisitos. Nos dois casos, o planejamento no final se toma um projeto detalhado
de como deve ser construído, e outras equipes de profissionais se encarregam de 1nani pular a im-
ple1nentação real.
E1nbora algumas pessoas não consiga1n ver essa atividade co1no algo próximo à complexidade
do projeto e construção de un1 imenso arranha-céu, o desenvolvin1ento de soft,vares é complica-
do, e a função de um arquiteto é de extrema necessidade e1n sistemas de quase todos os tama-
nhos. lndependente1nente da di1uensão do aplicativo que você estiver construindo ou de quão
pequena for sua contribuição individual para o siste1na, uma arquitetura terá sido escolhida (tal-
vez de 1nodo informal) e estará sendo usada.

Em projetos menores, é possível gerenciar sem um arquit et o, mas o que esta-


NOTA rá ocorrendo é que você (ou outro membro da equipe de desenvolvimento)
terá informalmente assumido essa função. O problema das pessoas que assu-
mem a função de projetista informalmente é que a equipe não tem consciência
de quem é o responsável por nenhum dos aspectos específicos do projeto.

Você pode ser u1u iniciante no Visual Basic ou ta1nbén1 no desenvolvimento. Talvez não queira
assumir o papel do arquiteto de sistemas no futuro próxin10. Mas isso não altera a necessidade de
compreender o processo e as decisões sobre a arquitetura que serão to1nadas em qualquer projeto
com seu envolvilnento. No ciclo de evolução do desenvolvimento de sofuvares, a equipe inteira
deve estar envolvida no processo integral, poré1n o arquiteto éo principal condutor do planejamen-
to nas fases inicias da Definição/Escopo, Análise das Necessidades e Projeto (veja a Figura 5.1).
Arquitetura dos Aplicativos na Plataforma .NET 129

FIGURA 5.1
No ciclo de evolução
do desenvolvi,nento de
soft1vares, a
arquitetura está
envolvida
principalll1ente nas
prilneiras fases, e,11
que o sistema é
projetado.

Depois dessas fases iniciais, o foco passa para a equipe de in1ple1nentação (desenvolvedores de
soft,vare) e, en1 seguida, para os grupos de implantação. O ideal é que a pessoa que assu1nir a
função de arquiteto seja altamente experiente, corn bastante conhecitnento técnico para avaliar
todas as opções disponíveis e habilidade operacional suficiente para interpretar con1 correção os
requisitos do siste1na. Em geral, o papel de arquiteto é desernpenhado por me,nbros da categoria
sênior de u1n grupo de desenvolvimento.

Que Partes de um Sistema São Consideradas Arquitetura


do Aplicativo?
Utna resposta breve para essa pergunta seria 'todas', 1nas ela é muito abrangente para ser útil. Os
aspectos que envolve1n a arquitetura de u1n siste1na são os 'grandes detalhes', como que tipo de
interface com o cliente será usada, se serão executados aplicativos Winclo,vs ou da Web e co1no
o código da página da Web se co,nunicará con1 o banco de dados de back-end. O aspecto princi-
pal é que a arquitetura do siste1na tem relação co1n a base e a estruturado aplicativo, e não com as
opções de implementação que serão selecionadas dentro dessa estrutura.
O arquiteto, no entanto, será envolvido na fase de ilnple1nentação, mesmo se parecer que todos
os 'grandes detalhes' já fora1n detern1inados e só restara1n os 1nais fáceis relacionados à i1nple-
1nentação. Ele continua engajado por duas razões principais: para verificar se a arquitetura esco-
lhida provou ser a correta (fazendo os ajustes necessários para lidar com os proble1nas que
aparecerem) e para se ce1tificar de que o projeto esteja sendo implementado como foi planejado.
Pode ser difícil de acreditar, mas às vezes os desenvolvedores se desviam do projeto de um siste-
ma, produzindo resultados indesejados.
Para responder a pergunta. mais especifica,nente, e,n siste,nas .NET, a arquitetura deve fornecer
uma visão geral de alto nível de cada aspecto do aplicativo. O essencial é o nível de detalhes; a
maioria dos itens discutidos na fase da arquitetura será abordada nova1nente no projeto detalha-
1130 Dia 5

do e na implementação. Por exemplo, parte da arquitetura do sistema pode ser uma discussão so-
bre segurança, e nesse nível a declaração a seguir poderia ser suficiente para abordar esse tópico:
"O aplicativo baseará suas permissões de segurança nos usuários e e1n grupos do Windo"vs 2000
já em uso na empresa". Essa declaração é o bastante co1no ponto de partida; o próximo nível se
tornaria mais detalhado e poderia incluir infonnações sobre que áreas do aplicativo serão prote-
gidas e a quen1 será concedido acesso para cada área específica.
Na fase de i1nplementação ou desenvolvirnento, o programador teria de detenninar exatarnente
corno encontrar o logon do grupo e do usuário do Windows, mas esses detalhes decerto não
fazem parte da arquitetura do sisterna. E1nbora ela aborde tudo em u1n nível superior, as áreas-chave
a seguir devem ser reconhecidas como parte de qualquer arquitetura de aplicativo:
• Distribuição física e lógica dos códigos (que código será executado onde?)
• Tecnologias usadas na interface com o usuário, bancos de dados e lógica. operacional
• Método de comunicação entre co1nponentes diferentes do siste1na e enh·e esse e os outros
siste1nas da ernpresa
• Segurança
• Acesso aos dados
• Escalabilidade e disponibilidade
Cada u1na dessas áreas é por si só importante, mas a arquitetura é a co1nbinação de todos esses
fatores e1n um projeto que funcione como um todo. A finalidade de cada área será abordada nas
- segumtes.
seçoes .

Distribuição Lógica e Física dos Códigos


No nível da arquitetura, as decisões pode1n ser tomadas com base em u1na organização pretendi-
da, pen11itindo que os códigos sejam categorizados em grupos co1no código de acesso aos da-
dos, código de segurança, código de inte1face com o usuário e outros. Na realidade, qualquer di-
visão de códigos depende de cada programador e do resto da equipe do projeto. Nada relaciona-
do à platafonna .NET (ou qualquer outra ferrarnenta de desenvolvimento) o forçará a manter os
códigos agrupados de n1aneira organizada. No entanto, não deixe que a realidade o bloqueie;
para as finalidades do projeto, é irnportante categorizar os códigos mes,no se essa organização
nunca existir efetivainente. O que deve ser detenninado sobre esses grupos é onde serão execu-
tados; serão todos processados co1no parte de u1n único aplicativo e1n apenas uma rnáquinaou o
código de acesso aos dados será executado ern um servidor independente?
Mais à frente nesta lição, abordarei o conceito de ca1nadas, e1n que toda a funcionalidade de um
aplicativo é dividida de rnodo lógico. Essas camadas são, então, tratadas como se fossem con-
juntos de código independentes, os quais podem ser movidos à vontade. As decisões a respeito
de onde executar cada ca1nada de um aplicativo e de quantos servidores serão usados para cada
uma delas constituem esse elemento da arquitetura do siste1na.
Arquitetura dos Aplicativos na Plataforma .NET 131

Tecnologias
Urna das áreas mais objetivas, esse elemento da arquitetura do siste1na traça u1n esboço 'geral'
das tecnologias que serão usadas. O segredo nessa área é disponibilizar infonnações suficientes
para ser útil, enquanto detalhes que possam não ter sido determinados ou sejam in·elevantes no
nivel da arquitetura deve1n.ser evitados. Considere esses dois trechos (não se preocupe em com-
preender os detalhes, só existem para atender à fi nalidade do exemplo):

Exemplo 1:
A equipe do projeto desenvolverá a interface co1n o usuário por 1neio do Visual Basic 6.0 (Servi-
ce Pack 5) e de um controle de grade ActiveX do Janus. Várias janelas serão criadas, todas com
1nenus, un1a grade principal e diversos botões funcionais. Esses fonnulários empregarão o
DCOM para se conectare1n com os servidores da camada intennediária, os quais executarão o
Windows 2000 Advanced Server (Service Pack 2). Os servidores da camada intennediária hos-
pedarão cinco componentes dentro do ambiente de serviços do co1nponente do COtvl+ do Win-
dows 2000. Esses componentes operacionais serão DLLs do COM, construídas con1 o uso do
Visual Basic 6.0 (Service Pack 5) e com suas propriedades configuradas como Public. Cada
componente será co1nposto de ...

Exemplo 2:
A interface con1 o usuário será baseada em fonnulários e usará o DCOM para se comunicar com
a camada intermediária. Dentro dessa camada, os objetos operacionais do COM terão sido insta-
lados no COM+ e man ipularão a comunicação co.m a ca1nada de dados. O ADO será en1pregado
para conectar a camada intennediária co1n os dados de back-end, e todas as infonnações serão
retornadas para a camada de apresentação depois de passarem pela comercial.
En1bora o Exemplo 1 tenha sido interro1npido, na verdade ele não estava ne1n perto de ser con-
cluído e ainda tinha de trans1nitir tantas infonnações úteis quanto o Exemplo 2. O segredo é se
lernbrar sempre do principal, que é conseguir descrever a arquitetura. Ainda falta,n o projeto de-
talhado e as fases da implementação para rnanipular a entrada nesse nível de particularidades.
Outra regra interessante é nunca passar muito tempo discutindo tecnologias específicas. Tente se
concentrar e só discutir a tecnologia em termos do que ela trará para esse projeto.

Comunicação entre Componentes


Se você estiver desenvolvendo tnn sistema distribuído, para ser executado em várias n1áquinas,
então, algu,na forma de comunicação precisa existir entre os diversos co1nponentes. Há muitas
opções diferentes, ,nas no nível da arquitetura, só é preciso ser específico com detalhes que já fo-
re1n defmitivos ou relevantes devido a algum outro aspecto do projeto. Nessa área, pode ser ne-
cessário definir o protocolo de co1nunicação se tivennos de nos conectar com outro sistema ou se
os detalhes técnicos forem cruciais para u1n projeto paralelo como a configuração da
1 132 Dia 5

rede/fire\vall. A platafonna .NET fornece várias opções diferentes para esse tipo de comunicação
incluindo o SOAP.

Segurança
U,n título indefinido para Lima área vaga, a segurança é u1n tópico que deve ser considerado ape-
nas porque toda discussão acaba por abordá-lo e pennanece aí se ele já não tiver sido detalhado.
A arquitetura deve detalhar como a segurança será proporcionada (usando o Windows 2000
Active Directory, por exe,nplo) e conceitualmente co,no será in1ple1nentada ("as opções de in-
terface ficarão ocultas" ou "a segurança será verificada a cada página/forn1ulário"). E' necessário
detalhar exata,nente co,no os progra,nadores Ílnple,nentarão esses recursos.

Acesso aos Dados


Que áreas de código acessarão os dados? Co,no farão isso? Esta seção detalha con10 o aplicativo
se conectará aos dados (provedor OLEDB usando a segurança do SQL Server, por exemplo).
Questões ,nais complexas, corno o projeto e a organização do banco de dados efetivo, são ,nais
bem definidas na fase do projeto detalhado ou como parte da implementação final.

Escalabilidade e disponibilidade
Esses são dois tópicos in1portantes e complexos e u1na das principais razões pela qual a arquite-
tura dos aplicativos recebe tanta atenção. Eles estão relacionados de muitas 1naneiras: as técnicas e
a arquitetura usada para fornecer u,n serviço em geral são utilizadas para disponibilizar o outro.
A escalabilidade descreve a capacidade de um siste,na de manipular cargas maiores, fornecendo
o ,nesmo nível de serviço (te1npos de resposta, quantidade de solicitações por segundo e assim
por diante) por ,neio de um incre,nento no hardv,rare. Lembre-se de que essa não é u,na n1edida
de dese1npenho; um siste1na pode ser escalonável e ter um péssi,no dese1npenho. Como assegu-
rar que u,n apl icativo possa ter u,na boa escalabilidade está além do escopo desta lição e deste li-
vro, mas un1 link para outros recursos será fornecido no final deste capítulo caso você esteja
interessado en1 uma abordage1n ,nais profunda desse tópico.
A disponibilidade é uma medida que aval ia com que freqüência o siste,na está e,n execução e
pode processar solicitações. Agora que os aplicativos da Web co1n interface pública estão sendo
desenvolvidos, a necessidade de siste1nas que estejam se1npre disponíveis está sendo difundida.
Em geral esse conceito é descrito como 'te,npo de funcionamento' e em tennos da quantidade de
'algarismos nove' existentes na medida de disponibilidade que u1n sistema tetn fornecido. O ter-
mo 'a!garis1nos nove' se refere ao te1.npo de funciona,nento de 99% (dois algarismos nove),
99,9% (três algaris,nos nove) ou maior que u1n sistema possui. Enquanto redigia esta seção, al-
guns sisternas de uso co,nercial foram registrados com um te,npo de funcionarnento igual a cin-
co algarismos nove (99,999%). Etn tern1os práticos, um site com utn te1npo de funcionamento de
cinco algaris1nos nove teria estado inativo por somente cinco 1ninutos em u1n ano inteiro (24 ho-
ras por dia, 7 dias por semana). Isso quase parece ridículo, e excede 1nuito meu tempo ativo no
Arquitetura dos Aplicativos na Plataforma .NET 133

trabalho, mas se você estiver executando um site con10 o Amazon.com, então, ficar inativo de al-
guma 1naneira pelo espaço de te1npo que for é inaceitável.
Criar um siste1na com esse nível de disponibilidade é uma combinação de projeto e processo. Do
ponto de vista do projeto, o sisten1a deve estar completa1nente a salvo de estouros de memória ou
outras falhas que impediriam o uso contínuo e deve poder ser executado e1n várias outras máqui-
nas,já que 1núltiplos grupos de hardware tê1n de ser usados para fornecer redundância. Do ponto
de vista do processo, no entanto, tudo é ainda mais complexo. Por exetnplo, atualizações de soft-
\.vare terão de ser feitas de maneira seqüencial para que o conjunto de servidores nunca fique in-
tegrahnente inativo. As discussões sobre o ten1po de funcionamento e1n geral se concentra1n no
sistema operacional ou na tecnologia específica do servidor de banco de dados /servidor de com-
ponentes/servidor Web em uso, sugerindo, digamos, que o Windov.1s 2000 fornece uma certa
quantidade de algarismos nove de tempo de funcionamento. Essa não é u1na discussão realista.
O siste1na operacional ou o servidor do banco de dados é só Lnna parte do siste1na, e tudo causa
impacto na sua capacidade de manter uma disponibilidade alta.

Arquiteturas Viáveis na Plataforma .NET


Não há L11na quantidade fixa definida para as arquiteturas que podem ser desenvolvidas - todas
as opções diferentes poderia1n ser combinadas para produzir u1n universo de variações -, mas
existe1n certas arquiteturas generalizadas dentro das quais a 1naioria dos sistemas .NET tàlharia.

Os Três Elementos de Qualquer Aplicativo


As diferenças entre todas as arquiteturas possíveis residem e1n como as três ca1nadas distintas de
utn siste1na de computador são distribuídas. Essas três ca1nadas são listadas aqui, junto a uma
descrição breve:
• Apresentação Esta ca1nada representa a interface co1n o usuário e outros sistemas, o
aspecto fisico público do sistetna.
• Lógica Operacional Todo os códigos que não estejatn envolvidos, etn particular, na
criação da interface com o usuário ou outros aspectos da catnada de apresentação. Estaca-
1nada representa o núcleo do aplicativo, o código que realmente faz o trabalho do sisten1a.
• Dados O banco de dados (ou outra fonte de dados como a XML) e o código que o
acessa são considerados a ca1nada de dados.
Essas três camadas são a representação lógica de um sistema co1npleto, 1nas esse pode assumir
várias for1nas: u1n único programa executável, componentes distribuídos na quantidade de servi-
dores que se desejar, ou um simples site da Web. Tndependenten1ente do aplicativo e1n particu-
lar, é útil descrever todos os sistemas com relação a essas três camadas.
134 Dia 5

Quantas Camadas?
U,na das n1aneiras n,ais co1nuns pelas quais as arquiteturas de aplicativos tên1 sido descritas é
en, tennos da quantidade de ,náquinas diferentes que executa1n partes do sistema. A arquitetura
1nais simples é apresentada como u1n sistema de ca1nada única, e1n que o programa (apresenta-
ção, lógica operacional e dados) está todo em u1na n1áquina. Essa é a arquitetura e,npregada pela
maioria dos aplicativos cornerciais como o Microsoft Office e 1nuitos softwares empresariais
projetados para sere,n usados por alguns usuários ao mesmo tempo. Só as máquinas que execu-
tarem alguma forma de processa,nento são i1nportantes. U,n progra,na em que os arquivos de
dados esteja1n localizados en1 um servidor de arquivos também é considerado um aplicativo de
ca,nada única porque todo o trabalho efetivo é feito em u1na 1náquina, e o servidor de arquivos
apenas fornece u1n local na rede para arn1azenar dados.
Por outro lado, quando u,n servidor de banco de dados (con,o o SQL Server ou o Oracle) é usa-
do, então, ele é considerado uma segunda camada porque realmente executa u,n processamento.
Os sistemas que possuem um software cliente (e1n geral na máquina de mais de uma pessoa) que
se conecta de modo direto co,n u,n banco de dados de back-end são cha1nados de aplicativos de
duas camadas ou cliente/servidor. A arquitetura cliente/servidor é comum nos aplicativos em-
presariais. Ela pern1ite que 1nuitos usuários trabalhe1n co1n o 1nes1no conjunto de dados enquan-
to fornece um dese1npenho muito melhor do que um sisteina com base em arquivos, coino o
Microsoft Access.
Para concluir, a fonna ,nais recente de arquitetura de aplicativo é chamada de três ca1nadas ou
várias camadas e descreve sisten1as e1n que o código é executado e1n três ou n1ais seções distin-
tas. A divisão lógica de u1n sisterna desses tambétn é co1nposta de três ca1nadas, ,nas o layout ti-
sico pode exceder três grupos distintos. Em geral, isso significa que algum tipo de código
cliente, co1no u1n site interativo da Web ou talvez um aplicativo Windows, que cha1na um códi-
go executado ern outro servidor ou conjunto de servidores para manipular a lógica operacional, e
urn banco de dados de back-end estão sendo usados. Essa arquitetura está se tornando 1nais po-
pular porque fornece muita flexibilidade para a manipulação de diversos usuários e, portanto, é
bem adequada para aplicativos coin base na Internet. Há várias maneiras técnicas diferentes de
criar aplicativos de três camadas, ,nas o 1nétodo recomendado pela Microsoft antes da platafor-
ma .NET se tornar disponível era cha1nado de Windows DNA.

Windows DNA
O Windows Distributed Netv.1ork Architecture (ou Distributed interNet Architecture, dependen-
do de onde você encontrar sua definição), é o conjunto de tecnologias e diretrizes da Microsoft
anteriores à plataforma .NET para criação de sisteinas de três camadas. Coin base na idéia geral
de que todo apl icativo pode ser dividido e1n três ca1nadas, de Apresentação, Lógica Operacional
e Dados, o Windows DNA. esboçou a 'melhor' maneira de desenvolver sistemas distribuídos.
E1n um aplicativo Windo,~1s DNA, o código-cliente era executado como um aplicativo Windows
padrão ou co1no uma interface da Web criada co1n o Active Server Pages. O código-cliente con-
Arquitetura dos Aplicativos na Plataforma .NET 135

tinha apenas a lógica relacionada à interface e acessava toda a operacional chamando co1npo-
nentes do COM localizados localmente ou em outro servidor, co1nponentes que, então, se
encarregariatn de interagir com o banco de dados.
Utn princípio essencial do 1nodelo Windows DNA para desenvolvi1nento de aplicativos é que
tudo flui através de três camadas, de ,nodo que a ca,nada de apresentação se co1nunica apenas
com os objetos operacionais, e esses 1nanipula1n toda a co1nunicação co1n o banco de dados. A
cainada de apresentação nunca acessa diretamente o banco de dados e, po1tanto, as três ca1nadas
são abstratas, o que proporciona a possibilidade de alternar o banco de dados sem que seja preci-
so reescrever toda a interface con1 o usuário, ou criar u1na interface totaln1ente nova se1n ser ne-
cessário alterar a can1ada operacional ou o banco de dados. A flexibilidade obtida nesse modelo
1nais do que compensa qualquer trabalho adicional envolvido para assegurar que as três ca,nadas
sejam apropriadamente independentes.
Agora, embora o modelo Windows DNA seja be1n detalhado, a imple1nentação real pode ter
tuna entre várias configurações diferentes. E,n um caso, o aplicativo poderia executar tudo e,n
um servidor, con1 o Active Server Pages (interface da Web) se co,nunicando co,n os co1nponen-
tes (provavehnente escritos etn Visual Basic 6.0), que, por sua vez, funcionariam co,n tuna insta-
lação local do SQL Server. Apenas uma máquina é usada, mas as três ca1nadas ainda são
distintas, e o modelo Windovvs DNA é mantido. De modo alternativo, o 1nodelo também pode
ser expandido para quantas n1áquinas fore1n necessárias a fi,n de manipular a carga do siste1na.
U1n siste1na possível poderia e,npregar u1n grupo de 20 servidores Web, todos atendendo ao
Active Server Pages, que se conectaria a um agrupamento de máquinas com balancea1nento de
carga executando o 1nesn10 conjunto de con1ponentes do COM, que, por sua vez, acessariam um
par de servidores processando o SQL Server em u1na configuração de grupo. Apesar da imple-
mentação e1n escala 1nuito maior, o mes1no 1nodelo está sendo adotado, o que demonstra a flexi-
bilidade e escalabilidade do Windows DNA de três ca1nadas que o tornou tão popular.

Onde a Plataforma .NET Se Encaixa7


A platafon11a .NET é un1a mudança radical no desenvolvunento, mas podem ser aplicados a ela
os 1nes1nos conceitos gerais de arquitetura. Muitos siste1nas .NET segue1n os modelos e exem-
plos discutidos anterionnente e pode1n ser classificados co1no de so1nente u1na ca1nada, clien-
te/servidor ou até como aplicativos \\'indows. A tecnologia pode mudar (ASP.NET em vez de
ASP, classes .NET em vez de objetos do COM e assim por diai1te), 1nas a arquitetura ainda é a
mesma. No entanto, algu1nas outras opções estão disponíveis para apri,norar a arquitetura do
Windows DNA quando a plataforma .NET for usada.
O pri1neiro conceito novo envolve a comunicação entre as camadas. No Windows DNA tradi-
cional, as páginas da Web se con1unicavam com os objetos operacionais do COM usando o
DCOM (Distributed COM), que é um padrão binário usado para ligar todos os aplicativos confi-
gurados para COM através de uma conexão de rede. A abstração entre as camadas é litnitada por
esse ,nétodo de con1unicação porque só é possível e1npregar as tecnologias que pode1n usar o
1136 Dia 5

COM nas ca1nadas de apresentação e operacional. No Windo,vs DNA convencional, você pode-
ria reescrever seus objetos operacionais se1n ter de alterar a camada de apresentação ou de dados,
1nas apenas se estivesse utilizando u1na linguagem compatível com o COM (em geral o Visual
Basic ou o VC++). A platafonna .NET introduz u1na nova 1naneira de comunicação que pode
permitir a abstração real entre as camadas, o SOAP (Si1nple Object Access Protocol).
A comunicação do SOAP é toda feita com o uso da XML, e1n vez de u1n formato binário, e é exe-
cutada antes do conhecido protocolo HTTP. Para o desenvolvimento de aplicativos distribuídos,
isso significa que qualquer linguagem/ferra1nenta poderia ser usada para criar as ca1nadas do sis-
te1na. Seria possível que os componentes já existentes e1n sua e1npresa estivessem escritos em
Java, que poderia fornecer a camada de apresentação do sisten1a, enquanto o front-end estaria na
plataforma .NET usando o ASP.NET ou um aplicativo Windov.is. A versão .NET do Windows
DNA é até 1neU1or do que antes quando ele ernpregava o conjunto antigo de tecnologia para de-
senvolvi1nento.

Escolhendo uma Tecnologia de Cliente


U1na das escolhas mais polêmicas quando se projeta um sistema é que tipo de cliente será criado,
que em geral é uma discussão sobre a possibi lidade de do tipo'thick' ou do tipo ' thin' . As princi-
pais opções na platafonna .NET são as mesmas que já estão disponíveis por algum tempo,
ASP.NET para criar u1n aplicativo da Web ou Windo,vs Fonns (Fonnuláriosou Aplicativos
Windows) para gerar Llln aplicativo Windows. O segredo é detenninar qual é 1nais adequada
para u1n siste1na ou projeto específico. As seções a seguir descrevem as duas tecnologias, abor-
dando seus beneficios e problemas. Posso fornecer a você tuna regra simples para informar que
tecnologia usar e1n qual situação? Não, 1nas ainda nesta lição, disponibilizarei uma Iista geral de
perguntas que pode ser usada para ajudar a to1nar várias decisões sobre a arquitetura, incluindo
que tipo de cliente usar.

Sistemas de cliente do Tipo 'Thin' (ASP.NET)


As Active Server Pages são desenvolvidas co1n o uso das linguagens .N-ET padrão (co1no o Vi-
sual Basic.NET) e são projetadas para processar solicitações recebidas de usuários e retornar o
resultado apropriada em seus navegadores. O código que você escrever para urna página
ASP.NET será executado no servidor Web, e não no cliente, que é o ponto mais iinportante
quando se compara esse tipo de interface co1n qualquer outra. O ASP.NET não possui nenhum
requisito de cliente além do acesso à rede e algu1na fonna de navegador. Pode1n ser desenvolvi-
das páginas ASP.NET que exiban1 u1n conteúdo HTML 1nais sofisticado e que termine co1n uma
saída que precise da maior e 1nais recente versão do Internet Explorer, mas essa é u1na opção ex-
clusiva1nente sua. Ta1nbém é possível escrever as páginas da Web de 1nodo que elas retomem o
conteúdo HTML 1nais si1nples já visto, pennitindo que até o pri1nitivo navegador Mosaic consi-
ga visual izá-las. O sisten1a operacional do cliente tan1bé1n não é un1 problema. Exatamente
como na Web, suas páginas podem ser visualizadas de qualquer plataforma em que a Internet
esteja disponível.
A rqu itetura dos Aplicativos na Plataforma .NET 137

Continuando nessa 1nesma linha de raciocínio, a falta de requisitos de cliente significa que para
seu aplicativo ser executado, nada (além do requisito básico de um navegador da Web de algu1n
tipo) precisa ser instalado no computador do usuário. Quando você atualizar seu site, alterando
as páginas armazenadas e1n seu servidor, o próximo usuário a acessá-lo verá a nova versão, e ne-
nhu1n outro proble1na relacionado à atualização ou distribuição. Todos esses beneficias que re-
sultam da fa lta de requisitos de cliente ton1an1 a escolha de u,na interface da Web relativan1ente
fácil, exceto por doi.s pontos:
• A experiência que o usuário te1n co1u urn navegador da Web ainda não é tão boa quanto
com um aplicativo Windows. Considere alguns dos aplicativos Windows que você tem
utilizado, co1no o JVlicrosoft Office, o Visual Studio .NET, o Adobe Photoshop e outros, e

perceberá que quase nada na Web chega próxirno do nível da interface co1n o usuário. E
possível produzir u1na interface na Web que seja se,nelhante, ,nas o trabalho necessário
será 1nuito maior se co1nparar1nos com um aplicativo Windows.
• Um aplicativo ASP.NET e1n geral só funciona quando o usuário está conectado e seus re-
cursos são afetados pela velocidade dessa conexão.
Alguns ·itens apenas não funcionatn em urn sisterna com base na Web, coino uma experiência
off-line igualmente funcional e satisfatória. Por exe1nplo, o Outlook é capaz de funcionar on-line
ou off-line, ,nas sua contrapartida na Web, o Outlook Web Access, não possui nenhuma fun-
cionalidade off-line. Un1 progran1a projetado para trabalhar com arquivos ou outros aspectos 'lo-
cais' de seu sistema não terá um desen1penho tão bom se transferido para utua interface com o
usuário con1 base na Web.
Concluindo, é dificil encontrar razões contra o uso de u1na interface da Web, e há 1nuitas vanta-
gens en1 desenvolver u1n sistema dessa 111aneira.

Aplicativos Windows (Windows Forms)


En1 geral, é difícil explicar o que quero dizer com 'aplicativo Windows' porque esse é o único
tipo de aplicativo que a tnaioria das pessoas já viu. Basicamente, urn aplicativo Windows é algo
que você pode criar usando un1a co1nbinação de janelas e caixas de diálogo para ser executado na
platafonna Windows. Quase todos os aplicativos que estamos acosturnados a uti Iizar - o Micro-
soft Office, o Quicken e até o Sol itaire - são exe1nplos do que pode ser desenvolvido co1n o uso
dos recursos do Windov.,s Forms da platafonna .NET.
Depois de ler a seção anterior sobre o ASP.NET, você pode estar se perguntando por que não
usar se1npre uma interface da Web, e não é o único. Um aplicativo do Windov.rs Fonns possui al-
guns requisitos para a 1náquina cliente:
• O .NET Fra111ework deve ser instalado no cliente, enquanto no caso do ASP.NET, só é ne-
cessário no servidor Web.
• O Framework só é executado em platafonnas Windows.
• Seu aplicativo deve ser instalado.
138 Dia 5

• Atualizar seu aplicativo e,n geral significa lidar com todos os 1nicrocomputadores de al-
guma maneira (ferramentas automatizadas ou opções de download de rotinas ou drivers
específicos pode,n eli1ninar u,n pouco desse esforço).
A dependência da máquina-cliente possui Lun efeito colateral pernicioso quando se está lidando
co,n aplicativos públicos; o dese,npenho de seu aplicativo dependerá de uma 1náquina sobre a
qual você não tem nenhum controle.
Todos esses requisitos fazem parecer que a opção entre cliente do tipo 'thick' (n1ais robusto) e do
tipo 'thin' (1nais siinples) não é absolutan1ente u,na tomada de decisão. Na verdade, contudo,
ainda há várias vantagens interessantes nos aplicativos do Windows forros que valern a pena
1nencionar. A pri1neira grande vantagem é que o desenvolvedor que usar o Windo,vs Fonns po-
derá criar interfaces com o usuário co,npletas e funcionais e será possível fazê-lo muito mais rá-
pido do que com o ASP.NET. Apesar de todos os avanços na tecnologia da \\'eb, ainda é mais
dificil gerar tuna interface complexa nesse local do que no Windo,vs.

Muitos desenvolvedores da Web não concordariam com meus comentários de


NOTA que o ASP.NET é mais difícil de usar no desenvolvimento do que o Windows
Forms, mas apesar das diversas virtudes que apresenta, é aí que ele se torna
complicado.

U1na segunda vantagem está no desen1penho da interface co1n o usuário, u1na interface do Win-
dows e1n geral responde 1nelhor (responde rnais rápido aos cliques e outras ações do usuário).
Para concluir, a última vantagem em usar o Windows Forms é que há aqueles itens (uso off-line,
processamento 1nais rápido de objetos locais, como por exe1nplo, arquivos) que simplesmente
não podern ser realizados na Web.

Com o uso do Dynamic HTML, controles ActiveX e outras tecnologias mais


NOTA complexas da Web é possível melhorar algumas das questões descritas anterior-
mente. Ao fazer isso, no entanto, algumas vantagens do ASP.NET serão perdi-
das já que você estará criando um aplicativo com suporte restrito às platafor-
mas (os controles ActiveX só são executados em certos sistemas operacionais
e processadores, e o Dynamic HTML não tem suporte em qualquer navegador)
e que pode até ter alguns requisitos de implantação.

Decidindo Que Arquitetura Usar


Tomar uma decisão efetiva quanto à arquitetura, mes1no antes das alterações específicas do apli-
cativo sere1n feitas, decerto valerá a pena independente1nente de quanto você precisar pagar para
uin desenvolvedor de sisternas experiente. Se tomar a decisão errada nesse momento, todo o pro-
Arquitetura dos Aplicativos na Plataforma .NET 139

jeto pode estar fadado à falha. E' claro que os erros sempre poderão ser con·igidos, mas nesse
caso, 1nuito trabalho poderia ser eliminado se tuna nova arquitetura precisasse ser selecionada.

Fatores Essenciais Que Influenciarão Sua Decisão


O fator 1nais i1nportante na escolha da melhor arquitetura são os requisitos do siste1na. Esses de-
talhes, obtidos co1n os líderes operacionais do projeto e seus futuros usuários, devem especificar
1ninuciosa1nente o que o sistetna precisa fazer. Após conhecê-los, o segredo será projetar un, sis-
tetna que possa 1nanipular essas necessidades. Você pode analisar tun resumo dos requisitos de
siste1nas na seção "Exemplos de Cenários" para ter un,a percepção dessa to1nada de decisões,
,nas prirneiro fornecerei u1n conjunto de perguntas para sere,n fonnuladas quando for interpretar
os requisitos ou examinar utn grupo já existente deles.

NOTA
-- Com base em minha experiência, e por ter observado a de outras pessoas que
não foi muito agradável, recomendo nunca desenvolver um sistema (ou proje-
tar estimativas ao desenvolver um) com base nos requisitos interpretados pe-
los outros. Por outros quero dizer alguém que não seja você ou um membro de
sua equipe em cujo trabalho confie. Requisit os incorretos em geral resultam
em um sistema inadequado e terminarão definitivamente em uma estimativa
inválida. Depois de ocorrido, culpar os requisitos fornecidos não irá ajudar,
portanto, certifique-se de que você ou um membro de sua equipe esteja envol-
vido na documentação deles. Se isso não for possível, então, estabeleça um
tempo maior a seu projeto para revisar a análise dos requisitos existentes e
para examinar qualquer parte obscura pesquisando diretamente a fonte (o
pessoal operacional por trás do projeto, os usuários ou mesmo um sistem a an-
terior que executasse as mesmas ações).

Plataforma Cliente
Como parte de seu planejamento, você precisa saber alguns detalhes sobre a platafonna en, que
seu sisten,a será executado:
• Que siste1nas operacionais estão instalados nos siste1nas de destino?
• Quais são as especificações de hardware das 1náquinas de destino (CPU/RAM/espaço em
disco)?
• Qual o nível de controle que a ernpresa te1n sobre as 1náquinas de destino? Ela controla a
configuração, a instalação do softv.,are e a proteção contra vírus? Soluções extrernas para
essas questões seriam um servidor só para ter1ninais burros em tuna extrem.idade e com-
putadores públicos de propriedade dos usuários na outra.
• Algum dos co1nputadores clientes é um laptop? O acesso off-li11e ou ren,oto é necessário?
Serão precisos serviços de discage1n ou eles já existe1n?
1140 Dia 5

Rede
Muitas opções relacionadas à arquitetura, con10 o tipo de cliente, a replicação de bancos de da-
dos e o protocolo usado dependem da rede em que o sistema será executado:
• Qual a velocidade de comunicação disponível entre os usuários e os servidores de
back-end (ou o que estará disponível, se os servidores de back-end ainda não existiren1)?
• Os serviços de acesso re1noto serão necessários e/ou fornecidos? VPN? Dial-up?
• Os computadores-cliente tê1n acesso à Internet?
• 1-Já algu1n soft"vare/hardware de firewall entre os usuários e os servidores de back-end?
• Que tipo (TCP/[P, TPX, NetBEUl e outros) de rede está em uso?

Segurança
Todo siste1na precisa ter pelo 1nenos algu1nas especificações de segurança; mesmo um aplicati-
vo não protegido deve possuir tuna declaração de que foi projetado dessa maneira. U1na infor-
mação essencial que precisa ser detenninada, ,nas que não é fácil de conve1ter ern uma si,nples
pergunta, é qual o nível de importância que será dado à segurança do apl icativo e seus dados?
Tanto u1n sistema financeiro quanto un1 que registre a pontuação em jogos de golfe consideram a
segurança, 1nas o grau de preocupação provavehnente será um pouco 1nais alto em u1n deles.
Além dessa parcela da informação, as perguntas a seguir serão pontos de partida úteis na deter-
tninação das necessidades de segurança do aplicativo:
• Como os usuários serão autenticados na rede existente?
• As máquinas clientes pertencem a um domínio do Windo"vs 2000/NT?
• Se público, o acesso será anônjmo ou os usuários terão de se identificar?
• Esse aplicativo será responsável por alterações na senJ1a ou pelo gerenciamento de outros
recursos de segurança?
• Os usuários terão diferentes níveis de acesso, possivehnente com restrições para os recur-
sos do aplicativo que poderão usar?

Outras Considerações
Outros fatores essenciais no desenvolvimento de u1na arquitetura serão listados aqui, porétn, é
nessas áreas que o nível de experiência do desenvolvedor te1n a maior importância. Cotn relação
a esses pontos, não há respostas definitivas. É n1ais u1na questão de conseguir informações sufi-
cientes a fi1n de incluí-las no planejamento da arquitetura.
• Velocidade das alterações na lógica operacional - Se a lógica operacional que conduz o
siste1na se alterar rapidamente, isso afetará a freqüência co1n que o cliente e1n u1n sistema
cliente/servidor teria de ser atualizado. Alterações maiores na lógica operacional decerto
precisaria1n até mesmo de uma atualização tambén1 do cliente.
• Conjunto de habilidades da equipe de desenvolvi1nento-Algu1nas fonnas de desenvolvi-
1nento são mais co1nplexas e, po1tanto, rnais difíceis do que outras. Na 1naioria dos casos,
Arquitetura dos Aplicativos na Plataforma .NET 141

u,n siste1na cliente/servidor é mais simples de escrever do que um completo com três ca-
1nadas. Quando escolher u,na arquitetura, você poderá tentar desenvolvê-la de acordo
com o nível de habilidade da equipe ou basear a aptidão necessária na arquitetura selecio-
nada.
• Requisitos/planos futuros - Ao desenvolver a arquitetura para um sistema, você terá de
enxergar além dos requisitos atuais e considerar os de amanhã. No n1ínimo, 1nes1no se não
tiver infonnações sobre quais serão os planos futuros, desenvolva u1n siste1na que possa
ser aprirnorado. Se já souber os detalhes específicos, docu1nente-os em seus requisitos e
projete de modo apropriado. Como exemplo desse tipo de info1u1ações, imagine u1n siste-
1na planejado para ser usado por duas pessoas, mas que será aberto para a comunidade da
Web em alguns rneses.

Exemplos de Cenários
As discussões anteriores sobre os fatores essenciais se concentrara1n no que você precisa apreen-
der durante a fase de análise dos requisitos, mas isso na verdade envolve examinar várias descri-
ções co1n estilo de narrativa e tentar decifrar as informações que elas contêm. Nesta seção,
mostrarei alguns exemplos breves de requisitos de sistema e as infonnações sobre a arquitetura
que podem ser obtidas por meio deles.

Sistema de uma Videolocadora


Narrativa dos Requisitos:
"U1na cadeia de videolocadoras precisa de um novo siste1na para rastrear as fitas, os clientes e as
locações. Todos os locais atualn,ente estão co.nectados ao escritório central por 1neio de mo-
dems. Cada loja possui u1n ou mais co1nputadores agindo con10 terminais de ponto-de-venda. Os
cotnputadores são novos, co1n placas Pentium II. Os dados sobre as Vendas/ClientesNídeos de
cada loja não precisa1n estar disponíveis no escritório central em tempo real; o siste1na atual exe-
cuta à noite alguns comandos em lote que trans1nitem os dados para o escritório central, que e1n
geral são suficientes para os propósitos da loja."

Discussão
Esse é u1n cenário be1n co1nu1n -1núltiplos locais ou filiais executando a entrada de dados, e um
escritório central que deseja ser atual izado regularn1ente cornos dados desses locais (veja a Fi-
gura 5.2). As máquinas no local cliente parecen, (de acordo com essa breve discussão) ser de utn
padrão con1um e bastante novas de modo que utn aplicativo do Windows Fonns é u,na possibili-
dade, e urn do ASP.NET sempre será uma opção. Nesse caso, o fator decisivo terminará sendo a
declaração que diz que a atual ização noturna dos dados atenderá. Co1n esse comentário e uma
conexão relativa1nente lenta retornando para o escritório central, eu consideraria utn sistetna etn
que os dados ficariam armazenados nesse escritório e serian1 replicados para cada local durante
períodos lentos ou à noite, depois que cada loja fechasse.
1142 Dia 5

Os sistemas para cada loja seriam aplicativos do Windows Forms, el i1ninando, assin1, a necessi-
dade de urn servidor Web. U1n banco de dados local de algurn tipo (MSDE ou Access) seria ins-
talado em cada loja, e uma carga programada desses dados seria enviada para o escritório central
toda noite. Se, ern vez disso, fosse usado urn banco de dados central, co1n todos os escritórios
executando o seu trabalho através de uma conexão dial-up, proporcionaríarnos a vantagem de ter
os dados de todas as lojas disponíveis e atualizados no escritório central, mas o desempenho de
uma conexão via mode1n provavelmente seria um problema. U,n front-end com base na Web
que desse supo1te a fu nções que urna videolocadora em geral precisa (seria necessário pesquisar-
rnos mais para detenn inar isso), corno a impressão de recibos e talvez cartões de associados, se-
ria difícil de criar.

FIGURA 5.2
A. videolocadora
possui 11n1a arquitetura
con1un1, con1 ,nuitas
.filiais se conectando a Escritório
11111 escritório central. Central
Dados
A decisão principal é Escritório
se o cliente deve se da Filial
conectar direta,nente
ao escritório central
ou usar alg111n tipo de
depósito de dados
local.

Dados
Escritório
da Filial - - -

Escritório Dados
da Filial

Acesso Público
Considere o que seria diferente se a linha a seguir fosse incluída nos requisitos da videolocadora:
"Por fin1, espera1nos criar um site da Web público para nossos clientes, no qual eles poderão pro-
curar filmes e verificar se um certo filme existe em estoque e1n uma loja específica."
Essa declaração provoca 1nais alterações do que você pode imaginar. Corno é um 'requisito futu-
ro', poderírunos apenas ignorá-lo e projetar o siste1na com base no resto da infonnação. Isso pro-
duziria um siste1na que teria de ser redefinido logo que a ernpresa passasse para a próxi1na etapa
de seus planos. Ern vez disso, é preferível tentar desenvolver uma arquitetura que aborde os pla-
nos atuais e possa rnanipular os requisitos futuros.
A rqu itetura dos Aplicativos na Plataforma .NET 143

Se1n entramos e1n muitos detalhes, porque você con1 certeza iria precisar coletar ,nais infonna-
ções sobre os planos futuros a fi,n de criar uma arquitetura adequada para o site público da Web,
considere as alterações básicas que seriam necessárias (veja a Figura 5.3). O comentário sobre
"alguns co,nandos e,n lote trans,n ite,n os dados para o escritório central toda noite" de certo já é
incorreto. Se o site da Web disponibilizasse informações sobre os filn1es, mas estivesse atrasado
en1 un1 dia, não seria tão útil! Não é necessário obter as infonnações e,n tempo real, n1as um atra-
so aceitável teria de ser determinado (talvez 15 minutos).
Se o te1npo de espera planejado não for tão curto, então, talvez o siste1na també1n possa ser pro-
jetado co,n u1n annazena1nento de dados local e atualizações e,n lote. Para um siste,na de com-
putador, 15 ,ninutos é muito te,npo, e seria preciso u,na largura de banda ,nuito 1nenor do que en1
tuna conexão contínua. Com esse novo requisito, u1n aplicativo da Web parece mais adequado
porque todos os dados seria1n armazenados no escritório central e alguns códigos poderia1n ser
compartilhados entre os dois siste1nas. Mas um site da Web não teria u1n nível de resposta tão
bo1n quanto um aplicativo do Windows Fonns com o arn1azenamento de dados no local da loja.

FIGURA 5.3
A decisão de ter um
site público da Web Dados
alterou a arquitetura
da videolocadora para Escritório
Central
assegurar que os
dados do escritório
Escritório
central Jiquenz da Filial
atualizados.
Escritório
da Filial Internet
~ -
t\.,~f} ,;. -
Escritório
da Filial ,(~
, ! jP
,:- Escrítório ;~ )
,(~ r\-.~# /

Escritório
da Filial
da Filial
Escritório
da Filial

Serviço de Listagens Imobiliárias


Narrativa dos Requisitos:

"Uma grande e1npresa i1nobiliária, de abrangência nacional, deseja informatizar suas listagens
de imóveis. Os corretores adicionaria1n as listagens diretamente a um siste,na de computador, e
u,n site público da Web seria disponibilizado para os clientes pesquisare,n as que estivessem dis-
poníveis e enviarem mensagens para os corretores apropriados. Esses precisariam do serviço de
listagens, assin1 co,no de u,n recurso para inserir listagens novas, e acessaria,n os dois de seus
1144 Dia 5

laptops. Já que esses corretores e1n geral estão viajando durante todo o dia, eles usam seus lap-
tops re1notamente a 1naior pa11e do tempo."

Discussão:

Dada a descrição anterior, você poderá extrair alguns ele1nentos essenciais logo de i1nediato.
Haverá um site da Web, que já está definido, pelo n1enos com relação à interface co1n o público.
A questão é "co1no 1nanipular a interação con1 os corretores". Eles têm de poder acessar e ainda
adicionar, atualizar e excluir as listagens que inseriram no serviço, tudo enquanto viaja,n o dia
inteiro. Podería1nos sincronizá-los co1n o siste1na quando estivessem no escritório, fazer o
download, das Iistagens em suas máquinas e carregar qualquer listage1n nova que tivessem acres-
centado. E provável, no entanto, que eles só passen1 pelo escritório ocasionalmente e, portanto,
uma nova listagem não chegaria a eles ou suas listagens novas não serian1 carregadas por cerca
de um dia. Isso é aceitável? Talvez, precisa1nos de mais infonnações.
De 1nodo alternativo, os corretores poderiam usar modetns sem fio (co1n a tecnologia dos celula-
res, con10 o COMA), que poderiatn conectá-los ao escritório central ou à Internet de qualquer lo-
cal. Por meio dessa opção, você agora teria duas escolhas: continuar utilizando o aplicativo
off-line, porém executando sua sincron.ização através de u,na conexão sem fio (resultando em
atualizações mais freqüentes) ou desenvolver o recurso adicionar/editar/excluir em u1na parte
segura do site público da Web da agência in1obiliária, http://www. nomedos i te. com. br/ agentes,
que os agentes acessariam com un1 navegador comum pelo 1node1n celular. Devido à baixa velo-
cidade (atual) desses modems celulares, gostaria de considerar as duas opções e executar alguns
testes, mas o site público poderia ser iniciado sem espera.
Como você pode ver, a arquitetura do aplicativo não é um conceito definitivo, principaln1ente
quando se lida só com uma quantidade limitada de inforn1ações sobre a situação. E1n geral, é pre-
ciso solicitar todos os requisitos possíveis, analisá-los e, e1n seguida, voltar aos diversos entre-
vistados e pedir dados adicionais. Esse processo pode ser apenas para esclarecer as perguntas
originais, ou talvez novas perguntas su1jam das respostas fornec idas.

Biblioteca Pessoal com Informações sobre CDs


Narrativa dos Requisitos

"Como projeto prático, você irá desenvolver u,na biblioteca pessoal co1n infonnações sobre
CDs que os usuários poderão instalar em suas máquinas para registrar suas coleções. Ela dará su-
porte à pesquisa por non1es de CDs e ao rastrean1ento de títulos na Internet. Todos os detalhes so-
bre a coleção de CDs do usuário serão ar1nazenados, e o sistema pennitirá a geração de alguns
relatórios siinples que usem esses dados."

Discussão:

Esse sistema é bem simples, e a arquitetura para desenvolvê-lo ta1nbém deve ser. O único item
realinente desconhecido nele é a pesquisa de detalhes sobre os CDs na Internet, 1nas essa não é
Arquitetura dos Aplicativos na Plataforma .NET 145

uma questão relacionada à arquitetura. U1n aplicativo do Windows Forms seria o 1nais adequa-
do, porém você deve escolher um banco de dados que não seja o SQL Server porque é preferível
fazer a distribuição se1n precisar de nenhu1n software adicional nas n1áquinas dos usuários. Um
arquivo do Access (. mdb) ou um banco de dados MSDE atenderia1n satisfatoriamente a esse pro-
jeto. Co1no alternativa, todas as informações poderia1n ser armazenadas apenas como XML em
un1 conjunto de dados (DataSet).

Resumo
O universo da plataforma .NET é novo e poderoso, 1nas tudo precisa de un1a base. O projeto e a
arquitetura de seus siste1nas são críticos para a obtenção de êxito. Apesar dos novos recursos e
alterações radicais na tecnologia subjacente, a arquitetura de um sisten1a .NET não é tão diferen-
te do que era para u1n sistema do Visual Basic 6.0; 1nuitas opções ainda são as mes1nas. Certifi-
que-se sempre de basear suas escolhas nos requisitos que obtiver e não esqueça de planejar para
o futuro!
Como foi mencionado, 1nuitos aspectos da arquitetura dos sistemas estão além do escopo desta
lição, n1as o MSDN dedicou uma seção de seu site da Web para a arquitetura dos aplicativos
.NET. Acesse http: //msdn. mi crosoft. com/1 i brary /def au 1t. asp?url =/1 i brary /en-us/dnbda/
html/daag.asp para encontrar muitos recursos úteis.

P&R
P Ouvi dizer que o Windows DNA foi abandonado e não é mais aplicado agora que a
plataforma .NET exis te. Você afirmou que ele ainda é empregado, mas, na verdade,
não é um recurso ultrapassado?
R O Windows DNA representa tanto alguns conceitos quanto tecnologias. Algu1nas das
tecnologias a ele incorporadas, co1no o Visual Studio 6.0, fora1n substituídas pelas equi-
valentes da plataforma .NET, ,nas o conceito do Windows DNA (co1nputação distribuí-
da e1n várias camadas, separando as de apresentação, operacional e de dados) ainda é
válido. Os sisten1as que já fora1n desenvolvidos co,n o 1nodelo do Windows DNA serão
fáceis de transferir para o universo da plataforma .NET.
P No universo da plataforma .NET, todos os meus componentes se comunicarão uns
com os outros por meio do SOAP (XML acima do HTTP), em vez de com o velho pa-
drão binário do DCOM?
R Você está correto co1n relação ao fato de que o DCOM não é mais o 1nétodo preferido,
1nas a plataforma .NET fornece mais do que apenas o SOAP co1no um meio para dois
aplicativos se comunicaretn. O SOAP é excelente para a comunicação com a platafonna
.NET ou siste,nas que não sejam .NET e é especiahnente bo1n quando se trabalha entre
146 Dia 5

duas redes porque ele passa co1n facilidade através de firewalls. O SOAP é uma opção,
,nas há várias outras fonnas de co1nunicação incluindo os formatos binários.

Workshop
O Workshop foi planejado para ajudá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e co,neçar a pensar e,n co,no colocar seu conheci,nento e,n prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".

Teste
1. Nomeie u1na vantagem relevante em usar tuna interface com usuário con1 base na Web
e1n vez de u1n aplicativo Windows.
2. Se u,n apl icativo usar um arquivo do banco de dados Access localizado em um servidor,
ele será considerado um sistema cliente/servidor ou de utna única camada?
3. O que tem de ser instalado para que un1 co,nputador execute u,n aplicativo criado com a
plataforrna .N.ET (não é só procurar um site da Web criado com ela)?
SEMANA 1

DIA

O Que Fazer Quando Programas


Bons Apresentam Problemas e
para Se Certificar de Que Isso Não
Aconteça
Pode acontecer um erro quando seu progra1naestiver sendo executado (normahnente causando a
interrupção dele). Se ocorrer no 1nomento em que u1n cliente estiver processando seu prograrna,
algo be1n pior poderá acontecer (você pode não ser pago). Portanto, seria 1nelhor se pudéssemos
evitar esses proble1nas antes que acontecessem .
1-lá duas técnicas importantes que o ajudarão a evitar en·os. :Primeiro, você deve detectar quando
as falhas ocorrerem e1n seus prograrnas e lidar com elas em vez de permitir que a 1nensagen1 de
erro padrão su1ja co1no resposta. Em segundo lugar, é bo1n se certificar de que seu aplicativo te-
nha a 1nenor quantidade de erros possível.
Hoje, você aprenderá as duas principais n1aneiras de evitar problemas ern seu código:
• Tratamento de exceções estruturadas
• Depuração
148 Dia 6

Tratamento de Exceções Estruturadas


.As versões rnais antigas do Visual Basic usavam o tratamento de erros para proteger um aplicati-
vo. O Visual Basic .NET é a primeira versão a dar suporte a um conceito 1nelhor en1 linguagens
de programação - o tratamento de exceções estruturadas.
,
O Que E o Tratamento de Exceções Estruturadas?
Antes que você possa exa1ninar o que é Structured Exception Handling (SEH, trata-
Novo TERMO
mento de exceções estruturadas), deve aprender apenas o que significa urna exceção
estruturada - ou até uma exceção não estruturada. Caso contrário, não saberá o que está tratando.
Uma exceçc7o é algo que sai da rotina (e e1n geral de n1aneira inesperada)
,
em seus aplicativos. I-Iá
dois tipos de exceções - exceções de hardware e de software. E claro que u1na exceção de hard\va-
re é aquela causada pelo hard\vare - por exetnplo, quando seu programa tenta acessar uma parte
da n1en16r.ia que não deveria ou u1n evento se1ue.lhante que ocorra com base no hardware. U111a ex-
ceção de soft.,.vare ocorre quando se tenta atribuir um valor incompatível a u1na variável ou um
erro parecido acontece.

O trata,nento de exceções estruturadas é tuna estratégia para lidar com erros de hard,vare ou
soft\.vare. Tratando os dois tipos de exceção da 1nes1na maneira, o código necessário para proces-
sá-las será 1nais fácil de escrever e mais consistente. Execute o tratamento de exceções estrutura-
das para 'proteger' as seções de código que estiverem propensas a seren1 alvos de exceções. Por
exemplo, quando estiver para efetuar uma divisão, poderá proteger o código que a calcula. Se -
por causa de un1 erro que você cometeu no programa ou u1n valor que o usuário inseriu - o pro-
gra1na tentar fazer a divisão por zero, o código protegido poderia lidar com a exceção resultante.
Outras vezes e1n que se deve usar o SEH são na leitura em bancos de dados, abertura, leitura ou
gravação e1n arquivos, ou qualquer outro 1nomento em que você ache que u1n erro possa ocorrer.

-;;----- ....... Sou daqueles que crê ser difícil usar em demasia o SEH. Os benefícios que
NOTA pode obter protegendo a si mesmo, seus programas e usuários de erros com-
pensam em muito uma pequena redução no desempenho que resulte da utili-
zação do SEH. Por outro lado, seja sensato. Se não houver nenhuma
possibilidade (e quero dizer, realmente não existir a possibilidade) de um erro
ocorrer, deixe de lado a digitação adicional.

Erros e Exceções
Be.1n, em que um erro difere de un1.a exceção? Se você estiver familiarizado corn outras versões
do Visual Basic ou 1nesn10 co,n a maioria das linguagens de programação, dece1to se deparou
com o conceito de erro, mas não de exceção. Qual é a diferença? Por que precisarnos de uma pa-
lavra nova e de algo que soa tão extravagante como o tratamento de exceções estruturadas?
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 149

Primeiro, uma exceção na verdade é um erro. Parte do proble1na, no entanto, é que u1n erro signi-
fica muito 1nais. Um exemplo de erro poderia ser u1na função que retornasse um resultado que
não fosse esperado ou se o progran1ador usasse o algorit1no errado. U1na exceção é mais formal.
A exceção ocorre, para repetir a definição anterior, quando algo acontece em seu código fora do
·fluxo normal de controle. O SEH define u1na maneira particular de lidar com exceções, assegu-
rando que tudo seja non11alizado depois do fato. Alé1n disso, um outro recurso adequado das ex-
ceções é que hoje elas são co1npartilhadas entre todas as linguagens que tenha1n suporte da
platafonna .NET. Isso significa que seria possível ter u1n código que causasse un1a exceção e,n
un1a linguagem, mas a tratasse en1 outra.
A 1naioria dos erros no Visual Basic te1n sido tradicionalmente tratados com o uso da instrução
On Error. Essa instrução não é estruturada e pode resultar em um código confuso que salte de
tun local para outro de um procedimento. As exceções são tratadas co.m a utilização de uma
abordage1n 1nais estruturada, ou organizada, co1no você verá.

O Bloco Try
Você deve proteger a seção dos códigos co1n o bloco Try ... End Try a fin1 de tratar as exceções sem-
pre que ocorrerem. Inicie o código que deseja proteger com Try e finalize a seção com End Try.

A Sintaxe de Try... End Try

SINTAXE O código a seguü· mostra a sintaxe do bloco Try ... End Try:

Try

Catch Ex As Exception

End Try

onde Try é o início da seção do código a ser protegido e End Try finaliza o bloco de código. A li-
nha Catch n1arca a seção do bloco que realmente trata as exceções que possatn ocorrer.

A Seção Catch
Marcar apenas tuna seção de código com Try .. . End Try na verdade não produz nenhum resulta-
do. Se u1na exceção ocorrer no código protegido, ela deve ser 'capturada' e tratada. Capture a ex-
ceção com a palavra-chave Catch.
Cada bloco Try ... End Try pode ter u1na ou mais seções Catch. Cada seção Catch em geral se
destina a u1n ou 1nais tipos de exceção. Se decidir ter várias seções Catch en1 seus blocos Try,
cada seção deve capturar tipos diferentes de exceção. Você pode querer fazer isso para permitir
que cada tipo de exceção seja tratado de modo diferente. Se resolver inserir todas essas seções
Catch, também é recomendável ter u1n.a seção Catch genérica que capturará todas as exceções
1150 Dia 6

que possam passar pelas outras seções. Essa fonna do bloco Try ... End Try teria uma aparência
semelhante à mostrada na Listagem 6.1 .

CôotGO LISTAGEM 6.1 Capturando Várias Exceções

1 Try
2 1

3 Catch eNoFile As FileNotFoundException


4 ' trate aqu i a exceção causada por arquivos não encontrados
5 Catch eIO As IOException
6 ' trate aqui a exceção causada por uma entrada/resultado
7 Catch Ex As Exception
8 ' trate aqui as outras exceções
9 End Try

ANÁLISE Esse bloco Try fo i projetado com a finalidade de capturar erros en1 un1 procedin1ento
que processa arquivos. f-lá seções separadas para tratar exceções por arquivos não
encontrados (Fi l eNotFoundExecpt i ons) , de EIS (1 OExcept i ons) e outras. Se existisse apenas uma
seção Catch, você precisaria de algu1n código que detenninasse a exceção específica. Dessa ma-
neira, fica n1ais evidente que código é usado para cada tipo de exceção.

Criaremos uin prograina co1n uma exceção intencional, de modo que você possa ver co1no ela
funciona. Examinaremos seus resultados e o que ela faz ao programa. E1n seguida, adicionare-
1nos o tratamento da exceção, e saberemos co1no ele pode proteger o código.
l. Crie um novo aplicativo do console. Chame-o de Exceptions.
2. Altere o nome do módulo criado para modExceptional.
3. Acesse a caixa de diálogo Project Properties dando um clique com o botão direito do
1nouse no nome do projeto do Solution Explorer e selecionado Properties.
4. Configure o Sta1tup Object co1no modExceptional . As configurações finais devem ficar
como as que são tnostradas na Figura 6.1.
Para atender a finalidade deste exemplo, você usará uma exceção simples e surpreendentemente
co1nun1, Division By Zero, que ocorre quando há tuna divisão por zero. Esse erro pode ser
,
de-
monstrado com facilidade dividindo-se u1n nú1nero por tuna variável não inicializada. (E uma
das causas mais co1nuns dessa exceção).
A Listagen1 6.2 mostra que aparência o código final deverá ter:
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 151

FIGURA 6.1
A caixa de diálogo .:.1
6 Ccm:n:in Ptop:st.cs
Project Pro1;erties ~ Gerr.:,ol
f)J(d
W?2Nã
QutpA type: ~rtl4) cbject:
para 11111 progrc1111a tmp:11b
.:.J ~1...-..
-
co,n 11111a exceçao.
Reftter,:e Poth
Strongr,~
Oe:$ig ,er Otf<!lúl$
lco-"AQ~>:-.
Root ~espac~:
Exct(:ÔOl"IS
~ ..-,.-...,~ - - - - ~3
C) Cc:dl~oticn Propc1tic,

JrifCffl\)tiol'I --

ProjP.ct fcider: C:\Doa.Jments êndsettngs\d!f~t\,rll)' Docunerts\Teach Y«J'Sef VB


Pro)'!« fio: Exoiptions.vbpof
OUtpA name: Ex01!pticn$.~e

OK

LISTAGEM 6.2 Um Programa com Exceção


1 Module modExceptional
2
3 Sub Main()
4 '***Este código contém uma exceção,
5 'e portanto não será executado até o final
6 Dim dDividend As Decimal = 5
7 Dim dDivisor As Decimal = O
8 Dim dResult As Decimal = O
9 'Essa linha é a que causará
10 ' uma Exceção DivisionByZero
11 dResult = dDividend /dDivisor
12 System.Console . Readline()
13 End Sub
14
15 End Module

ANÁLISE As linhas 6, 7 e 8 declara1n suas variáveis. Você usou deci1nais aqui, 1nas tambén1 pode-
ria e1npregar outros tipos de variável nu1nérica. Os valores ta1nbém foran1 inicializados.

Antes da divisão na linha 11, o valor corn o qual o divisor foi inicializado, O, não foi alterado.
Portanto, quando o computador tentar efetuá-la, u1na exceção ocorrerá. Se você executar esse
prograrna no IDE, verá um erro como o mostrado na Figura 6.2.
Se você selecionar Break, o programa ainda será executado, 1nas no ,nodo Debug (depuração).
Examinaremos 1nelhor o 1nodo Debug ainda nesta lição, portanto selecione Continue neste 1no-
1nento. Isso farácon1 que o prograrna continue a ser executado. Neste caso, ele será finalizado.
152 Dia 6

Microsoft lkvclopmcnt Environmcnt


FIGURA 6.2
At/ensagen1-padrão
de exceçcio.

Se você reproduzir o exen1plo e tentar executá-lo e1n un1ajanela do pro1npt de co1nando, o resul-
tado final será semelhante, poré,n sua correção será mais difícil. Pri,neiro, e,n un1 co,nputador
de desenvolvimento (que tenha o Visual Basic .NET instalado), deve aparecer a caixa de diálogo
Just-In-Time Debug. Selecione No; seu programa continuará, e este resultado aparecerá:

RESULTADO 1 Unhandled Exception: System.DivideByZeroException:


2 An except ion of type System.DivideByZeroException was thrown.
3 at System.Decimal .Divide(Decimal dl, Decimal d2)
4 at Exceptions.modExceptional.Main()in
5 C:\Code\Day06\Exceptions\modExceptional .vb:line 11

ANÁLISE Essa é urna n1ensagem-padrão que você verá quando uma exceção ocorrer. Várias
mensagens de erro relacionadas a exceções são muito 1nais longas, no entanto, todas
contêm infonnações semelhantes. A pri,neira linha sempre identifica o tipo de exceção que aca-
bou de ocorrer. Neste caso, descobriremos que foi uma do tipo Sys tem . Di vi deByZeroExcept i on.
O tipo de exceção em geral é un,a grande indicação da natureza do erro e pode até proporcionar
idéias de co1no corrigi-la. Aqui, o tipo de exceção System. Oi vi deByZeroExcept i on informa
principalmente dois detalhes:

• A exceção que acabou de ocorrer é urna das 'comuns', isto é, que faz parte do espaço de
no,ne Systetn (e não de outro espaço de nome, coino System. 10. Fi 1eNotFoundExcepti on).
• A exceção que acabou de ocorrer envolve tuna operação de divisão. Portanto, você deve
procurar tuna possível causa e,n seu código, onde estiver efetuando u1na divisão.
De maneira se,nelhante, o restante da exceção disponibiliza muitas infonnações. As outras li-
nhas sã.o uma lista invertida dos procedimentos que estavam efetivamente en, execução quando
a exceção ocon·eu. Na saída do exe1nplo, ven1os que na verdade ela surgiu no procedi1nento
System. Decimal .Divide. Esse procedirnento foi chamado por Exceptions.modExceptio-
nal .Main.
A principal função de todas essas infonnações é localizar candidatos ao erro. Ao encontrar uma
ex.ceção, você deve pri1neiro exan, inar o código de cada um desses procedimentos. Em geral
(mas nem sempre), o erro se encontrará e1n um deles. Comece co1n o pri,neiro ite,n da lista (nes-
se caso, modExcept i ona l . Ma i n) e percorra-a até o final. Mais adiante, nesta li.ção, exatninaremos
algu1nas ferramentas que tornarão esse trabalho ,nais fácil.
Algu,nas outras exceções co,nuns estão descritas na Tabela 6. 1.
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 153

Esta não é uma lista completa de todas as exceções possíveis. Há muitas ou-
N OTA tras; por favor consulte a ajuda do Visual Basic .NET para obter mais detalhes.
Além disso, você pode criar suas próprias exceções para adicionar a essa lista
se precisar, como veremos ainda nesta lição.

TABELA 6.1 Exceções Comuns

Tipo de Exceção Quando Ocorre?


ArgumentException Categoria geral para erros que ocorram quando o tipo (ouva-
lor) errado for passado para um método. Inclui Argument-
Nu l l Exception e ArgumentOutOfRangeException. Pode surgir
por causa de um erro do programador ou nas entradas de da-
dos do usuário.
ArgumentNullException Ocorre quando você passa um valor nulo para um método, e
ele não o aceita.
ArgumentOutOfRangeException Ocorre quando é passada uma variável que é grande ou pe-
quena demais para o método, por exemplo, se você passar o
número -1 a um método que foi criado para conter um valor
relativo ao mês (isto é, entre 1 e 12).
DivideByZeroException Ocorre quando se tenta efetuar uma divisão por uma variável
não inicializada ou que contenha o valor zero. Em geral só
acontece quando há erro do programador.
IndexOutOfRangeException Ocorre quando se tenta acessar o membro de um array que
não existe. Em geral acontece por causa de erro do progra-
mador, mas também poderia ser causada por entradas inváli-
das do usuário.
NotlmplementedException Geralmente usada como um espaço reservado quando o de-
senvolvedor está trabalhando pela primeira vez no progra-
ma. Você pode criar o shell para seu aplicativo e, em seguida,
lançar essa exceção de qualquer método. Enquanto continuar
no aplicativo, substitua a exceção pelo código efetivo. Isso
assegurará que conclua todos os seus procedimentos.
OurOfMemoryException Ocorre quando seu programa não tem memória suficiente.
Isso poderá acontecer ao preencher arrays extensos ou ao
executar um laço.
OverflowException Uma exceção bem comum que ocorre quando você tenta in-
serir um valor que é muito grande em uma variável, como,
por exemplo, na atribuição a seguir:
Dim iSmallishNumber As Short = 50000
Fi leNotFoundException O exemplo de um erro que não é definido no espaço de nome
System. Nesse caso, a exceção é definida no espaço de nome
System. IO (veja o Dia 8, "Introdução ao .NET Framework",
para obter mais informações sobre os espaços de nome).
Esta exceção ocorre quando você tenta acessar um arquivo
que não existe. Isso pode acontecer porque talvez ele não te-
nha sido criado ou o caminho está incorreto.

Agora que você já vi u a exceção e te,n (espero) ui.na idéia melhor do que seja, deve adicionar o
SEH a seu progra1na para fornecer ao usuário 1nais infor1nações quando u1n erro ocorrer.
11 54 Dia 6

Abra o projeto Exceptions no Visual Basic .NET. Você copiará o projeto anterior e fará altera-
ções para capturar a exceção, co1no 1nostram as etapas a seguir:
1. Altere o nome do projeto para Excepti ons2. Faça isso selecionando o projeto no Solution
Explorer e, em seguida, selecione File, Save Exception As no tnenu.
2. Altere o nome do arquivo que conté1n o código para Exceptions2. vb. Faça isso selecionan-
do o arquivo no SolutionExplorer e, em seguida, selecione File, Save Excepti on. vb As.
3. Adicione u1n bloco Try . .. End Try ao código que efetua o cálculo. Use uma instrução
Catch genérica para capturar a exceção Division By Zero.
4. Adicione u1n código para exibir u1na 1nensage1n n1ais amigável quando a exceção ocorrer.
O novo código deve ficar com u1na aparência sen1elhante ao da Listage1n 6.3.

CóOIGO LISTAGEM 6.3 Adicionando o Bloco Try ... End Try

1 Module modExceptional
2
3 Sub Main()
4 '***Este código contém uma exceção,
5 'e portanto não será executado até o final
6 Dim dDividend As Decimal = 5
7 Dim dDivisor As Decimal = O
8 Dim dResult As Decimal = O
9 'Esta linha é a que causará
10 'uma exceção DivisionByZero
11 Try
12 dResult = dDiv i dend / dDivisor
13 Catch Ex As Exception
14 System.Console.Writeline(''Ocorreu um erro de divisão por zero.'')
15 System.Console.Writeline(''Verifique o divisor.'')
16 End Try
17
18 System.Console.Readline()
19 End Sub
20
21 End Module

ANÁLISE A linha 11 inicia o bloco Try, portanto, o código desse local até o primeiro bloco
Catch da linha 13 está protegido. Nesse caso, a única linha executável é a que causa a
exceção da divisão por zero na linha 12. Quando essa exceção ocorrer, o programa será interrom-
pido e procurará algo para tratar dela. Já que a seção Catch da linha 13 é genérica, capturará qual-
quer tipo de exceção. A variável Ex será usada para armazenar a exceção criada, e você poderá
empregar as propriedades dessa variável para visualizar mais infonnações sobre a exceção. Em
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 155

seguida, será exibida uma mensagem de e1To, e o código continuará até o final , começando na li-
nha posterior a instrução End Try.

Aninhando Blocos Try . .. End Try


Você pode encontrar tuna situação na qual queira proteger duas seções de código com blocos
Try .. . End Try, ,nas deseja lidar com as exceções de 1naneira diferente. Se os dois fore1n blocos
separados de código, não haverá problema. No entanto, se um dos blocos estiver contido no ou-
tro (veja a Listagem 6.4), não há opção. Nesse caso, é preciso aninhar os blocos Try ... End Try,
con10 1nostra a Listage1n 6.4.

CôDIGO LISTAGEM 6.4 Aninhando Blocos Try ... End Try

1 Sub WriteToFi l e(ByVal FileName As String)


2 Dim fsOut As System.IO.FileStream
3 Dim strOut As System. IO.StreamWriter
4 Try
5 'Abra o arquivo
6 fsOut = -
7 New System.IO.FileStream(FileName,_
8 System.IO. FileMode .OpenOrCreate,
9 System.10.FileAccess.Write)
10 Try
11 'Grave no arquivo
12 strOut =
13
-
New System.10.StreamWriter(fsOut)
14 strOut.Write(DateTime . Today.ToString())
15 Catch eIO As Exception
16 Console.Writeline( ''Não foi possfvel gravar no arquivo: {O}.'' ,
FileName)
17 End Try
18 Catch eFile As Exception
19 Console.Wri teline(''Não foi possfvel abrir o arquivo: {O}.'', FileName)
20 End Try
21 End Sub

ANÁLISE A Listagem 6.4 é u1n exemplo de gravação en1 um arquivo. Você exa1ninará esse as-
sunto com mais detalhes no Dia 8. Porém, há dois blocos Try ... End Try neste exem-
plo. Un1 dos blocos Try (o que começa na linha 1O) está todo contido dentro do outro bloco Try (o
que começa na linha4). Portanto, o bloco Try interno está aninhado no outro bloco. Se wna exce-
ção ocorrer na gravação que acontece na lin.ha 14, a instrução Catch da linha 15 a capturará, e o
usuárioverá "Não foi possível gravar no arquivo SomeFile.out".Alé1ndisso, seoarquivonão
puder ser aberto, o bloco Catch da linha 18 capturará a exceção, exibindo "Não foi possível
abrir o arquivo: SomeFile.Out '' .
1 156 Dia 6

Exatamente con10 co1n I f ... End I f e outros blocos, não há limite para a maneira de aninhá-los.
'
As vezes, aninhar blocos pennite que a escrita do código seja feita de uma maneira mais organi-
zada do que se eles não fosse1n aninJ1ados.

A Seção Final ly
Quando você escrever blocos Try, às vezes se deparará com situações nas quais, 1nesmo se uma
exceção ocorrer, terá de executar algo. Por e·xe1nplo, se você escrever u1n código que grava in-
formações e1n utn arquivo, deve fechá-lo, ocorrendo ou não um erro durante a gravação. Adicio-
ne essa funcionalidade cotn a seção Fina 11 y. Essa seção surge depois de todas as seções Ca tch, e
deve conter apenas o código que sen1pre terá de ser executado. Esse é u1n bo,n local para fechar
arquivos, configurar variáveis co1n Nothi ng ou excluí-las quando desejar. A Listagen1 6.5 mostra
a inserção de uma seção Fina 11y no código da Listagem 6.4.

CÓDIGO LISTAG EM 6.5 Usando a Seção Fina 11 y

1 Sub WriteToFile(ByVal FileName As String)


2 Dim fsOut As System.IO.FileStream
3 Dim strOut As System. IO.StreamWriter
4 Try
5 'Abra o arquivo
6 fsOut =-
7 New System.IO . FileStream(FileName,_
8 System. IO. Fi leMode.OpenOrCreate,
9 System.IO.FileAccess.Write)
10 Try
11 'Grave no arquivo
12 strOut =
13 New System. 10 . StreamWri ter( fsOut)
14 strOut.Write(DateTime.Today.ToString())
15 Catch eIO As Exception
16 Console . Writeli ne(''Não foi poss1vel gravar no arqui vo:{O} . '' ,
FileName)
17 Finally
18 strOut.Close()
19 End Try
20 Catch eFil e As Exception
21 Console.Wri teli ne( ''Não foi possfvel abrir o arquivo:{O} . '' , FileName)
22 Finally
23 fsOut.Close()
24 End Try
25
26 End Sub
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 157

ANÁLISE Aqui, tanto Stream~Jri ter quanto Fi 1e serão fechados, mesmo se e1Tos ocorrere1n.
Embora isso não seja necessário, é boa prática fazer tuna lilnpeza sempre que não
precisar mais de uma variável.

Lançando Exceções
Ocasionalmente, pode-se querer notificar um usuário de que algo de rnuito errado aconteceu.
Pode ser algo relacionado ao seu aplicativo ou uma exceção ' normal ' . Por exemplo, você pode
ter criado dois objetos nesse aplicativo, Emp1oyee (funcionário) e Customer (cliente). Talvez queira
gerar urna exceção se o programa tentar atribuir uma instância de Emp l oyee a urna variável criada
para conter objetos Customer. E1n vez de criar un1 novo tipo de exceção, é possível reutilizar
Inva l idCastExcepti on. Assin1, u1na nova exceção Invali dCastExcepti on poderá ser gerada e usa-
da como notificação do aplicativo através da instrução Thro1i. lsso é rnostrado na Listagem 6.6.

CÓDIGO LISTAG EM 6.6 A Instrução Throw

1 Dim oCust As Customer New Customer(''Bob'', ''Sjerunkl'')


=
2 Dim oEmp As Employee = New Employee("Phil","Barr")
3 Dim oSomething As Object
4 oSomething = oEmp
5 If TypeOf oSomething Is Customer Then
6 oCust = oSomething
7 Else
8 Throw New InvalidCastException(''Não ê posslvel atribuir Employee a Customer.'')
9 End If

ANÁLISE A linha importante do exemplo é a oitava. Ali, você criou u,na nova instância do ob-
jeto Inval idCastException e a 'lançou'. Isso gerará uma exceção adicional que
deve ser capturada por un1a instrução Catch ou tratada pela rotina-padrão, causando o surgimento
do depurador (se houver urn a,nbiente de desenvolvi1nento instalado) ou de urna 1nensage1n de
erro.

O trata1nento de exceções fornece urna 1naneira estruturada e li1npa de proteger seus programas
de erros devido a problemas no hardware, entradas inválidas do usuário ou a seus próprios enga-
nos. Qualquer progra,na se tornará n1ais robusto se você adicionar o trata111ento de exceção a um
código que poderia gerá-la.

Depurando
Novo TERMO
Tão iJnportante quanto a tratar apropriada1nente os erros e exceções é a depuração -
o ato (e arte) de tentar encontrar e corrigir os erros do código. E' claro que isso leva
co111 freqüência à pergunta, "En1 prirneiro lugar, por que há erros no código? Os desenvolvedores
158 Dia 6

não têm de ser astutos?". Mesmo sendo verdade que todos os desenvolvedores são talentosos
(você está lendo este livro, não?), às vezes enganos acontece1n. A.ntes que você possa remover os
erros de seus programas, passe1nos mais algum te1upo examinando como eles podeLn surgir.

A Fonte dos Erros


Um erro (em u1n programa de computador) pode aparecer de várias maneiras. É possível que

surJa como
• Um engano na estratégia usada para executar algu,na tarefa. Essas falhas são e,n geral
chan1adas de erros lógicos que às vezes são os ,nais difíceis de corrigir. Eles ocorre,n
quando se escreve o código de ,nane ira errada. Você poderia estar ordenando uma I ista de
non1es, mas o ,nodo usado para fazê-lo não levou en1 conta todos as possibilidades. Por
exen1plo, alguém con1 o sobrenon1e St. Jean deve vir antes ou depois de urna pessoa que
tenha co,no primeiro no,ne Santana?
• Um engano ao inserir o código, u,n erro de digitação. Esses podern ser fáceis ou difíceis
de resolver. De certa maneira, esses erros devem desaparecer quase inteira,nente, já que o
Visual Basic .NET verificará a digitação das palavras-chave. Porén1, os erros de digitação
podem se tornar u1n proble1na, se você não configurar Opt i on Exp 1i ci t ern seus ,nódulos.
Se não o fizer, poderá cometer um erro acidental ao digitar um nome de variável posterior-
1nente, fazendo co1n que o Visual Basic .NET crie de modo automático uma nova variá-
vel. Essa variável nova seria inicializada co1n o valor o (em variáveis numéricas), o que
pode não ser o desejado. Por exemplo, sem Opt i on Exp 1i ci t , o código a seguir seria com-
pilado, ,nas nunca retornaria nada.
1 Imports System
2 Module Typo
3
4 Sub Mai n
5 Dim sName As String
6
7 Cons o1e . Wri te Li ne ( 11 Di gi te o norne : 11 )
8 Name = Console.Readline()
9 Console.Writeline("O nome digitado foi {O}" , sNmae)
10 End Sub
11 End Modu 1e
Como já foi dito, Opt i on Exp li ci t faria co1n que o Visual Basic .NET capturasse esse
erro. Sen1 ele, você ta1nbé1n poderia capturá-lo se1n grandes dificuldades. No entanto, há
u1n subconjunto desses tipos de erros que, por razões que desconheço, o cérebro sernpre
lê corretamente. Examinei durante alguns minutos uma seção de código na qual sabia que
havia un1 erro de digitação, mas não vi nada. Toda vez que leio a palavra escrita incorreta-
ruente, a enxergo da rnaneira 'correta' . Nessas situações, chama1nos se,npre outra pessoa,
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 159

que olha por ci1na de nossos ombros e imediatamente percebe o erro, causando algutn em-
baraço. Depois de alguns mo1nentos de brincadeiras, os dois voltam ao trabalho.
• Um erro causado por entradas do usuário ou pelos dados. Esses são erros dificeis de corri-
gir depois que ocorrem. A melhor solução para a entrada ou dados incorretos é reduzir a
chance do usuário inserir informações inválidas. Você examinará alguns dos controles
que pode1n ser usados para isso posteriormente neste livro. Além disso, ser lun 'progra-
1nador defensivo' tan1bém ajudará. Pressuponha que os dados sejam inválidos - você
deve verificar os valores, para ter certeza de que são apropriados e proteger as seções de
código que possa1n gerar exceções usando o trata1nento de exceções estruturadas.

Faça ]
Use Opti on Exp li ci t em todos os módulos. Não esqueça t ambém de ativar Option Stri ct.
Isso ajudará o Visual Basic .NET a detectar Essa opção assegurará que você sempre este-
muitos erros que você possa por acidente adi- ja a par quando um valor for passado a uma
cionar a seu código digitando incorretamente variável de um tipo diferente. A conversão au-
nomes de variáv eis. tomática pode levar a erros traiçoeiros. Cons-
ciente de sua necessidade, você poderá
' executar a tarefa de modo mais apropriado.

Be1n, pode haver tnuitas fontes de erros em seus progra1nas. Algu1nas delas estarão sob controle,
enquanto outras não. De qualquer 1nodo, o Visual basic .NET fornece a você 1nuitas ferramentas
para aj udá-lo a corrigir, ou depurar, seus programas.

Aprendendo a Depurar com a Prática


'
Co1no já foi dito, a depuração é quase tanto tuna a1te quanto un1a ciência. As vezes, ela requer
urna ceita destreza para que se descubra o que pode estar causando um erro. Portanto, tenho a
itnpressão de que un1as das 1nelhores 1naneiras de aprender a depurar é utilizar esta técnica em
urn programa real, e não apenas exarninar suas ferrrunentas (o que pode ser um pouco subjetivo).
Por isso, você depurará um programa que calcula u1na tabela de valores de hipoteca. Ele mostra
os diversos pagamentos 1nensais que seria1n necessários a e1nprésti1nos de vários períodos e ta-
xas de juros. A Listagern 6.7 contém a saida procw·ada envolvendo u1n emprésti1no de 100 1nil
dólares.

RESULTADO LISTAGEM 6.7 Resultado de um Programa Que Calcula a Tabela de


Pagamentos de uma Hipoteca
Digite o valor do empréstimo:
100000

Anos 10 15 20 25 30
Juros
5.00 1060.66 790.79 659.96 584 . 59 536.82
5.25 1072.92 803.88 673.84 599.25 552.20
1 160 Dia 6

LISTAGEM 6.7 Resultado de um Programa Que Calcula a Tabela de Pagamentos de


uma Hipoteca (continuação)
5.50 1085 . 26 817 . 08 687.89 614.09 567.79
5.75 1097 . 69 830.41 702.08 629.11 583.57
6.00 1110.21 843 . 86 716.43 644.30 599.55
6.25 1122.80 857.42 730.93 659.67 615.72
6.50 1135.48 871 . 11 745.57 675.21 632.07
6.75 1148. 24 884.91 760.36 690.91 648.60
7.00 1161.08 898. 83 775.30 706.78 665.30
7.25 1174.01 912.86 790.38 722.81 682.18
7.50 1187.02 927.01 805.59 738.99 699.21
7.75 1200 . 11 941 . 28 820 . 95 755.33 716 . 41
8.00 1213.28 955.65 836.44 771.82 733.76
8.25 1226.53 970 . 14 852.07 788.45 751.27
8.50 1239.86 984.74 867.82 805.23 768.91
8.75 1253.27 999.45 883.71 822.14 786.70
9.00 1266 .76 1014.27 899.73 839.20 804. 62
9.25 1280 .33 1029.19 915 .87 856.38 822 . 68
9.50 1293 . 98 1044.22 932.13 873.70 840.85
9.75 1307.70 1059.36 948.52 891.14 859.15
10.00 1321.51 1074.61 965.02 908.70 877.57

A Listagem 6.8 mostra a tentativa inicial de criar esse programa e seu resultado, confirmando
que você precisa executar u1na depuração.

CÓDIGO/ LISTAGEM 6.8 Um Programa Que Precisa de Depuração


RESULTADO

1 Option Explicit On
2 Imports System
3 Imports Microsoft.VisualBasic.ControlChars
4
5 Modul e modMain
6
7 Sub Main()
8
9 Dim slnput As String
10 Dim dbl Return As Double
11
12 'Armazena a entrada do usuário
13 Dim dblPayment As Double
14 Console.Write(''Digite o valor do emprêstimo:'')
15 slnput = Console.Readline()
16 dbl Return = CDbl(slnput)
17
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 16 1

CÓDIGO/ LISTAGEM 6.8 Um Programa Que Precisa de Depuração (continuação)


RESULTADO

18 'Crie a tabela
19 OutputMortgageTable{dblReturn)
20 Console.Write(''Pressione ENTER para continuar'')
21 Console . Readline()
22 End Sub
23
24 Private Sub OutputMortgageTable{ByVal Principal As Oouble)
25
26 Oim iYears As Integer
27 Oim iRate As Integer
28 Oim dblAnnualinterest As Oouble
29
30 Console.Writeline(Tab &''Years'' &Tab & ''10 '' &Tab & ''15'' &
31 Tab & 11 20 11 &Tab & 11 25 11 &Tab & 11 30 11 )
32 Console.Writeline(''Juros'')
33
34 For iRate = 500 To 1000 Step 25
35 dblAnnualinterest = iRate / 100
36
37 For i Years = 10 To 30 Step 5
38 Console.\~rite(Format(dbl Annual Interest , "0. #0")& Tab & Tab)
39 'iYears * 12 para obter o número de meses (pressupondo
-..pagamentos mensais)
40 Console.Write(Format(Payment(Principal, _
41 dblAnnual lnterest, iYears * 12), 11 0. 00 11 ) & Tab)
42 Next
43 Console.Writeline()
44 Next
45
46 End Sub
47
48 Public Function Payment(ByVal Principal As Oouble,
49 ByVal Annuallnterest As Double , _
50 ByVal Periods As Integer) As Double
51 Dim dbl Monthlylnterest As Oouble = Annuallnterest / 1200
52 Return Principal * dblMonthlylnterest * 1 +
53 dblMonthlylnterest A Periods /1 +
54 dblMonthlylnterest A Periods -1
55 End Function
56
57 End Module

Digite o valor do empréstimo: 100000


162 Dia 6

CôOIGO/ LISTAGEM 6.8 Um Programa Que Precisa de Depuração (continuação)


RESULTADO

Anos 10 15 20 25 30
Juros
5.00 415 . 67 5.00 415.67 5. 00 415.67 5.00
415.67 5.00 415.67
5.25 436.50 5.25 436.50 5.25 436.50 5.25
436.50 5.25 436.50
5.50 457.33 5.50 457.33 5.50 457.33 5. 50
457.33 5.50 457 . 33
5.75 478 . 17 5.75 478 .17 5. 75 478.17 5.75
478 .17 5.75 478.17
6.00 499 . 00 6.00 499.00 6.00 499.00 6.00
499 . 00 6.00 499.00
6.25 519.83 6.25 519.83 6.25 519.83 6.25
519.83 6.25 519.83
6.50 540.67 6.50 540.67 6.50 540.67 6.50
540.67 6.50 540.67
6.75 561 . 50 6.75 561.50 6. 75 561.50 6.75
561.50 6.75 561.50
7.00 582.33 7.00 582.33 7. 00 582.33 7.00
582.33 7.00 582.33
7.25 603 . 17 7.25 603.17 7. 25 603.17 7.25
603.17 7.25 603.17
7.50 624 . 00 7.50 624.00 7. 50 624 .00 7.50
624.00 7.50 624.00
7.75 644 . 83 7.75 644.83 7. 75 644.83 7.75
644.83 7.75 644.83
8.00 665 . 67 8.00 665.67 8.00 665.67 8.00
665.67 8.00 665 . 67
8.25 686.50 8.25 686.50 8.25 686.50 8.25
686.50 8.25 686.50
8.50 707 . 33 8. 50 707.33 8. 50 707.33 8.50
707.33 8.50 707.33
8.75 728.17 8.75 728.17 8. 75 728.17 8.75
728 .17 8.75 728 .17
9.00 749.00 9.00 749 . 00 9.00 749.00 9.00
749.00 9.00 749.00
9.25 769 . 83 9.25 769.83 9.25 769.83 9.25
769.83 9.25 769.83
9.50 790.67 9.50 790.67 9.50 790.67 9.50
790.67 9.50 790.67
9.75 811.50 9.75 811.50 9.75 811.50 9.75
811 . 50 9.75 811 . 50
10.00 832.33 10.00 832.33 10.00 832.33 10.00
832 . 33 10.00 832 . 33

Os Modos na Vida de um Programa


Durante a criação dos programas no Visual Basic .NET, eles passarão por três ,nodos distintos.
Quando você iniciar pela prüneira vez o V.B .NET e estiver trabalhando em u1n progratna, esse
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 163

será o 1nodo Design. Para confirmação sobre qual modo estáe1n uso, exa1nine a barra de título da
janela. Depois das palavras ' Microsoft Visual Basic', aparecerá [design]. De 1naneira se1ne-
lhante, quando u1n programa for executado no IDE, vere1nos [run], significando que esse é o
modo Run. O últi,no modo é Break, ou Debug. Esse 1nodo surgirá se o progran1a que estiver em
execução for interrompido de algu1na fonna. Essa inte1Tupção pode se dar devido à ocorrência
de un1a exceção, ou o n1odo Break pode ser introduzido no IDE. Veja a Figura 6.3 para ver um
exemplo do IDE no modo Break. Observe que a barra de título inclui o marcador [break].

FIGURA 6.3 t" ~dt -;,,,. fl'oJe(t ~ Qeb.9 !°"' '.!'!.'M>w ~

O Visual Basic . AfEJ' no l i<J' ill ' ~ "' liJ I i


J..ogr. . [>Z<oJ-.,,.,,.... ,..,••
~ ~1.. -, '
~a. !
C• ' ~

li
'

• ::J
lei • ......
11 IM Q <:. e~
• ]gil
~J@~ 9.. .. ~
• Gj
i!tJ - ':. ,.. ~ ~
~ *~~
,nodo Break.
.-..,..vt,[Codoll <• X
l<~motv) .:] !(l)c<Lv-.S) CiJ @) ili i5
•· S~Ukll\~' (2p-o~ts)
Di.- :,Input. 1:1 St.-rino
Di• db1Rct.urn .l:, Doublc . e ª°"""-
~ Rcfeuinces
- !!) -....vb
'Get. user Input.
DUI dblPt\',ISl'ICnt. ,.. Doublo
coo.sol e . vr 1t.eL1n~ ("E11t.e:r t oan amount.: "J
~Input.• con:sole,Rea.d.L1nc()
Stop
dblReturn • CObl (slnput.J

' ( CCt\t.C thc- to.bli:


O\l.t.put.rtort.oaoeTable(dblPaYffll!nt.J

tnd Sub •

• ' •
l.OC:iils o [1 rommand Wndow - lnwned1..ite ti> l'3
I~ VOU. T
d:lf>~ O Ooutle
<l*tetun O Dcuble:
SIIIC:Yt 'l '2'1X1X/' St,"'J

Use o ,nodo Break para auxiliar na depuração de seus programas. Nesse ,nodo, são disponibili-
zadas várias ferramentas por meio das quais você poderá visualizar o conteúdo de variáveis, 1no-
nitorar ou alterar o fluxo do programa, ou testar blocos de código. Essas ferra1nentas terão u,n
valor inesti1nável na revelação e correção de erros em seus programas. Se quiser introduzir o
modo Break, en1pregue a palavra-chave Stop, con10 mostra a Figura 6.3.
Co1no alternativa, você pode inserir utn ponto de interrupção na linha onde gostaria que o pro-
grruna fosse interro,npido. Ele será executado normalmente até que atinja a lin.ha e, em seguida,
passará para o ,nodo Break e retornará ao IDE. Seu programa ainda estará e1n processa1nento e1n
segundo plano, mas se encontrará em tuna pausa. Um ponto de inte1Tupção pode ser inserido em
seu código de utna entre três maneiras:
• Dê u1n clique na 1nargem colorida esquerda da janela do código, próxin10 à linha na qual
gostaria que estivesse o ponto de interrupção. U1n círculo vennelho deve aparecer na
1nargem.
• Dê um clique co,n o botão direito do mouse na linha do código e selecione Inse1tBeakpo-
int. Um círculo vermelho deve aparecer na 1nargem.
164 Dia 6

• Selecione Debug, New Breakpoint no n1enu. Isso abrirá a caixa de diálogo New Breakpo-
int (veja a Figura 6.4). Essa caixa é o meio mais flexível de criar um ponto de interrupção.
Ela não só pennite que você defina u1n ponto de interrupção para encerrar o programa
quando uma linha for atingida, como ta1nbém que os crie para situações em que uma va-
riável for alterada ou alcançar um valor específico, ou siinples,nente em que uma certa
condição for verdadeira.

New Breakpolnt
FIGURA 6.4
- ,... 1Md,.,,, 1o... 1
Caixa de cliálogo & e.okCIXCCI.ÓOn ~ tho Qr0!70m ,NCMs tNs loc:6\ioo J'I • hntion.

New Breakpoint.
E"""'°"'
ua,, I•
'""'''.." ~1,- -

'"""'°"··· 1(no""-·>
~"""'··· 1b!e,k-

OK I CN>Cfl H,lp

Usando Pontos de Interrupção para Examinar o Programa de


Exemplo
Carregue a versão inicial do programa no IDE (do diretório OriginalMortgage), de 1nodo que
você possa testar os pontos de i.nterrupção. Co1n o ,nódulo modMa i n. vb abe1to no editor, dê um
clique na 1narge1n colorida, próximo à linha
dblReturn = CDbl(slnput)
Deverá aparecer un1 círculo verrnelho perto da linha. Se isso acontecer, inicie o progran1a no
!DE. A janela do console deve surgir, pern1itindo que seja digitado um valor para o empréstimo.
Insira 10000 e pressione Enter. Você deverá ser enviado nova1nente ao IDE onde u1na seta a1na-
rela será adicionada ao círculo vermelho, como vemos na Figura 6.5. A seta amarela sernpre
mostra a próxima linha a ser executada.
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 165

FIGURA 6.5 fjlo (dt eroio<t ~ Qebt,J """' -


'jjew !!:\>
E.,>;ecutando u,n 'iJ · ll) • ~ !iil 1111 lQ li'!, n • r , • ~ • r.. , -..,
progra,na co111 111n • " • Q ó . , (:1 "-.! "'" @ • • ";j "'- b •. , ....
ponto de [-.-« •"""2090
. ~

1nterr11pçao. 3 ,.~. ,·,...


1 --.---------.3
•• X
i:i m 61 r..
. _ ...._ .(,,.o;,d)
Dua dblRet.urn As Double
.. B (a Mort1J.t0e
~ 9il R.eftren:os
Dim. dblP6~nt; J.~ Doublc
J !) AssrobMrlo.Yb
!!'.) ...t<.,n.,o
c,0n, 01c: . llt i.te ( ''tnu:r loon
Nt10unç. : " )
slnput. • Consol e. ReedL 111e (J
C) dbl Rccurn • CDb l (slnpuc)

•create eh.e t&.bl e


Out.putNortgo.qeTob Ie Cdb l Rcturn) •

'°'"'
""'---.,..1v-...,-------....1;,y.
l"''i""' •}<) C<,ttn,
-_:::J - •-
O X

Do.ti,
oc..tle
51,hq

• • •
I
--dod
Q ,..... ii;;1 1.0<A1s!~wo<ch1 :mcdlSl.oci<l@&e-.. :;J c......-><1 ... El °"""'1 0 t"""" 1
i,, 16 Col9 Õ,9 [ím

Percorrendo Seu Código


Um dos recursos 1nais úteis disponíveis no n1odo Break é a capacidade de percorrer o código. Ele
pennite que o usuário visualize o fluxo ou lógica de u1n progran1a, possivehnente encontrando
erros en1 laços ou durante chamadas de procedimentos. Depois que você tiver entrado no 1noclo
Break, poderá co1neçar a percorrer seu código linha a linha. Isso pern1itirá que exa1nine o efeito
de cada uma delas sobre as variáveis ou que se certifique de que os prograrnas executem real-
mente as etapas que planejou. Há quatro funções principais relativas às etapas, disponíveis no
1nenu Debug ou na barra de ferra1nentas de depuração. ·Elas são:
• Step lnto Esse é o comando de etapas 1nais usado.Toda vez que você selecioná-lo, a
próxima ação disponível será executada. Selecione-o de dentro do procedin1ento Output-
MortgageTab l e, e você deve ver a seta a1narela se mover para a linha
OutputMortgageTable(dblReturn)
Selecione-o novatnente, e você deverá passar para o procedi1nento OutputMortgageTab l e.
Selecione-o 1nais uma vez, e estará na li nha
Console.Writeline(Tab & "Years" &Tab & "10" &Tab & "15" &
Tab & "20" & Tab & "25" & Tab & "30")
Observe que a linha amarela não se deté1n nas instruções de declaração de variáveis. Isso
acontece porque elas não são consideradas código executável. A seta a1narela só parará
em linhas que execute1n algo, e não nas que declara1n variáveis novas.
• Step Out Ocasionalmente este comando será útil se você passar por um proceditnen-
to no qual sabe que não há erros. Ele faz com que o resto do procedimento seja executado
e move a seta a1narela para a primeira linha depois da chamada original. Selecione-o de
166 Dia 6

dentro do procedilnento OutputMortgageTabl e, por exemplo, e deverá ser enviado de vol-


ta ao procedimento Sub Main.
• Step Over Tambén1 é útil quando há uma depuração nos procedimentos etn que sabe-
1nos que não existem erros. O co1nando Step Over tratará o procediinento como se fosse
apenas uma linha de código. Por exemplo, se a seta a1narela estivesse na linha Output-
MortgageTab lede Sub Ma i n, e Step Over fosse selecionado, todo o código de OutputMort -
gageTab l e seria executado, e você seria transferido para a próxi1na linha de Sub Mai n.
• Run To Cursor Outro comando útil quando você sabe que uma seção de código não
possui erros. O comando Run To Cursor permitirá a execução de todo o código até a Jinha
selecionada. Para usar este modo, selecione a linha até onde deseja executar o código e a
opção Run To Cursor no 1nenu Oebug ou no de atalho.

Usando o Recurso de Percorrer o Código para Examinar o Programa


de Exemplo
Percorrer um progra1na às vezes pode revelar erros causados pelo desenvolvedor. Esses podem
ser laços que tenninam precoce,nente ou que não são executados o suficiente, ou testes lógicos
que não produze1n os resultados esperados.
Para percorrer o progra1na de exemplo, faça o seguinte:
l . Encerre o progra1na selecionando o botão Stop Debugging na barra de ferra1nentas ou se-
lecione Stop Oebugging no 1nenu Debug.
2. Remova o ponto de interrupção que você criou anteriormente dando um clique no círculo
vermelho da 1nargem e gere um novo no início do primeiro laço For dentro de Output -
MortgageTab l e.
3. Inicie o programa. Quando as infonnações fore1n solicitadas, digite 100000 como quantia
do empréstin10. O programa deve entrar no modo Break na linha
For iRate = 500 To 1000 Step 25
4. Percorra o código (ou selecione R.un To Cursor) até que alcance a linha
Consol e . Writeline()
5. Exa1nine a janela do console (veja a figura 6.6). Observe que na verdade há dez itens na
linha, e,n vez dos cinco que você esperava (um para cada coluna de 10 a 30). O valor da
taxa de juros está sendo repetido a cada passagem pelo laço quando só deveria ser execu-
tado uma vez antes do laço.
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 167

FIGURA 6.6
E.,'(ibindo o cabeçalho.

6. Após interromper o programa, transfira a linha de código que exibe a taxa de juros en1
cada linha da tabela para que fique antes do início do segundo laço For. O resultado deve
ter a seguinte aparência:
Antes:
For iYears = 10 To 30 Step 5
Consol e.Write(Format(dblAnnuallnterest, "0.#0") & Tab &Tab)
Depois:
Conso l e.Write(Format(dblAnnuallnterest, "0.#0") & Tab & Tab)
For iYears = 10 To 30 Step 5
7. Pressione Step Into para continuar a execução do progra,na. Observe que a seta amarela
está nova1nente no início do procedimento Out putMortgageTab l e. O Visual Basic .NET
reco,npilou e recarregou o procedi,nento co1n as alterações.
8. Agora se você percorrer o código até a linha da etapa 4, deverá ver apenas cinco valores
exibidos nessa linha, con10 na Figura 6.7. Eles ainda serão valores incorretos, ,nas pelo
,nenos u,n dos erros foi corrigido.

FIGURA 6.7
Prilneira correção.

9. Execute o progra1na até o final usando antes Step Out para retornar a Sub Mai n. Exa1nine
a janela do console para ver os valores errados (eles são os 1nes1nos para todas as Iinhas).
Em seguida, retorne ao IDE e selecione Continue para finalizar o progra1na.
168 Dia 6

Examinando as Variáveis
Além de investigar o tluxo da lógica de seu aplicativo, o Visual Basic .NET fornece ferramentas
que pennite1n a visualização do conteúdo das variáveis. Isso pennite detenninar se seus conteú-
dos representarn o que você definiu e se o cálculo está correto.
Exatamente como quando percorreu o código, há várias ferramentas que você pode usar para
monitorar as variáveis. Algumas das n1ais úteis são rnostradas na Figura 6.8 e descritas a seguir:
• Pesquisa ern janela suspensa Se você rnantiver o cursor do mouse posicionado sobre
u1na variável do procedi1nento atual, tuna pequena janela aparecerá mostrando seu valor
no momento. E' possível ver isso na Figura 6.8, e1n que a variável dbl Return atualn1ente
annazena o valor 100000. Essa é uma ferra1nenta útil e prática se só quisennos fazer uma
verificação breve de u1n valor ocasionahnente. Outro beneficio dessa ferra1nenta é que se
pode selecionar a parcela de u1n cálculo para saber seu valor, se1n precisar que todo ele
seja executado.
• Janela Locais Esta janela e1n geral aparece na parte inferior da tela quando se está no
1nodo Break. Caso contrário, selecione-a na opção Windows do 1nenu Debug. A janela
Locais 1nostra todas as variáveis do procedi1nento atual, assiin co1no seu tipo e valor no
1nomento. Isso é prático quando se está percorrendo um código, porque os valores ficarão
com a cor ver1nelha quando forem alterados. A janela Locais será útil sempre que você
depurar um procedimento que altere os valores das variáveis.
• Janela Watch Esta janela e1n geral aparece na parte inferior da tela quando se está no
1nodo Break. Caso contrário, selecione-a na opção Windows do menu Debug. A janela
Watch mostrará as variáveis as quais você estiver interessado. Dê um clique co1n o botão
direito do mouse nas variáveis e selecione Add Watch para adicioná-las à janela. Se elas
estivere1n no escopo, o valor atual será exibido. Senão, ela o informará que, "O nome
[no,ne de sua variável] não foi declarado". Esta janela é útil para monitorar um grupo de
variá.veis. E1n vez de só exa1niná-las quando estiverem na janela Locais, será possível
rnonitorá-las durante toda a sessão de depuração.

Examinando Variáveis para Depurar o Programa de Exemplo


Já que você deu uma aparência melhor para o layout da tabela da hipoteca, o único erro que ainda
poderia existir estaria no cálculo de cada variável. E' recomendável depurar a função Payment
para se certificar de que apenas os valores corretos estarão em uso. Siga estas etapas:
1. Encerre o progra1na se ele estiver em execução agora. Remova todos os pontos de inter-
rupção existentes e adicione tun à primeira linha da função Payment. A linha deve ser esta
Dim dblMonthlylnterest As Double = Annual lnterest / 1200
2. Adicione um segundo ponto de interrupção à linha End Sub de Sub Main para pennitir
que você visuali ze a tabela antes que o prograrna se encerre.
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 169

FIGURA 6.8 elo tdt l)ow l)ojo<t ~ld C,,,.,,, lod' li!, _ U,b

Exarninando os valores @• !ll · ~ " " x "t.l e, ...., · · · .i;:i • e+ 1 , """9


• 11 • m <> c:-3 ( i C.J ttox @ •.
das variáveis.


CoMol c , vru.e LtrieO
t:cxt.

Pnf'C9,III 100000
cll~tnt.e1f'St 6.ZS
R«• 625
H~s $5


.....
lf
_..... · """"°"' ... El o..cw. lEl '""'""
Ln'41 COISI ChSI
1
- ft'iis

Mesmo começando com uma declaração, essa li nha é executáv el por causa da
atribuição.

3. Execute o progra1na até que alcance o ponto de interrupção. Insira 100000 para o valor do
emprésti1no.
4. Quando o programa entrar no modo Break, exan1ine ajanelaLocals. Observe que ela in-
clui todos os valores de Principal, Annuallnterest e Periods. Do 1nes1no ,nodo, se você
1nantiver o cursor do 1nouse sobre u1na variável (por exen1plo, Annua l Interes t) no 10.E,
deverá ver u1na janela suspensa 1nostrando o valor atual.
5. Avance u1na etapa para processar essa Iinha. Podemos notar que a variável
dbl Monthlylnterest se alterou e ficou vermelha na janela Windows.
6. Selecione o código
1 + dblMonthlylnterest A Periods
En1 seguida, ,nantenha o cursor do mouse sobre o texto selecionado. Umajanela suspensa apare-
cerá, informando que o valor é 1. U1n cálculo rápido em algum local confirmará que isso estará
correto se você executar prilneiro a operação exponencial e, e1n seguida, a adição. No entanto, o
valor certo deveria ser aproxilnada1nente 1.647 porque a adição deve ser efetuada antes, e só en-
tão elevaría1nos o resultado à quantidade referente aos períodos. Esse erro será repetido na se-
gunda metade da função. Acrescente parênteses ao cálculo de ,nodo que as adições sejam
executadas antes e, então, teste o valor novamente.
7. De maneira se1nelhante, o cálculo como u1n todo sofre de uma grande carência de parênte-
ses. Interrompa o programa e altere a linha de cálculo para que fique como a descrita a seguir:
170 Dia 6

Return Principal * (dblMonthlylnterest *_


((1 + db l Monthlylnterest) A Periods) / _
(((1 + dblMonthl ylnterest) A Periods) - 1))

DICA
Os parênteses não custam nada. Quando você estiver escrevendo uma função
matemática, não economize em seu uso - empregue quantos precisar para se
certificar de que as operações sejam efetuadas na ordem correta. Como alter-
nativa, é possível colocar cada etapa em uma linha, embora isso exija mais va-
riáveis temporárias no cálculo.

8. Encerre o aplicativo, remova o ponto de interrupção na .linha da função Payment e reexe-


cute o progra1na. Você deve ver a tabela correta da hipoteca, co1no 1nostraaFigura 6.9.

FIGURA 6.9
Tabela correta da
hipoteca.

Retoques Finais no Programa de Exemplo


f-lá algu1nas outras alterações 1nenores que você pode fazer para organizar melhor este progra-
1na. Por exe1nplo, o código que é usado para fonnular uma pergunta ao usuário poderia ser inse-
rido e1n uma função. Isso pennitiria sua posterior substituição por um código que processasse
uma função se1nelhante, porém co1n formulários Windows, da Web, ou em algu1na outra tela.

Uma boa idéia é isolar seções de código que sejam específicas do sistema ope-
DICA racional ou da interface com o usuário nos procedimentos. Assim, quando
você precisar alterar a interface com o usuário, só terá de substituir o procedi-
mento, e não o código que o utiliza.

Outra alteração se1nelhante é simplificar o cálculo da função de paga1nento da hipoteca. Já que a


expressão (1 + dblMonthlylnterest) A Periods) aparece duas vezes no cálculo, você pode
criá-la como uma operação isolada. Declare uma variável ternporária do tipo duplo para armaze-
nar o conteúdo e substitua o cálculo por essa variável.
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 171

Depois que você tiver feito todas as alterações no programa do exemplo, ele deve ficar se1ne-
lhante ao 1nostrado na Listagem 6.9.

CôOIGO LISTAG EM 6.9 Código Depurado

1 Option Explicit On
2 Imports System
3 Imports Microsoft.VisualBasic.ControlChars
4
5 Module modMain
6
7 Sub Main()
8
9 Oim slnput As String
10 Oim dblReturn As Oouble
11
12 'Solicite a entrada do usuári o
13 Oim dblPayment As Oouble
14 Conso l e .Write( ''Oigite a quantia do emprêstimo:'')
15 slnput = Console.Readline()
16 dblReturn = CObl(slnput)
17
18 'Crie a tabela
19 OutputMortgageTable(dblReturn)
20 Console.Write( ''Pressione ENTER para continuar'')
21 Conso l e.Readline()
22 End Sub
23
24 Private Sub OutputMortgageTable(ByVal Principal As Oouble)
25
26 Oim iYears As Integer
27 Oim iRate As Integer
28 Oim dblAnnualinterest As Oouble
29
30 Console.Writeline(Tab & ''Years'' & Tab & ''10 '' & Tab & ''15'' &
31 Tab & ''20'' & Tab & ''25'' & Tab & ''30'')
32 Conso l e .Writeline( ''Juros'' )
33
34 For iRate = 500 To 1000 Step 25
35 dblAnnuallnterest = iRate / 100
36
37 Console.Write(Format(dblAnnuallnterest,"0. #0") & Tab & Tab)
38 For iYears = 10 To 30 Step 5
39 'iYears * 12 para obter o número de meses (pressuponha pagamentos
• mensais)
40 Console.Write(Format(Payment(Principal,
41 dblAnnual Interest , i Years * 12), "0 . 00")& Tab)
42 Next
43 Console.Writeline()
172 Dia 6

CÓDIGO LISTAGEM 6.9 Código Depurado (continuação)

44 Next
45
46 End Sub
47
48 Public Function Payment (ByVa l Princ ipal As Double,
49 ByVal Annuallnterest As Double, _
50 ByVal Periods As Integer)As Double
51 Dim dblMonthlylnterest As Double = Annuallnterest / 1200
52 Return Principal * (dblMonthlylnterest * _
53 ((1 +dblMonthlylnterest) A Periods) / _
54 (((1 +dblMonthlylnterest) A Periods) - 1))
55 End Function
56
57 End Module

Outras Ferramentas para Depuração


Muitas outras ferra,nentas estão disponíveis para ajudá-lo na depuração. Muitas delas são avan-
çadas e não faze,n parte do escopo deste livro, ,nas você deve ao 1nenos saber que existe1n. Entre
elas destaca1nos
• Ttntnediate Window Está sempre disponível no 1nenu Debug, Windows. Abre urna
janela que permite inserir uma linha de código a ser executada imediata1nente. lsso possi-
bilita o teste de pequenos trechos de código. Já que está disponível havendo ou não a de-
puração, pode-se usar a janela Tm,nediate para testar pequenos cálculos enquanto os
progratnas são escritos. Utn emprego comutn para estajanela é exibir o conteúdo das va-
riáveis ' disponjbilizando-o' nesse local, por exetnplo:
?dblMonthlylnterest
4.16666666666667[-03
• Quickwatch Window Disponível no menu Debug quando se está no ,nodo Break.
Abre uma janela que 1nostra o valor das variáveis. Esse recurso ficou u1n pouco ultrapas-
sado por causa da janela suspensa que já exibe o valor das variáveis. No entanto, a janela
Quickwatch ta1nbé1n é útil para testar as expressões tanto quanto as variá.veis.
• Cal) Stack Disponível no 1nenu Debug, quando se está no 1nodo Break. Abre u1naja-
nela que mostra a lista de procedi1nentos ativos no 1nom.ento. Por exemplo, se seu Sub
Ma i n cha,nasse OutputMortgage Tab 1e, a pilha de chamadas exibiria os dois procedimentos
(em orde,n inversa). Você pode usar esse recurso para navegar nos dois proced i,nentos;
isso pertnitiria a visualização da linha de Sub Mai n que chama o segundo proceditnento.
.Esta janela pode ser e111pregada para depurar proble1nas ern que a decisão errada seja sele-
cionada em u1na instrução If.
O Que Fazer Quando Programas Bons Apresentam Problemas e .. . 173

• Disassembly Disponível no 1nenu Debug, quando se está no modo Break. Esta é uma
ferramenta avançada que 1nostra a linguage,n de máquina efetiva criada para o programa
e só será reahnente útil se você conhecer a 1nontage1n.
• Threads Disponível no menu Debug, quando se está no modo Break. Esta, é uma fer-
ramenta avançada que 1nostra as linhas de execução ativas em um programa. Util quando
se executa uma progra1nação co1n múltiplas linhas de execução no Visual Basic .NET.
O Visual Basic .NET fornece 1nuitas ferra1nentas que o ajudarão a disponibilizar programas sem
erros. A melhor 1naneira de conhecer as ferramentas e saber quais delas o auxiliarão mais, é tes-
tá-las. E1n vez de tentar eliminar os erros co1n a leitura do código, percorra-o 1ninuciosamente,
investigue os valores das variáveis utilizadas e isole as falhas empregando essas ferramentas.

Resumo
Todos os progra1nas tê1n erros. Algumas vezes, o erro está na pessoa que executa o progra1na.
Em outras, há realmente uma falha ou erro no código. Isso pode acontecer porque o autor do pro-
grruna não testou todas as possibilidades de entradas ou não protegeu o programa da fa lta de ar-
quivos ou bancos de dados. Em qualquer dos casos, é sua responsabil idade, co1no
desenvolvedor, tentar assegurar que nenhu1n desses erros faça o usuário perder infonnações.
Você deve se esforçar para tornar seus progra1nas tão livres de erros quanto possível. As ferra-
mentas de depuração do Visual Basic .NETo ajudarão nessa tarefa. Certifique-se de usá-las para
percorrer seu código e de que o fl uxo se encontre da fonna que foi planejado. Assegure que as
variáveis armazene1n os valores corretos e que os cálculos sejam exatos.
De 1naneira se1nelhante, você pode proteger o programa de erros adicionando o trata1nento de
exceções estruturadas às seções críticas de código. Pontos propensos à falhas - como onde o có-
digo abre arquivos, lê ou grava informações, ou faz cálculos - deve1n ser inseridos em blocos
Try ... Catch ... End Try. Esses blocos trata1n os erros de 1nodo sofisticado, pennitindo perfeita-
mente que o usuário continue a usar o programa.
Na próxi1na lição, você trabalhará co1n objetos. Co1no poderá ver, já esta1nos fazendo isso; no
entanto, estudaremos o assunto com 1nais detalhes no Dia 7, "Trabalhando com Objetos".

P&R
P O que acontecerá se eu tiver algum código antigo que use n Error Preciso reescre-
vê-lo para empregar o tratamento de exceções estruturadas?
R Não. Se incluir a referência Microsoft . Visual Bas i e, poderá continuar a usar On Error
Goto e On Error Resume Next. Alé1n disso, o objeto Err está disponível para você.
1 174 Dia 6

Workshop
O Workshop foi planejado para ajudá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e começar a pensar e,n co,no colocar seu conheci,nento em prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".

Teste
1. Dê o no,ne de três ferra1nentas que pode,n ser usadas para visualizar o conteúdo de utna
variável enquanto você estiver no n1odo Break.

Exercícios
J. Você acabou de herdar o bloco de código a seguir. Ele solicita ao usuário dois valores.
Em seguida, calcula e exibe u,na tabela com a multiplicação de todos os valores entre os
dois núrneros inseridos. Por exemplo, se o usuário inserir 5 e 9, o resultado deve ser se-
tnelhante a

RESULTADO Tabela de Multiplicação (de 5 a 9)


5 6 7 8 9
5 25 30 35 40 45
6 30 36 42 48 54
7 35 42 49 56 63
8 40 48 56 64 72
9 45 56 63 72 81

Adicione o trata1nento de exceções e depure o código da Listagem 6.10 para assegurar que ele
gere o resultado desejado.

Código LISTAGEM 6.10 Código da Tabela de Mul tiplicação


1 Imports System
2 Imports Microsoft.VisualBasic.ControlChars
3
4 Module modTable
5
6 Sub Main()
7 Dim ilow,iHigh As Integer
8 Dim slnput As String
9
10 'Permita várias execuções da geração da tabela
11 Do
12 'solicite valores
13 Console.Write("Valor mínimo (máximo igual a 20, O para
finalizar): ")
O Que Fazer Qua ndo Programas Bons Apresentam Problemas e .. . 175

Código LISTAGEM 6.10 Código da Tabela de Multiplicação (continuação)


14 slnput = Console.Readline()
15 ilow = Cint(slnput)
16
17 If ilow <>O Then
18 Console.Write("Valor máximo (máximo igual a 20): ")
19 slnput = Console.Readline()
20 iHigh = Cint(slnput)
21
22 OutputTable(ilow, iHigh)
23 End If
24 Loop Until ilow = O
25 Console.Write( ''Pressione ENTER para continuar'')
26 Console.Readline()
27 End Sub
28
29 Private Sub OutputTable(ByVal MinValue As Integer,
30 ByVal MaxValue As Integer)
31 Dim iCount, iCount2 As Integer
32
33 Console.Wri teli ne()
34 Console.Writeline( ''Tabela de multiplicação ({O} a {1}'',
35 MinValue,MaxValue)
36
37 ' exiba o cabeçalho
38 For iCount = MinValue To MaxValue
39 Console. Writeline(Tab & CStr(iCount))
40 Next
41 Console.Writeline()
42
43 ' Exiba cada uma das linhas da tabela
44 For iCount = MinValue To MaxValue
45 For iCount2 = MinValue To MaxValue
46 Console.Write(CStr(iCount)& Tab & CStr(iCount * iCount2))
47 Next
48 Console.l~riteline()
49 Next
50 End Sub
51
52 End Modul e

2. Conforn1e avançar no livro e tiver problemas co1n seu código, tente usar as ferra1nentas
de depuração para corrigir o progra1na. E1npregue pontos de interrupção para isolar se-
ções que você achar que possan1 conter erros, percorra o código e utilize as janelas Lo-
cais e Watch para 1nonitorar as variáveis.
176 Dia 6

3. Se você encontrar exceções em seus progra1nas, adicione o tratamento de exceções. Pro-


cure na ajuda on-line a palavra-chave ' Exception' para examinar os diversos tipos de ex-
ceções. Como alternativa, pesquise a lista selecionando Exceptions no 1nenu Debug, do
Windo\.vs.
4. Use o aplicativo do exemplo para testar os tipos diferentes de pontos de interrupção. Ten-
te configurar um quando o pagamento estiver abaixo de um certo valor.
SEMANA 1

DIA

Trabalhando com Objetos


Tanto o uso quanto a criação de objetos são essenciais para o desenvolvi1nento no Visual Basic
.NET. Embora você já tenha trabalhado co1n eles no decorrer deste Iivro, esta lição será dedicada
a esse tópico e abordará:
• O que são objetos.
• Con10 funcionam.
• Onde os objetos serão inseridos ern seus programas.
Co1neçaren1os com a definição básica de objeto e todos os termos e conceitos que a aco.1npa-
nha1n.

Para Começar: O Que É um Objeto?


Para definir o tenno 'objeto', podería1nos retornar no te111po até o latin1 medieval, 'obiectum' ou
'coisa colocada na frente da 1nente' , 1nas para usannos u1n tenno mais simples começare1nos
apenas com a palavra ' coisa'. Um objeto é uma descrição genérica de qualquer coisa que se pode
querer discutir, ou usar no trabalho. En1 conversas corriqueiras, o te11110 objeto em geral se desti-
na a descrever apenas coisas rnateriais, mas en1 progra1nação, em que 1nuito pouco é reahnente
físico, essa definição é ampliada para incluir qualquer entidade. Podemos nos referir a utn carro,
pessoa ou prédio como um objeto, mas ta1nbé1n é aceitável usar esse termo para descrever algo
menos tangível como uma taxa de juros ou uma regra que será aplicada à correspondência eletrô-
nica recebida.
1178 Dia 7

O uso de objetos pen11itirá que seus programas sejam dedicados às entidades com as quais você
estiver trabalhando, cujo objetivo final será produzir siste,nas que sejam fáceis de compreender
e aprimorar. E1n vez de um programa e1n que todas as infor,nações e códigos relacionados a ape-
nas u111a entidade esteja111 espalhados por todo o aplicativo, uma abordagem co,n base no objeto
consolidará essas infom1ações trazendo-as para a definição do objeto.

Classes e Instâncias
Para co1npreender os objetos você terá de passar rapidamente para o conceito de classe. As clas-
ses, co1no nas classificações, descrevem um grupo ou tipo de entidade, e todos os objetos são
1ne1nbros de alguma classe. Elas são a descrição de um objeto, fornecendo detalhes que definem
seu con1portamento e relatando que tipos de inforn1ação estão disponíveis sobre ele. Podería-
tnos, por exemplo, ter u1na classe Car (carro). Ela nos relataria que as informações a seguir esta-
ria1n disponíveis sobre um carro: sua cor, velocidade, peso, 1narca, modelo e ano. Todos esses
itens são atributos do objeto, parcelas descritivas de infonnação às quais nos referi,nos co1no
propriedades. Além dessas propriedades, a classe ta1nbém descreve o que o objeto pode fazer e
co,no. Esses comportamentos e,n geral são cha,nados de métodos do objeto, e un1 objeto carro
poderia ter tnétodos como "VirarEsquerda", "Avançar", "DarRé" e assirn por diante. E' co1n o
uso dessa classe, que fornece i1úormações sobre as propriedades e n1étodos do objeto,junto a al-
guns outros detalhes, como u1n n1odelo, que os objetos são criados.
Retornando ao exernplo do carro, a classe seria a sua especificação, o projeto que descreve co.,no
ele funciona e se parece. Essa classe é então usada para criar muitos carros, cada um com uma
existência própria, mas todos eles baseados na .1nes1na especificação. Todos possuem as mesm.as
propriedades porque elas provêm da especificação, co,no a cor, n1as cada tnn pode ter u1n valor
diferente para essas propriedades (carro azul, carro vern1elho, carro a,narelo e assim por diante).
Todos os carros ta1nbé1n co,npartilharia,n os 1nes1nos con1portan1entos ou ações (os 1nétodos da
classe), como "Avançar'' e os que fosse,n construídos a partir da mesma especificação executariam
essa ação da 1nes1na maneira.
Criar u1n carro com base na especificação é equivalente a gerarmos u,n objeto com base em uma
classe. Portanto, enquanto o Ford Thunderbird seria u1na classe, o T-Bird azul de Bob seria um
objeto. Cada tnn desses objetos é, individualmente, un,a instância da classe e não há li,nite para
quantas podem ser criadas. Todas as instâncias compa1tilha1n o 1nodelo, ou descrição, fornecido
por sua classe. Isso significa que todas as instâncias da classe Car terão as 1nes1nas propriedades
e 1nétodos e se comportarão da mesma maneira. No entanto, cada instância terá valores próprios
para suas propriedades; todos os carros tên1 uma propriedade e1n con1un1 que é a cor, n1as cada
um deles possui uma cor diferente.

Referências
En1 programação, u,n conceito adicional é introduzido, o da referência a utn objeto. Utna variá-
vel de objeto, qualquer variável declarada co,no u,n. objeto de algun1 tipo (Di m myCar As Car),
Trabalhando com Objetos

não contém o objeto proprian1ente dito, n1as apenas un1a referência a ele. É diferente dos tipos
co1nuns de variáveis, co1no os inteiros ou strings, nos quais elas armazenrun diretamente o valor.
Isso significa que mais de uma variável de objeto pode se referir, ou apontar, ao mesmo objeto.
E1n geral, esse não é o caso. O objeto é criado e usado e1n uma variável, 1nas é importante com-
preender a diferença entre os objetos e outros tipos de variáveis a esse respeito.

Passando o Conceito para o Código


Passe,nos alguns desses conceitos para código. Pri1neiro, para criar objetos, você deve ter uma
classe. Existen1 muitas classes disponíveis que forrun criadas por outras pessoas; na verdade, o
.NET Fran1ework inteiro é u1na 'biblioteca de classes' , un1 conjunto de classes pré-existentes
que podem ser usadas e1n seus progran1as. Em 11osso exe1nplo, no entanto, criaretnos nossa pró-
pria classe, Car, porque é algo SÍlnples de fazer.

=---
NOTA
A finalidade desta lição não é ensinar tudo a respeito de classes, e sim o sufi-
ciente sobre a construção de classes para que você compreenda as que já fo-
ram criadas. Esse conhecimento será útil para se aprofundar no .NET Frame-
work no Dia 8, "Introdução ao .NET Framework", e ele fornecerá uma visão
inicial para o desenvolvimento de seus próprios objetos no Dia 15, "Criando
Objetos no Visual Basic .NET".

Abra o Visual Studio .NET e crie tun novo projeto (E1npty Project) na pasta Visual Basic Pro-
jects (veja a Figura 7 .1 ).
Esse projeto não contém arquivo de nenhu1n tipo, portanto precisamos adicionar um a ele; sele-
cione Project, Add Class no menu. Isso adicionará u1na classe vazia ao projeto (chan1e-a
e l sCa r. vb ), um ótin10 ponto de partida para esse exercício. Agora, foi criado un1 shel I de uma
classe nesse arquivo, fornecendo o código a seguir:
Publ ic Class clsCar

End Class
Neste ponto, uma classe foi criada, mas está completa1nente vazia. Agora, dentro desse shell, pode-
01os co1neçar a descrever as propriedades e métodos dos objetos de nossa classe Car. Qualquer iten1
que inserirn1os nessa classe fará parte de todas as instâncias do objeto criadas a partir dele. Por en-
quanto, adicionaren1os as prop1iedades Make, Mode l e Co l or.
180 Dia 7

!'o:ew Pmject E3
FIGURA 7.1
Utn projeto vazio é ·8 VM Bosk ProiO(U
iniciado se,n conter D Vlsu.:I C# Pro!C(U
Cl \llsud e++ ~º""'
nenhurn arquivo. D Seb.!pa-.d D«:kr/meot Pror.t"ts conook \Vk'\cb~,;:
C!J Cl <w< Pro)O(t, ~O:atbn 5~

a
LC) V1M1 9.u:lkl SCMtcos

~
Em:(y Wtb t->,r1 Pro"« Jn
PrnV'. tt F',ci<iin, Fd~r
[An EffiPI.Y ~ o,e,it fe. (Jeat:íng
-
a lou:l ãppkêttiM li

r Add to 5oMbi
NEf;ISolJtlantme: 1Pw6jectl j P' Crel!it:edr&ttOryfc..SolJtlon

·~·
Pto)ed w,t be c,e.,t~ at O:\...\Dl.,nc4ftmo\f'tt Oocunenu\V&ud St:udo Pto,ed1\ProJe<t.1\Pto)ect r.

Hóp

Propriedades
As propriedades são atributos de um projeto que você pode recuperar e configurar, e que podetn
ser adicionados a urna classe de urna entre duas maneiras. O prin1eiro método, e ta1nbém o n1ais
si1nples, é declarar u1na variável como Pub li e. Con10 discuti1nos no Dia 3, "Introdução à Progra-
tnação con1 o Visual Basic .NET", Pub li e descreve o escopo da variável. No caso de uma classe,
qualquer ite1n que for declarado co,no Pub l i e estará disponível para todas as pessoas que usarem
essa classe. Em nossa classe, apenas incluir a linha Dim Year As Integer não criaria tnna proprie-
dade exposta porque Year só estaria disponível internamente. Se fôsse1nos declarar Year como Pu-
bl ic Year As Integer, então, de repente ela seria exposta e,n todas as instâncias desse objeto.

Instruções de Propriedade
Como alternativa, as propriedades podem ser declaradas co1n o uso de tuna sintaxe Property es-
pecial:
Dim myVar as <Tipo de dado da propriedade>
Publi c Property <Nome da propriedade>() As <Tipo de dado da propriedade>
Get
Return myVar
End Get
Set(ByVal Value As <Tipo de dado da propriedade>)
myVar = value
End Set
End Property
As duas partes da definição da propriedade, Get e Set, representa1n a recuperação do valor dela e
a configuração desse valor. Em geral, o código de Get só retorna o valor de uma variável interna
(uma variável no nível da classe que representa a propriedade, normalmente com o prefixo mpara
indicar um valor membro), e o de Set insere um valor (que é fornecido por 1neio da pala-
vra-chave especial Va l ue) na1nesn1a variável interna. Para irnplementar a propriedade da cor em
cl sCar, podería1nos usar um código como o da Listage1n 7.1.
Trabalhando com Objetos 181

CôorGO LISTAGEM 7.1 Criando Propriedades em Classes


1 Public Class clsCar
2 Dim m_sColor As String
3 Public Property Color()As String
4 Get
5 Return m sColor
6 End Get
7 Set(ByVal Value As String)
8 m sColor = value
9 End Set
10 End Property
11 End Class

Agora, adicione o código da propriedade aos de Ma ke e Mo de 1, letnbrando de tambén1 acrescentar


duas variáveis internas cornplementares (essas duas propriedades devem usar strings corno seu
tipo de dado). No aspecto geral, essa segunda maneira de declarar propriedades pode produzir
resultados semelhantes, tnas é muito mais flexível porque permite que você defina qual o código
necessário para controlar apropriada,nente a configuração e a recuperação de urn valor da pro-
priedade.

Propriedades Read nly e rite nly


Não será raro surgire1n propriedades que você achará ,nelhor serem de leitura, co,no a de urna
versão ou talvez uma data de criação. E' muito tnenos cotnum, se não i1npossível, haver uma pro-
priedade que possa ser alterada, porétn não lida, como um campo de senha. Em versões anterio-
res do Visual Basic, você poderia criar essas propriedades de leitura e de gravação apenas
optando por não itnplementar o trecho Set ou Get de suas definições. Isso é parcialtnente o que se
faz no Visual Basic .NET. Se tuna propriedade de leitura estiver sendo criada, o trecho Set de
sua definição não deve
,
ser incluído, porétn ReadOnly deverá ser especificada co.1no pala-
vra-chave adicional. E o que 1nostra o código a seguir cotn a propriedade Descri pt i on, que é um
valor calculado e, portanto, não faria rnuito sentido gravá-lo. Não seria interessante configurar
un1a propriedade co1no Descri pti on porque, na verdade, ela é apenas o resultado de un1 cálculo.
1 Public ReadOnly Property Description()As String
2 Get
3 Return m sColor & 11 11
&m sMake & 11 11
&m sModel
4 End Get
5 End Property
A palavra-chave usada para u1na propriedade de gravação é l~ri teOn 1y e, nesse caso, só é inseri-
do o trecho Set em sua definição:
1 Dim m_sPassword As String
2 Public WriteOnly Property Password() As String
11 82 Dia7

3 Set(ByVal Value As String)


4 m sPassword = Value
5 End Set
6 End Property

Criando a Instância de um Objeto


Depois que você tiver essa classe, podere1nos gerar uma instância dela en1 outra parte de nosso
projeto. Adicione urn módulo a ele (selecione Project, Add Module no menu) chan1ado Ma i n. vb
e crie urna sub-rotina Sub Ma i n ( ) ern seu interior. Nesse ponto, seu rnódulo deve ser sen1elhante
ao código da Listagem 7.2.

CôDIGO LISTAGEM 7.2 Criando um Módulo Novo para Teste


1 Module Main
2 Sub Main()

3 End Sub
4 End Module

Esse novo procedimento Mai n ( ) é o ponto de partida de nossa solução. Seu código será executa-
do quando processannos esse aplicativo, e é aí que escreveremos as instruções que trabalharão
com nossa nova classe. Para começar a usá-la, primeiro ternos de criar urna variável do tipo apro-
priado:
Dim objCar As clsCar 'ou Chapter7.clsCar, examinaremos melhor esse ponto
posteriormente
Essa linha parece estar declarando urna variável co,nurn, co1no urna string ou um inteiro, 1nas ela
é muito diferente. Aqui, ternos urna variável que poderia conter a referência a um objeto do tipo
cl sCar, 1nas que na verdade não armazena nada. Quando declaramos uma variável alfanun1éri-
ca, urna string é criada. Embora possa não ter nenhurn dado, ela realmente existe. Nesse caso,
não ternos nada em objCar. Portanto, a próxima etapa é criar u1na instância de nossa classe, o que
podemos fazer com a palavra-chave New:
objCar = New clsCar()
Agora sim criamos uma instância de cl sCar e atribuímos à variável objCar uma referência a esse
novo objeto. Já podemos, por meio de objCar, acessar as propriedades desse objeto:
1 objCar.Color = ''Red''
2 objCar.Make = ''Ford''
3 objCar.Model = ''Escort''
Essas propriedades podem ser recuperadas corn muita facil idade:
Dim sCarDesc As String
Trabalhando com Objetos

sCarDesc = objCar.Color & " " & objCar.Make & " " & objCar.Model
Já que os objetos funcionam por referência, podemos criar variáveis adicionais, todas apontando
para o 1nes1no local:
1 Dim objCar As clsCar
2 Dim objCar2 As clsCar
3 Dim sMake As String
4 objCar = New clsCar()
5 objCar2 = objCar
6 objCar.Make = "Ford"
7 objCar2.Make = ''Chevy''
8 ' objCar2 . Make é igual a objCar. Make
Compare isso co.1n u1na variável que não seja de objeto, co1n.o tuna string, em que o valor real é
transferido entre os locais:
1 Dim sFirstValue As String
2 Dim sSecondValue As String
3
4 sFirstVa l ue = ''Dog''
5 sSecondValue = sFirstValue
6 sSecondValue = ''Cat''
7 ' sFirstValue <> sSecondValue
Nonnahnente, quando lidamos co1n variáveis, logo que elas saem de escopo (veja o Dia 3 para
obter mais inforn1ações sobre as variáveis e o escopo), deixa1n de existir. Já que múltiplas variá-
veis pode1n apontar para u1n único objeto, as regras que controlam a eli1ninação dele são u,n
pouco diferentes. Quando todas as variáveis que fazem referência ao objeto não existirem 1nais,
ele se tornará inacessível e acabará sendo eliminado pelos serviços e1n segundo plano da plata-
forma .NET. Esse processo, que é chamado de coleta de lixo, permite que o progra1na crie e
libere livren1ente os objetos sabendo que o siste1na o aco1npanha, li1npando tudo que é desnecessá-
rio. Dessa 1naneira, a platafonna .NET faz a lin1peza para seu programa, fornecendo outro serviço
subjacente para que nenhum dos códigos precise se encarregar desse tipo de operação.

Encapsulando Códigos em Suas Classes


Agora você já viu, no código, a criação de u1na classe, a instanciação de objetos com base nessa
classe e a manipulação das propriedades desse objeto. Dando continuidade, considere a idéia de
u,na classe, diferente de u,n UDT, (novamente, veja o Dia 3 para obter ,nais infonnações sobre
as estruturas ou tipos definidos pelo usuário), que descreva 1nais do que apenas u,u conjunto de
valores, podendo incluir também o compo1ta1nento. Para fornecer essa i1nple1nentação do com-
portatnento, a classe apresentará 1nais do que apenas silnples códigos de configuração e recupe-
ração de valores; ela também poderá possuir u1n código para executar a validação da
propriedade e outras ações. Em nossa classe clsCar, pode1nos de1nonstrar esse recurso adicio-
nando um código de validação a nossas propriedades. E1n sua estrutura atual, você poderia con-
1 184 Dia 7

figurar a propriedade Co l or com qualquer valor alfanumérico, mesmo se ele nem fosse uma cor
(obj Ca r. Co l or = 11 John 11 ) . Para tornar nossa representação do objeto Car um pouco mais sofisti-
cada, poden1os adicionar um trecho de código que verifique qualquer valor infor1nado en1 u1na
lista de cores e rejeite o que não tiver uma correspondência. Isso envolve reescrever a rotina da
propriedade Color corno mostra a Listagem 7.3.

CóDIGO LISTAG EM 7.3 Adicionado Validação à Propriedade Color


1 Public Class clsCar
2 Dim m sColor As String
3
4 Public Property Color() As String
5
6 Get
7 Return m sCo l or
8 End Get
9
10 Set(ByVal Value As String)
11
12 Select Case Value.ToUpper()
13 Case "RED"
14 m sColor = Value
15 Case "YELL0\~ 11
16 m sColor = Value
17
-
Case "BLUE 11
18 m- sColor = Value
19 Case Else
20 Dim objException As System.Exception
21 objException = New System.ArgumentOutOf RangeException()
22 Throw objExcepti on
23 End Select
24 End Set
25 End Property
26
27 End Class

Agora, uma tentativa de configurar a propriedade com u1na cor inválida (inválida na lista interna
de nosso código, que considera a cor popular ' lilás', por exemplo, como inadequada) resultará
no lançamento de u1na exceção. Para obter 1nais informações sobre as exceções e o tratamento
de erros com base nelas, veja o Dia 6, "O Que Fazer quando Progra,nas Bons Apresentam Pro-
blemas e para Se Certificar de Que Isso Não Aconteça". Con10 descrito nessa lição, podemos tra-
tar corretan1ente essa exceção reescrevendo nosso código de teste (contido em Sub Ma i n ( ) ) para
que inclua u1na estrutura Try ... Catch. Esse código alterado é 111ostrado na Listagem 7.4.
Traba lhando com Objetos

CôDIGO LISTAGEM 7.4 Incluído Tratamento de Erros em Nosso Código de


Teste
1 Sub Main()
2 Dim objCar As clsCar
3 Dim sColor As String
4
5 objCar = New clsCar()
6 objCar.Year = 1999
7
8 Try
9 objCar.Color = ''Green''
10 Catch objException As System.ArgumentOutOfRangeException
11 'Opa! Trate o erro!
12 System.Console. l~ri teline("Opa! ")
13 End Try
14 sColor = objCar.Color
15
16 objCar.Make = "Ford"
17 objCar.Model = ''Escort''
18 System.Console.Writeline(objCar.Description)
19 End Sub

Além da validação da propriedade, que por si só já é poderosa, uma classe pode conter uma fun-
ção ou sub-rotina que não faça parte de nenhu,n código de recuperação ou configuração da pro-
priedade, gerahnente cha,nada método. Os tnétodos são criados para fornecer uma
funcionalidade relacionada a um objeto e etn geral agetn co,n base nas infonnações da proprie-
dade (porque estão disponíveis). Para nossa classe cl sCar, wn rnétodo útil pode ser gerar o tem-
po de existência do carro co1nparando a data e a hora atuais co1n u,na propriedade desse que
represente sua data de produção. Criar a propriedade da data de produção é relativatnente sim-
ples. Será do ,nesmo modo como a propriedade anterior exceto que é uma data, e adicionar esse
1nétodo é mes1110 tão fácil quanto criar tuna função pública na definição de nossa classe.
Primeiro, a nova propriedade:
1 Dim m dtManufactured As Date
2
3 Public Property Manufactured() As Date
4 Get
5 Return m dtManufactured
6 End Get
7 Set(ByVal Value As Date)
8 m dtManufactured = value
9
-
End Set
10 End Property
186 Dia 7

Se criássemos essa função como privada, ela poderia ser utilizada a partirdes-
NOTA sa classe, mas não estaria disponível para nenhum outro código. Como alter-
nativa, também podemos declarar elementos de nossa classe (propriedades,
funções, sub-rotinas) como Fri end. Essa declaração assegura que códigos
dentro da mesma montagem possam acessar essas partes da classe como se
fossem públicas, mas que elas estejam ocultas (privadas) para qualquer códi-
go externo à montagem da classe. (As montagens serão abordadas com deta-
lhes como parte da implantação no Dia 19, "Implantando Seu Aplicativo"; por
enquanto considere-as como as várias partes de uma mesma solução.)

A Listage1n 7.5 mostra o novo 1nétodo.

CôOIGO LISTAGEM 7 .5 O Método GetAge


1 Public Function GetAge() As Long
2 Dim lngDays As Long
3 Dim dtCurrent As Date
4 dtCurrent = System.DateTime.Today
5 lngDays = dtCurrent.Subtract(m_dtManufactured).Days
6 Return lngDays
7 End Funct i on

Depois que tivennos adicionado esse código a nossa classe, podere1nos cha1ná-lo por meio de
qualquer instância (obj Ca r. GetAge ( ) ), co1no na Listagem 7.6.

CôOIGO LISTAGEM 7 .6 Usando Nosso Método Novo


1 Dim objCar As clsCar
2 objcar = New clsCar()
3 objCar.Manufactured = #30/1/2000#
4 System.Console.Writeline(objCar.GetAge())

E1n algu1nas situações, o novo método seria mais adequado co1no tuna propriedade (que, então,
renomearíamos para Age, já que seria um atributo, e não tuna ação) porque na verdade não exe-
cuta nenhutna ação e só retorna u1n valor. Para nossa classe Car, um exemplo melhor de método
poderia ser algo relacionado à ação, como Sta rt Eng i ne, cuja i1nple1nentação é fornecida na Lis-
tagem 7.7.

CÓDIGO LISTAGEM 7 .7 Nosso Novo Método Orientado à Ação


1 Public Sub StartEngine()
2 System. Console.Writeline(''Vroom,Vroom ... !!!'')
3 End Sub
Trabalhando com Objetos

Com esse código adicionado a cl sCar, teríamos disponível u,n 1nétodo mais orientado à ação.
Por meio de tuna co1nbinação de propriedades (algumas com código e outras sern) e rnétodos, é
possível criar objetos co1nplexos. Lembre-se de que todos os objetos que compõetn o .NET Fra-
mework (co1no System.Console e outros) fora1n construídos de acordo corn essas regras, e os
que você criar terão as n1esmas características deles. A única diferença existente entre os objetos
do .NET Framework e os seus é que esses não precisa,n ser escritos no Fra1nework!

Tópicos Avançados
Embora as propriedades e métodos permitam que você crie objetos complexos e poderosos, o
suporte ao objeto na plataforma .NET possui 1nuitos outros recursos além desses básicos. Os re-
cursos avançados facilitarão a representação de conceitos e entidades en1 nosso código, produ-
zindo u111 siste1na 1nais shnples e1n tennos de utilização, 1nanutenção e expansão. Apesar de esse
suporte ser a1nplo, forneceremos u1na visão geral das cinco áreas principais: sobreposição, he-
rança, construtores, espaços de nome e n1embros estáticos da classe.

Sobreposição
Esta seção aborda os aspectos básicos da sobreposição; detalhes adicionais serão discutidos no
Dia 15, quando criannos nossos próprios objetos. A sobreposição penn ite que u1na única função
ou sub-rotina com vários parâmetros diferentes seja chamada. Isso possibilita que um só méto-
do, por exe,nplo, aceite os parâmetros em combinações distintas ou usando tipos de dados diver-
sos. Portanto, voltando ao nosso exe1nplo de cl sCar, seria possível projetar o método GetAge de
modo que ele pudesse funcionar de uma entre várias maneiras. A implernentação existente não
usa parâmetros e retorna a diferença en1 dias entre a data atual e a de produção, mas talvez tam-
bém quiséssemos permitir que o usuário de nosso objeto solicitasse a diferença entre a data da
produção e qualquer outra aleatória e ainda especificasse a unidade de tempo a ser usada. Para
fazer isso sem esse conceito de sobreposição, tería,nos de criar u1na função diferente para cada
chamada possível, como na Listagern 7.8.

CôDIGO LISTAGEM 7.8 Criando Várias Opções em um Único Método


1 Public Function GetAge()As Long
2 Dim lngDays As Long
3 Dim dtCurrent As Date
4 dtCurrent = System.DateTime.Today
5 lngDays = dtCurrent.Subtract(m_dtManufactured).Days
6 Return lngDays
7 End Funct i on
8
9 Public Function GetAgeAtDate(ByVal dtPoi ntlnTime As Date) As Long
10 Dim lngDays As Long
11 lngDays = dtPointlnTime.Subtract(m_dtManufactured).Days
188 Dia 7

CôDIGO LISTAGEM 7.8


- Método (continuação)
Criando Várias Opções em um Unico
12 Return lngDays
13 End Function
14
15 Public Function GetAgelnUnits(ByVal sUnit As String) As Long
16 Dim lngUnits As Long
17 Dim dtCurrent As Date
18 Dim tsDifference As System.TimeSpan
19 dtCurrent = System.OateTime.Today
20 tsOifference = dtCurrent.Subtract(m_dtManufactured)
21 Selec t Case sUnit
22 Case ''Hours''
23 lngUnits = tsOifference.Hours
24
25 Case "Oays"
26 lngUnits = tsDifference.Days
27
28 Case ''Minutes ''
29 lngUnits = tsDifference.Minutes
30
31 Case ''Years''
32 lngUnits = tsDifference.Days \ 365
33 End Select
34 Return lngUnits
35 End Function

Todas essas funções na verdade são apenas variações de GetAge, 1nas cada lista de parâ1netros di-
ferente e seu código correspondente precisa de seu próprio nome de função. Com a sobreposi-
ção, elitnina1nos essa restrição e pode1nos criar todas essas funções usando o 1nesmo nome,
GetAge. Para usar esse recurso, tudo que precisamos fazer é adicionar a palavra-chave Overl oads
à fi·ente de cada (incluindo a original) declaração de função (antes de Pub 1i e) e alterar todos os
no,nes das funções para que usem apenas um:
Publi c Overloads Function GetAge() As Long
End Function

Public Overloads Funct ion GetAge(ByVal dtPointlnTime As Date) As Long


End Function

Publ ic Overloads Function GetAge(ByVal sUnit As String) As Long


End Function
No código de nosso exemplo que usa essa função, já podemos escolher qualquer utnadas três de-
clarações que ela pode utilizar (veja a Figura 7 .2).
Trabalhando com Objetos 189

----- -
N OTA
Cada declaração de função deve ser diferente de alguma maneira - quantidade
de parâmetros, tipo de dados do parâmetro ou do valor de retorno-, ou não
poderá ser usada.

A sobreposição representa o conceito de que a 111esma ação ou solicitação pode ser usada de várias
maneiras e pennite que você use esse recurso na modelagem de seu objeto sen1 ter de recorrer à
criação de diversos 1nétodos diferentes (GetAge, GetAgeFromDate e outros). Essa técnica é usada
e1n todo o .NET Framework para pennitir a chamada de funções co,n vários conjuntos de parâ-
1netros diferentes. Considere, por exe1nplo, o método System. Conso 1e. Wri teL i ne, que pode ser
chamado usando qualquer u1na das 18 listas diferentes de parâ1netros. Como o Frarnework de-
monstra, essa é uma maneira útil de si1nplificar os objetos e fornecer 1nais opções aos progra,nas
que os usa,n.

FIGURA 7.2
ri'> tdt !llO>o &oloct ~ Q<wl IOOls - !!<lo
J'odas as versões 1$l· tri · ~ liloTi lill>e ,..,: ,.•. JJ. c.f ,·......,
disponíveis de 11111a ' . '
) - - - - .. . . ~-- •• ~ :i t> X
.função serão ,nostradas _:] 1.M...,
por meio do Syoec:m.Coru,olc , llciç.cL1ne ( "\lboop~ ... l
lntelliSense quando tn<:I Tcy
você usar o T/isual :,CO lo r • 9J?JS:6Ji ~S:9.19&

Studio .J\FET para criar ~ - "'roi:d"'


~ J&a.ç;,nqg~1 • "Escore~
u,n cliente. Sy:»tc• . Con:iole , l te:Li nc 19.lil G"S ·.Rs.SSS..!.R&.Wt
IJ'C'

ob j Co.r - trc'1 cbCar t)


obJCdr.Hanu.toctutcd • #l/30/2000 #
9 y~tcb. Con:1ole . UctteLinc CObjCo.é -GctlQe(JI

ObJCOt. Get.t.oe (
ln~ I"' 3 of 3 .,, Getf'9! h,Unit At StrlltQ) As ÍÕnç!

Z:nd Y.odule

I
Pul>lie Cla:,., e b ( o.r
• J Oi.JS m_dtftanuf.a.ecurt!:d l.:s Date

Q, IS

Herança
Para algumas pessoas, este é um dos recursos 1nais estimulantes do Visual Basic .NET - um re-
curso considerado fundamental para a criação de sistetnas co1n base e,n objetos e que faltava no
Visual .Basic até esta versão. Não vou questionar essa opinião, n1as de alguma forma consegui
desenvolver sisten1as por muitos anos, se1n a herança, antes que a platafonna .NET chegasse.
Independentemente disso, a inclusão da herança na linguagen1 do Visual Basic é un1 recurso im-
portante e vale uma pequena discussão.
Como já abordei nesta lição, os objetos são maneiras de você representar conceitos ou entidades
no código, e todos os recursos de objetos no Visual Basic foram projetados para ajudá-lo a tornar
a representação o mais útil possível. Em muitas situações, uma entidade ou conceito na verdade
1190 Dia 7

é o que chamaríamos de um subobjeto de uma entidade ou conceito n1ais básico. Vários exem-
plos disso são usados en1 livros de progra1nação e infelizmente não apresentarei nada tão revolu-
cionário. Considere nossa classe de objetos criada para representar carros, co1no um Ford
Mustang, u1n Toyota Celica ou urn Chevy Cavalier, A classe teria várias propriedades, como Do-
ors (quantidade de portas que o carro possui), MaxSpeed, Co l or e outras.
A classe Car geral, na verdade, contêm várias subclasses de objetos, corno Hatchbacks e Conver-
ti bl es. E' claro que essas classes teriain todas as propriedades de sua classe-pai, Ca r, como Do-
ors, MaxSpeed e Co l or, mas tambén1 poderiam ter propriedades exclusivainente suas. U1n carro
de dois ,nódulos poderia ter propriedades que descrevessern o tamanho e o co1nporta1nento de
sua porta traseira. Esse relacionan1ento, entre Car e suas subclasses, Hatchback e Convertible,
seria considerado u1n relacionamento pai-filho, e o método para representá-lo em nossos siste-
1nas é chamado herança. Diz-se da classe Hatchback que ela é herdeira de sua classe básica, Car.
Esse relacionatnento significa que, além de qualquer método e propriedade criados na clas-
se-filha, ela tan1bé1n possuirá todas as propriedades e n1étodos herdados do seu pai.
O exen1plo anterior foi iniciado co1n nossa classe Car e seguiu dai e1n diante. Use1nos o mes1no
ponto de partida, Car, e sigamos em direção a um exemplo 1nais detalhado de herança. Para co-
meçar, poderíamos ter uma classe básica Vehi cl e para representar qualquer tipo de veículo (bar-
co, carro, caminhão, avião) e que possuísse as propriedades MaxSpeed, NumberOfPasssengers,
Colore Descri pt i on. Essa classe seria faci11nente representada em tun código do Visual Basic,
como 1nostra a Listage1n 7.9.

CôDIGO LISTAGEM 7.9 Nossa Classe de Veículos


1 Public Class Vehicle
2
3 Public Property MaxSpeed() As Long
4 Get
5 End Get
6 Set(ByVal Value As Long)
7 End Set
8 End Property
9
10 Public Property NumberOfPassengers() As Long
11 Get
12
13 End Get
14 Set(ByVal Value As Long)
15 End Set
16 End Property
17
18 Public Property Color() As String
19 Get
20
Traba lhando com Objetos 191

CôDIGO LISTAGEM 7.9 Nossa Classe de Veículos (continuação)


21 End Get
22 Set(ByVal Value As String)
23 End Set
24 End Property
25
26 Public Function Description() As String
27 End Function
28 End Class

O código que é usado em vários proceditnentos dessa classe não é relevante para nosso exen1plo,
portanto o deixaremos de fora por enquanto. Se passássemos para algum outro código, tentando
usar nosso objeto (que poderia ser o da sub-rotina Sub Ma i n ( ) de nosso projeto, co,no em exem-
plos anteriores), perceberíamos que é possível criar objetos do tipo Vehi e 1e e trabalhar com suas
propriedades, co,no na Listage,n 7 .1 O.

CôDIGO LISTAG EM 7 .10 Trabalhando com Nossa Classe de Veículos


1 Module UseVehicl e
2 Sub Main()
3 Dim objVehicle As Vehicle
4 objVehicle = New Vehicle()
5
6 objVehicle . Color = ''Red''
7 objVehicle.MaxSpeed = 100
8 End Sub
9 End Module

Agora, adicionando u1na classe co1nple1nentar a nosso projeto (veja a Listagern 7.11), podemos
criar urna classe (Car) que herde características de Vehi c1e, exatarnente corno a classe real de ob-
jetos Car é uma subclasse ou filha da classe Vehi cl e. Já que esta1nos gerando uma classe projeta-
da para tratar apenas de carros, podetnos adicionar duas propriedades (NumberOfDoors e
NumberOfTi res) específicas dessa subclasse de Vehi c1e.

CôDIGO LISTAGEM 7.11 Criando uma Classe-Filha


1 Public Class Car
2 Inherits Veh i cle
3
4 Public Property NumberOfTires() As Integer
5 Get
6
7 End Get
192 Dia 7

CôDIGO LISTAGEM 7.11 Criando uma Classe- Filha (continuação)

8 Set(ByVal Value As Integer)


9
10 End Set
11 End Property
12
13 Public Property NumberOfDoors() As Integer
14 Get
15
16 End Get
17 Set(ByVa l Value As Integer)
18
19 End Set
20 End Property
21
22 End Class

A parte essencial desse código é a linha Inherits Vehicle, que informa ao Visual Basic que a
classe é filha de Vehi cl e e, portanto, deve herdar todas as propriedades e n1étodos dessa classe.
Novamente, não há nenhum código inserido na definição de qualquer dessas propriedades por-
que isso não é relevante no mo1nento. Depois que esse código estiver posicionado, sem nenhun1
esforço adicional, poderernos ver o efeito da instrução Inheri ts.
Voltando a nosso procedi1nento Main( ), podemos criar um objeto do tipo Car, e logo veremos
ele expor tanto suas propriedades quanto as da classe-pai (veja a Figura 7.3).
Quando urna classe herdada adiciona novos métodos ou propriedades, diz-se que a classe básica
está-se estendendo. Além da extensão, ta1nbé1n é possível que un1a classe-filha sobreponha al-
gu1na ou toda a funcionali dade da classe básica. Isso acontece quando a classe-filha implen1enta
um método ou propriedade que ta1nbé1n é definido na classe-pai ou básica. Nesse caso, o código
da classe-filha será executado e,n vez do código do pai, pennitindo que você crie versões espe-
cializadas da propriedade ou método básico.
Para tuna classe-filha sobrepor alguma parte ela classe básica, essa parcela deve ser 1narcada com
Overri dab 1e na definição da classe básica. Por exemplo, na versão de Vehi e1e listada anterior-
mente, nenl1u1ua de suas propriedades possuía a palavra-chave Overri dab 1e e, portanto, as
classes-filhas não poderiam fornecer suas próprias i1nple1nentações. Em lnna dernonstração
de como a sobreposição é configurada nas classes básica e filha, o código da Listage,n 7.12 n1ar-
cará a função Descri pt i on ( ) con10 podendo ser sobreposta e, e,n seguida, a sobreporá na clas-
se-filha Car. Observe que as pa,tes não relevantes das duas classes forarn re,novidas para dar
maior clareza.
Trabalhando com Objetos 193

FIGURA 7.3 l:lt [<k 'j)ew - ~ - 1""' ~ u...


As classes expõen, ijl· ~ · ~ lil"

1,Qii 8 1·.,:• ,.:. gi. r. l .-..


todas as suas
propriedades e F5lte1Uno (Wiodow1Applic,11tion1) .:] 1 ......,
,nétodos públicos, alé111 objVelnele • J:ev Vch1c lc () -
.!
dos da classe e,n que
estão baseadas.
objVch1clc . Coloc- • .. Rad~
ObjVch1c1c . r..o.xSpeed • 100 1
tnd Sub
• End :to d u le
f
4 nodu l e ~e:,ting
Sub floln ()
Di.m objVehfcle l.:I Veh1cle
01.m ob,cec- .u car
obJCar • Nev Cttr ()
Ob.)Car.

1
·di'-•--·
ldi' c.b
, . Ge<lypo
d/WWW
rf/ lJ..t:ôetOfPas~s
or;., • "
:i..:,.,cnqcc:t .. 6

!!" ••

- .. Rc:d"'
-

,,;;rflc...•_.-.
__ ·Of_l•_.,_ __,.ed • 100

~·=====;::;::;--------------'--
· - ~~_..,- ~ - ~·_j
- iG O.W !0 1
o.e l 'M

CôDIGO LISTAGEM 7.12 Usando as Palavras -Chave Overridabl e e Overrides


1 Public Class Vehicle
2
3 'Código removido para fins de simplificação ....
4
5 Public Overridable Function Description() As String
6 Return ''Essa é minha descrição genérica de veiculo!''
7 End Function
8 End Class
9
10 Public Class Car
11 Inherits Vehicle
12
13 'Código removido para fins de simplificação ....
14
15 Public Overrides Function Description() As String
16 Return "Essa é a descrição do meu carro"
17 End Function
18
19 End Class

Quando sobrepuser um método ou propriedade, con10 fizemos na Listage111 7 .12, você poderá se
referir nova1nente ao membro original da classe básica usando o objeto interno MyBase. Por
exemplo, para se referir ao método Descri pt i on ( ) existente na classe Vehi c1e, podería,nos cha-
mar MyBase. Descri pt i on ( ) de dentro do 1nétodo Descri pt i on ( ) de Car. Esse recurso pennite o
11 94 Dia 7

forneci1nento de uma funcionalidade adicional podendo-se empregar a sobreposição sem que


depois seja necessário reco,npor todo o código original.
Além de marcar o cód.igo como Overri dab 1e, também é possível marcar u1n método ou proprie-
dade co1no MustOverri de e uma classe co,no Mus t lnheri t . A palavra-chave Must Override indica
que toda filha dessa classe deve fornecer sua própria versão dessa propriedade ou método, e a pa-
lavra-chave Mustlnheri t significa que essa classe não pode ser usada sozinha (você deve basear
outras classes nela). E' importante observar que se u1na classe tiver um 1nétodo 1narcado co1n
MustOverride, então, ela própria deve ser 1narcada co1n Mustlnherit.
A herança é um tópico extenso e não o abordan1os con1pletan1ente, n1as co1n as informações for-
necidas nesta lição, você estará pronto para co1neçar a projetar alguns aplicativos que se beneti-
cie1n desse recurso dos objetos.

A Base de Todas as Classes Básicas


Se você exa1ninar a lista do que é exposto por essa nova instância da classe Ca r, verá 1nais do que
as propriedades de Vehi cl e e de Car. Os métodos ToStr i ng ( ) e GetType( ) são expostos por esse
objeto, mas não fazem parte dessa classe ou de sua classe-pai. Esses métodos são na verdade ou-
tro resultado da herança. Enquanto Ca r herda características de Vehi e1e, tanto Vehi e1e quanto
Ca r (e todas as outras classes da plataforma .NET) herdam características da classe básica
System. Obj ect . Essa classe básica definitiva fornece alguns 1nétodos que auton1aticrunente farão
parte de toda classe que criannos.
U1na conseqüência adicional da herança, que decerto vale a pena rnencionar, se percebe na área
dos tipos de dados. Como discuti,nos no Dia 3, toda variável se enquadra em algu1n tipo de dado,
e os objetos não são exceções. Quando declaramos u1na variável como do tipo Ca r, isso é tão res-
trito quanto a tipificação de dados co1no inteiros e strings. Se criannos o parâ1netro de uma fun-
ção cotn esse tipo, então, apenas esse tipo de objeto poderá ser passado para ela. Ern uma
situação de herança, a classe-filha atuaco1no se fosse urna instância da classe-pai. Isso significa,
em nosso exemplo, que pode1nos inserir nossos objetos Car e1n argumentos de procedi1nentos e
variáveis que sejam do tipo Vehicle. A Listagem 7.13 1nostra u1n exemplo.

CôDIGO LtSTAGEM7.13 Uma Cl asse-Fi l ha Agindo como uma I nstância da


Classe-Pai
1 Sub Main ()
2 Dim objVehi cle As Vehi cl e
3 Dim obj Car As Car
4 objCar = New Car()
5
6 objCar.NumberOfDoors = 4
7 objCar.NumberOfPassengers = 6
8
9 objVehicle = objCar
Traba lhando com Objetos

CôDIGO LISTAGEM 7.13 Uma Classe-Fi lha Agi ndo como uma Instância da
Cl ass e-Pai (continuação)
10
11 objVehicle.Color = "Red"
12 objVehicle.MaxSpeed = 100
13 End Sub

A instância de Car representada por objCar foi facilrnente i.nserida na variável obj Vehi c l e, e des-
se ponto em diante poderia ser tratada co1no u1n objeto Vehicle. Esse fato, de que um obje-
to-filho pode ser usado como se fosse tnna instância da classe-pai, pennite a criação de un1
código genérico que funcionará co1n u1na classe ou qualquer uma de suas subclasses. Essa é utna
das ,naneiras co1no a herança pode ser en1pregada para gerar soluções melhores, n1as há n1uitas
outras. Apresentei uma visão geral do assunto herança, e ele merece u,na discussão adicional
tanto do ponto de vista do projeto quanto da implernentação. Por essa razão, esse tópico e outras
abordagens relacionadas a objetos serão examinados com n1ais detalhes no restante do livro.

Construtores
Quando você deseja usar um objeto, tem de trabalhar com uma instância exjstente ou criar a sua.
A instância de um objeto é gerada co,n a palavra-chave New, que e1nprega a classe especificada e
estabelece uma área na rnemória para a instância dessa classe. Os construtores são uma maneira
de for11ecer infonnações para essa classe no momento etn que é gerada para permitir que ela
tnesma se inicialize ou execute outras tarefas de configuração nessa hora. Se uma classe for urn
construtor, e muitas classes do .NET Fran1ework são, então, em geral é possível fornecer parâ-
rnetros no 1no1nento da criação, como parie da charnada a New. O código a seguir tnostra esse tra-
balho na criação de u,n novo objeto de exceção (veja o Dia 6 para obter mais info1111ações sobre
as exceções e outros tópicos de tratatnento de erros), fornecendo utna tnensagem de erro como
parârnetro para seu construtor. Essa 1nensage1n de erro será usada de n1odo auto.mático pelo
novo objeto para preencher u1na das propriedades.
Dim exError As System. Exception
Dim sMess age As Stri ng
sMessage = "Essa será a mensagem de erro . "
exError = New System. Exception(sMessage)
A criação de um construtor para nossa classe Vehi el e é relativamente fácil. Pri n1eiro, você preci-
sa gerar u,n método chamado New que seja público e não tenha parâtnetros.
Publi c Sub New ()
End Sub
Após concluir a criação desse construtor (isso ainda não produz nenhum resultado), você verá
pouca diferença em seu código, e até que adicione,nos algurna funcionalidade a essa sub-rotina
New( ), nada diferente acontecerá. O construtor, mesrno sern parâmetros, pode ser usado como
1 196 Dia 7

um local para inicializar variáveis internas, como a data de produção de nossa classe Vehicle
(veja a Listage1n 7.14).

CÓDIGO LISTAGEM 7 .14 Usando um Construtor para Inicializar os Membros


de uma Classe
1 Public Sub New()
2 m dtManufactured - System.Date.Now()
3
4 End Sub

Exata1nente como co1n qualquer outro 1nétodo de u1n objeto, é possível sobrepor esse e fornecer
1nais de utna maneira de chatná-lo. Ao contrário dos outros métodos, n.o entanto, sobrepor o
construtor não requer o uso da palavra-chave Overl oads. Você pode apenas criar 1núltiplas ver-
sões do procedimento New, e cada u1na será tratada como urna versão disponível do construtor. E1n
nosso caso, podería1nos rapidamente gerar alguns construtores úteis (mostrados na Listagem 7.15)
considerando as diferentes maneiras nas quais algué1n pode querer inicializar nosso objeto.

CÓDIGO LISTAGEM 7 .15 Sobrepondo o Construtor de uma Classe para Forne-


cer Maneiras de Ini cializar Objetos
1 Public Sub New()
2 m dtManufactured = System.Date.Now()
3
4 End Sub
5
6 Public Sub New(ByVal sColor As String)
7 m dtManufactured = system.Date.Now
8 m sColor = sColor
9
-
10 End Sub
11
12 Public Sub New(ByVal dtManufactured As Date,
13 ByVal sCol or As String)
14 m dtManufactured = dtManufactured
15
-
m sColor = sColor
16
17 End Sub

No caso de uma classe-fi lha, aquela que herda características de outra classe, você pode querer
chamar o construtor da classe básica de seu procedimento New. Isso pode ser feito fac ihnente
con1 o uso do objeto especial MyBase, empregando um código como MyBase.New( ).
Trabalhando com Objetos

Espaços de Nome
O espaço de non1e é um conceito abstrato usado para agrupar vários ,nódulos ou classes, permi-
tindo que você categorize logican,ente todos esses objetos dentro de um único objeto de nível su-
perior. Pottanto, tendo Namespace Chapter7 no início de nossas classes e End Namespace no final,
cria1nos de 1nodo efetivo u1n agrupa1nento chamado Chapter7, que contén1 todas as nossas
classes dentro dele. Depois que esse espaço de nome existir, será usado con10 padrão para referên-
cias a objetos feitas em um código dentro do 1nesmo espaço de no1ne, mas tambén1 poderá ser
declarado explicita1nente (Dim objCar as Chapter7 . Car).
Há 1nuitas razões pelas quais você pode querer criar e usar espaços de nome, e não são poucas
delas a base do 'espaço de nome' identificador, co1no un1a 1naneira de gerar uma área privada
para assegurar que os no1nes de sua classe sejam exclusivos. Pela defi11ição de um espaço de
no1ne, nossa classe Car se torna Chapter7. Car, e, po1tanto, não entrará mais e1n confl ito co1n ne-
nhuma outra classe criada co1n o no1ne Ca r.
Outra razão mais sutil para usar os espaços de nome é porque produze1n u1n código em que a ma-
nutenção é mais fácil. O agrupa1nento de classes sob espaços de norne de nível superior resulta
em urn código que é definido claramente por algutn esquerna de categorização sendo, po1tanto,
1nais legível e sua 1nanutenção mais si1nples.
Etn nossos exen1plos no decorrer deste livro, podería1nos ter criado espaços de no1ne co1n base
no título da lição (por exe1nplo, o código integral desta lição seria inserido sob o espaço de nome
Dia7), podendo todos eles, en1 seguida, ser posicionados sob um espaço de nome 1nais abrangen-
te com relação ao livro chamado AprendaVB. Nossas classes poderiam ser criadas apenas coino
Di a7, n1as para assegurar que não houvesse ambigüidades, tambétn podería1nos nos referir a elas
com seu no1ne totahnente qualificado (AprendaVB. Dia7 .Car, por exemplo).
Esse método de agrupar classes é se1nelhante ao conceito de escopo que foi discutido no Dia 3;
urna classe só tem de ser exclusiva dentro de seu espaço de nome específico. Se por acaso você
criar u1na classe que compartilhe seu nome cotn outra que exista em um espaço de nome diferen-
te, então, precisará se certificar de especificar o no1ne completo da classe sempre que fizer refe-
rência a ela de fora de seu espaço de non1e.
Os espaços de nome são hierárquicos, o que pennite que você crie tun esque1na com vários níveis
para agrupar suas classes e objetos, exatamente como dentro do próprio .NET Fratnework. Há duas
maneiras de criar um espaço de nome de nível inferior. Defma-o usando o no1ne totaln1ente qualifi-
cado (veja a Listagen1 7. 16) ou anitlhe as definições dos espaços de nome (veja a Listagem 7.17).

CÓDIGO LISTAGEM 7.16 Declarando um Espaço de Nome com Várias Partes


1 Imports System
2 Namespace MyApp.Console
3 Module Main
4 Sub Main()
198 Dia 7

CôDIGO LISTAGEM 7.16 Declarando um Espaço de Nome com Várias Partes

5 Dim objHW As New MyApp.Console.Utilities()


6 objHW.PrintOut()
7 End Sub
8 End Module
9
10 Public Class Utilities
11 'Run the application
12 Public Sub PrintOut()
13 Console.Writeline(Environment.MachineName)
14 Censo l e. l~ri tel i ne (Envi ronment . Sys temDi rectory)
15 Console.Writeline(Environment.GetlogicalDrives())
16 Console.Writeline(Environment.Version. ToString())
17 End Sub
18 End Class
19 End Namespace

CôDIGO LISTAGEM 7.17 Usando Espaços de Nome Aninhados para Criar Hie-
rarquias de Objetos
1 Imports System
2 Namespace MyApp
3 Namespace Console
4 Module Main
5 Sub Main()
6 Dim objHl•I As New MyApp.Console . Uti l ities()
7 obj HI~. Pri ntOut ()
8 End Sub
9 End Module
10
11 Public Class Utilities
12 'Run the application
13 Public Sub PrintOut()
14 Console.Writeline(Environment.MachineName)
15 Censo l e. ~/ri tel i ne (Envi ronment. SystemDi rectory)
16 Console.Writeline(Environment.GetlogicalDrives())
17 Console.WriteLine(Environment.Version.ToString())
18 End Sub
19 End Class
20 End Namespace
21 End Namespace
Trabalhando com Objetos

E1n seus aplicativos, você pode usar os espaços de nome como uma 1naneira de agrupar códigos
conceituahnente relacionados, mas alé,n de seu efeito no escopo das classes, eles não são real-
1nente necessários na construção de u1n sisten1a.

Membros e Objetos Compartilhados


No co,neço desta lição, quando descrevemos o relaciona1nento entre as classes e os objetos, você
aprendeu que para usar qualquer propriedade ou método especificado e,n uma classe teria de
empregar ou criar un1a instância dessa classe. Em geral, é isso que acontece; não é possível tra-
balhar diretamente co1n uma classe, apenas co1n as instâncias dela que foren1 criadas. Há uma
rnaneira de expor u1na certa funcionalidade por meio da própria classe, no entanto, independen-
te,nente de qualquer instância particular dela, com o uso da palavra-chave Shared. Essa pala-
vra-chave, corno os outros descritores que foram vistos (co,no Pub li e, Priva te e Fri end),
significa que parte de uma classe está disponível sem a criação de uma instância. O .NET Fra1ne-
"vork usa esse recurso e,n suas classes, corno a propriedade exposta Today da classe System. Da-
te Time (cujo exemplo é mostrado na Listage1n 7.18).

CÓDIGO LISTAGEM 7.18 Funções Internas do Visual Basic 6.0 Foram Substituí-
das pelos Métodos Compartilhados no Visual Basic .NET
1 Imports System
2 Module Main
3 Sub Main()
4 Dim dtToday As Date
5 dtToday = DateTime.Today()
6 End Sub
7 End Module

Esses ,nembros co,npartilhados pode1n ser criados em seu próprio código quando você quiser
que u1n método ou propriedade em particular esteja sempre acessível, se1n a sobrecarga de gerar
u1n objeto. Em geral, no entanto, evite usar esse recurso a menos que seja reahnente necessário
porque ter 1nuitos mernbros co1npartilhados é quase o 1nesmo que apenas criar um 1nódulo cheio
de procedi1nentos e reduz o significado de seus objetos. Le1nbre-se de que Modul es é u1n tipo es-
pecial de Class, todos os men1bros de 1un módulo são considerados co1npartilhados (Shared) por
padrão.

Resumo
O .NET Framev,iork é un1a biblioteca de classes que você pode usar en1 seus aplicativos, todas
elas construídas a partir dos princípios básicos da prograrnação orientada a objetos, comuns às
linguagens .NET. Esses princípios (o conceito de classes, instâncias, propriedades, n1étodos, he-
rança e assi1n por diante) ta1nbé1n serão a base da criação das classes de sua autoria dentro do Vi-
1200 Dia 7

suai Basic .NET. Para desenvolver qualquer aplicativo que vá além do exen1plo n1ais simples,
será necessário empregar o .NET Frame\.vork e, co1n freqüência, ta1nbé1n será preciso gerar suas
próprias classes, tornando a utilização de objetos unia habilidade essencial para todos os progra-
madores da platafonna .NET. Nesta Iição abordamos, por 1neio da criação de nossas classes como
exe1nplo, conceitos básicos orientados a objetos e mostra1nos como implen1entá-los em u1n código
de sua autoria. Na próxima lição, Dia 8, introduziremos as classes disponíveis no .NET Frame-
\.vork e ilustraremos corno e1n pregá-Jas para desenvolver poderosos aplicativos .NET.

P&R
P Nunca trabalhei com uma linguagem orientada a objetos antes; posso ficar apenas
nos procedimentos e módulos?
R Você não precisa criar objetos no Visual Basic .NET, mas achará difícil usar essa lingua-
gem se1n e1npregar pelo menos alguns deles, con10 o .NET Framework. Por essa razão, o
enfoque inicial para u1n desenvolvedor que não conheça objetos é se fan1iliarizar com
sua utilização antes de passar para sua criação.
P Li que, no Visual Basic .NET, não é possível dizer exatamente quando um objeto
será eliminado e que esse é um fator limitante por várias razões. O que significam
esses comentários, e eles são verdadeiros?
R Quando se trabal_ha co1n objetos, sua elin1inação nem sempre ocorre e.,n u1n ponto defini-
do do código, portanto, será difíci l fazer co1n que u1n certo n·echo desse s~ja executado
sempre que u1n objeto for destruído. Em algu1nas linguagens, incluindo as versões ante-
riores do Visual Basic, havia um 1necanis1no disponível para adicionar u1n código ao
procedi,nento de um 'evento de eliminação' . O código inserido em um procedi1nento
desse tipo teria sua execução garantida sempre que o objeto fosse e!i,n inado. No Visual
Basic .NET, o subsistema de coleta de lixo eliminará os objetos quando necessário, mas
não é possível criar um código que seja processado na hora da destruição. Em geral, essa
' limitação' não causa 1nuitos proble,nas, mas às vezes (principahnente quando se trans-
fere um código antigo do Visual Basic) há a expectativa da execução de u1n código no fi-
nal do ciclo de vida do objeto, e isso não é facihnente transferido para uma
i1uplementação do Visual Basic .NET.

Workshop
O Workshop foi planejado para aj udá-lo a antecipar possíveis dúvidas, revisar o que já aprendeu
e começar a pensar eiu co1no colocar seu conhecimento em prática. As respostas do teste estão
no Apêndice A, "Respostas dos Testes/Exercícios".
Trabalhando com Objetos 201

Teste
1. Se urna classe tiver um método n1arcado corn MustOverri de, o que mais acontecerá?
2. Qual a palavra-chave que você pode usar em um construtor para cha1nar o de u1na classe
básica?
3. O que está errado nos construtores sobrepostos desse código (veja a Listage1n 7.19)?

CÓDIGO LISTAGEM 7.19 Versões Diferentes de Construtores Disponíveis para


a Classe Vehicle
1 Public Class Vehicle
2 Dim m dtManufactured As Date
3
-
Dim m_lngNumberOfPassengers As Long
4 Dim m_sColor As String
5
6 Public Sub New()
7 m dtManufactured = System.DateTime.Now()
8 End Sub
9
10 Public Sub New(ByVal sColor As String)
11 m- dtManufactured = System.DateTime.Now()
12 m sColor =sColor
13
-
End Sub
14
15 Public Sub New(ByVal sName As String)
16 End Sub
17
18 Public Sub New(ByVal dtManufactured As Date,
19 ByVal sColor As String)
20 m dtManufactured = dtManufactured
21
-
m sColor = sColor
22 End Sub
23
24 End Class

Exercícios
Por 1neio da herança, das classes, das propriedades e dos métodos, crie u1n exemplo de hierar-
quia de classes co,neçando e,n Ani1nal e descendo alguns níveis co1n algurnas classes ilustrativas.
202 Dia 7

SEMANA 1

Revisão
Agora que você tem1inou sua trajetória pela prin1eira se1nana de lições, já deve ter uma boa com-
preensão da progra1nação, do Visual Basic .NET e de co1no tudo se encaixa. (Dias 1 e 2). Ta1nbé1n
criou alguns exe1nplos de progra,uas na plataforrna .N.ET, usando tanto o lDE quanto a Jinha de co-
mando para compilá-los. Com essa experiência, já pode testar todos os exernplos deste livro e até
.
cnar os seus.
A lição sobre os tipos de dados e as técnicas básicas de programação usadas na criação de aplica-
tivos do Visual Basic .NET (Dia 3) forneceu-lhe urna boa introdução à programação sirnples. O
Dia 4 apresentou as instruções condicionais (inclusive as instruções r f) e laços, dois itens que
serão ernpregados e1n quase todos os progra1nas que vier a escrever. Pelo fato de o Visual Basic
.NET permitir a geração de tantos tipos diferentes de progra1nas, por rneio de uma grande varie-
dade de projetos e diversos arquivos-fonte, o Dia4 abordou as opções de arquitetura para desen-
volver todas as espécies distintas de sisternas que a platafortna .NET pode ser usada para criar.
Independentemente da sua habilidade em programação, erros sempre ocorrem em progran1as.
Não irnportando se eles poderia1n ser evitados, as técnicas de tratamento de erros abordadas no
Dia 6 permitem que você lide com o problema de maneira sofisticada. Para concluir,já que gran-
de parte do .NET Frrunework é baseadaen1 objetos, o enfoque da lição do Dia 7 foi sobre os ter-
mos e conceitos necessários para possibilitar o uso de objetos em seus próprios programas.
Todas essas informações, be1n como a prática da codificação que as aco1npanhou, devem tê-lo
preparado para encarar o pri1neiro projeto corno bonificação (The Ga,ne of Life - O Jogo da
Vida). Esse projeto, que você pode encontrar acessando a página Web deste livro no site
www.makron.com.br (veja a Introdução para maiores detalhes), alé1n de conduzi-lo na criação de
urn prograrna real completo, ilustra o uso de i.nstruções condicionais, arrays, laços, variáveis e até
técnicas de tratamento de erros mostradas no decorrer das lições que acaban1os de concluir. Leia o
material, desenvolva o projeto e faça testes co1n os resultados durante algurn ternpo. Quando esti-
ver pronto para seguir em frente, tente modificar o código para alterar co1no o progra1na funciona,
criando a sua própria variação dele.
SEMANA 2

Visão Geral
Durante esta se1nana, você se aprofundará realmente no esti1nulante mundo do
.N-ET Fra1nework. Ela co1neça co1n u1na lição no próprio Frame\.vork (Dia 8),
incluindo detalhes sobre o uso das classes Conso 1e. Ma th. Random e Envi ronment,
e infonnações sobre toda a excelente funcionalidade das listas e arrays forneci-
da pelo Fra1ne\.vork. Além de todas essas particularidades, essa lição ta1nbé1n
inclui u1na introdução a co1no encontrar o recurso necessário no .NET Fra,ne-
work por sua própria conta - infonnações valiosas quando você iniciar projetos
de sua autoria usando a platafonna .NET.
As próximas duas lições, Dias 9 e IO, enfoca1n a criação de uma interface co1n o
usuário en1 seus aplicativos, para Windows (usando os fonnulários Windovvs,
Dia 9) ou para a Web (usando a tecnologia dos forn1ulários da Web, aborda.da
no Dia l O). Poucos progrrunas são executados sem alguma interface con1 o
usuário, o que torna essas duas lições absoluta1nente essenciais.
Quase todo aplicativo ernpresarial existente usa algum tipo de banco de dados,
po1ianto, você passará duas lições exam inando esse tópico. O Dia 11 aborda os
conceitos subjacentes aos bancos de dados e o conduz pela criação de u111 deles
para u111 aplicativo de registro de CDs. O Dia J2 dá prosseguimento à Iição so-
bre dados 1nostrando con10 se conectar ao banco de dados de seu exemplo e de-
senvolver um aplicativo que permita adicionar, editar e excluir CDs de sua
coleção.
O trabalho co1n os bancos de dados introduzirá você no Server Explorer, ,nas o
Dia 13 mostrará corno usar seus vários recursos. Nessa lição, trabalhare1nos
co1n contadores de desempenho e registros de eventos, e aprenderemos u1na
rnaneira rnais fácil de configurar u1na conexão de banco de dados.
1 204 Semana 2

Para concluir, no Dia 14, você aprenderá alguns dos ,nais avançados recursos orientados a
objetos do Visual Basic .NET, incluindo a herança e a sobreposição. Essa lição realn,ente torna-
rá mais claro o poder dessa versão do Visual Basice mostrará como é possível usar esses recur-
sos para projetar sistemas que seja,n mais fáceis de estender e tenha,n uma 1nanutenção mais
si,nples.
No final da Se1nana 2, você terá aprendido tantos recursos do Visual basic .NET que estará pron-
to para criar aplicativos complexos. O projeto de bonificação número 2 (Parte 1 do Projeto de
Bônus 2) fornecerá a prática por 1neio de algu1nas dessas técnicas novas.
Semana 2


DIA e

Introdução ao .NET Framework


O .NET Fra1ne,.,vork não é especifica1nente um novo recurso do Visual Basic .NET porque ele é
co1npartilhado com muitas linguagens (mais de 20 no 1no1nento em que esse texto foi escrito). O
Fran,ework fornece um poderoso conjunto de co1nponentes para você usar e1n seus programas.
Ele conté1n uma quantidade i1nensa de classes que executa1n várias funções, da manipulação de
strings ou nú1neros à criptografia e o acesso à rede. Assimilar o .NET Fra1ne,vork é u1n processo
contínuo, mas conhecer os tennos-chave e a 1naneira co1no o Framev. ork é organizado são co-
1

nheci1nentos valiosos que o aj udarão no desenvolvi,nento de mais aplicativos corno Visual Ba-
sic .NET.
Hoje, você aprenderá:
• O que é o .NET Framework.
• Algu1nas classes importantes do .NET Framework.
• Co1n o encontrar o que precisa no .NET Fra,nework.

O Que É o .NET Framework?


O teimo .NET Framework foi o no1ne dado a vários co1nponentes e serviços que foram co1nbina-
dos para criar lttn ambiente poderoso de desenvolvi1nento. Ele inclui u1na grande quantidade de
classes (1nais de 6 mil) que fornecem grande parte da funcionalidade anterionnente existente no
Visual Basic ou na API do Windows. Isso pennitirá que você escreva aplicativos com base no
Windows e na Web, acesse a rede, crie elementos gráficos e muito mais.
1 206 Dia 8

Alé1n disso, o .NET Frame~ ork possui o Common Language Runtime (CLR), que é responsável
1

por executar seu código. O CLR oferece várias inovações i1nportantes que afetam os desenvol-
vedores de aplicativos .NET no Visual Basic .NET ou e1n outras linguagens que tenham suporte.
A principal alteração é que agora todas essas linguagens são compiladas para a Microsoft lter-
mediate Language (MSIL). E1n seguida, ela é conve1tida pelo CLR e1n código nativo quando é
executada pela primeira vez. O resultado final é que você se beneficiará do desempenho de um
código totalmente compilado, e não de um que seja interpretado no ten1po de execução.
Ainda há 1nais, todas as linguagens que têm suporte do CLR usam o 1nes1no tipo de dados. Isso
significa que é 1nuito ruais fáci l para duas (ou 1nais) linguagens interoperare1n. Anteriormente,
se você precisasse passar inforn1ações de uma linguagem (co,no a C++) para outra (diga,nos o
Visual Basic), poderia ter de executar algumas conversões para interpretar de modo apropriado a
variável. Agora, já que as duas linguagens emprega rã.o o mes,no tipo de dados, isso é simples. O
CLR pennite que os desenvolvedores utilize1n a linguage1n co1n a qual se sentem 1nais confo1tá-
veis, podendo ainda se co1nunicarem com outras.
Embora o CLR seja importante, ele em geral funciona e1n segundo plano. A parte essencial e vi-
sível do .NET Framework que você deve exa1ninar são algumas das classes que o compõern.

Classes Importantes do .NET Framework


Você usará muitas classes do .NET Frame\.vork quando desenvolver aplicativos no Visual Basic
.N.ET. No entanto, empregará aiguinas delas con1 1nais freqüência do que outras. Entre as classes
n1ais úteis estão
• Consol e Pennite a leitura e a exibição na linha de comando.
• Envi ronment Pennite a leitura e a gravação nas variáveis de a1nbiente do sistema.
• Random Permite a geração de números aleatórios.
• Math Inclui vários cálculos matemáticos.
• Co 11 ect i ons Fornece várias classes para diferentes estratégias de annazenamento de
conjuntos de itens.

Console
Você já viu algumas das classes Console quando desenvolveu aplicativos anteriormente. Os mé-
todos \~ri tel i ne e Readl i ne dessa classe têm sido usados com frequência para exibir resultados
e ler códigos de vários dos aplicativos do console, ou de linha de comandos, criados no livro até
agora. Essa é a utilização mais irnportante da classe Console. No entanto, há alguns recursos me-
nos en1pregados dela que vale a pena exarninar. Alguns dos métodos essenciais desta classe são
mostrados na Tabela 8. 1.
Introdução ao .NET Framework

T ABELA 8.1 Métodos da Classe Console

Método Descrição
Lê informações da linha de comandos (ou outro código). Não precisa que
Read a linha termine com Enter.
Lê informações da linha de comandos. Lê todos os caracteres até o Enter,
Readline sem incluí-lo.
Altera o destino das mensagens de erro a serem exibidas enquanto seu
SetError programa estiver em execução. Pode ser usado na criação de um meca-
nismo simples de registro de erros em seu aplicativo.
Altera a origem da entrada de Read e Readl i ne. Pode ser usado na altera-
Setln ção de um aplicativo de linha de comandos para que leia um arquivo ou
local de rede. Veja a seção "Redirecionamento", mais à frente nesta li-
ção.
Altera o destino dos métodos Wri te e Wri tel i ne. Pode ser usado na alte-
SetOut ração do destino da saída para registro ou outra finalidade. Veja a seção
"Redirecionamento", mais adiante nesta lição.
Write Exibe informações na linha de comandos (ou outra saída). Não termina
com uma nova linha.
l~ri tel i ne Exibe informações na linha de comandos (ou outra saída). Termina a saí-
da com uma linha nova.

Resultados Mais Simples


Já que a classe Console co1n freqüência é usada para saídas, seria bom se tornasse sua vida mais
fácil quando você executasse essa tarefa. Feliz1nente, ela faz isso. Quando e1nprega1nos os n1éto-
dos Wri te ou Wri teL i ne para exibir informações, nos beneficiamos de sua capacidade de utilizar
espaços reservados para as variáveis. E1n geral, quando se quer exibir u,na string que contém in-
fonnações annazenadas em variáveis, luna técnica conhecida como concatenação é usada.

Novo TERMO Concatenação é ,uai.s uma palavra sofisticada que quer dizer ' combi11ação de
'

strings' . E1n vez de somar as strings co.m o símbolo+, como faze1nos co.111 os nún1e-
ros, é usado o símbolo &, como en1
Console.Writeline("Insira" & ITEM_COUNT &

''itens. Pressione ENTER entre os itens.'')

Se você tiver uma string co1nplicada, pode ser difícil lidar co1n todas as aspas e E comerciais. Em
vez de construir uma string co1nplexa usando a concatenação, é possível utilizar esses espaços
reservados nos locais certos e incluir posterionnente as variáveis que serão empregadas em seu
preenchimento, como descrito a seguir:
Console.Writeline(''Insira {O} itens. Pressione ENTER entre os itens. '',
ITEM_COUNT)
O item {O} é um espaço reservado para a variável que você incluiu no final da string. Ela é ava-
riável ITEM COUNT das instruções anteriores. É possível inserir vários espaços reservados (ou até
1 208 Dia 8

mes1no usar o mesmo diversas vezes) na string. Assim, as variáveis que forem incluídas depois
da string serão inseridas nela e1n orde1n, começando co1n o item "Oº" (primeiro ite1n) e dando
continuidade, percorrendo as variáveis e espaços reservados em seqüência ({O}, { 1}, {2} e as-
si1n por diante). A Listage1n 8.1 de1nonstra esse recurso.
1

CÓDIGO LISTAGEM 8.1 Usando a Classe Conso 1e para Entradas e Resu 1ta dos
1 Imports System
2 Public Class ConsoleTest
3 Private Const ITEM COUNT As Integer = 10
4 Shared Sub Main()
5 Dim I As Integer
6 Dim sitems(ITEM COUNT) As String
7 Console.Writeline( 1'Insira {O)itens.'' &_
8 Pressione ENTER entre os itens.",ITEM_COUNT)
9 For I = O To ITEM COUNT-1
10 sltems(I)= Console.Readline
11 Next
12 Console.Writeline()
13 Console.Writeline(''Itens em ordem inversa:'')
14 For I = ITEM_COUNT - 1 To O Step -1
15 Console.Writeline(sltems(I))
16 Next
17 End Sub
18 End Class

ANÁLISE O código da Listagem 8.1 é be1n simples e pretende den1onstrar apenas algumas das
'
maneiras co1no você tem usado a classe Conso 1e nessas sete lições.
,
A linha 1 Ílnporta o espaço de no,ne System. E nesse local que a classe Conso 1e é definida, assin1
cotno 1nuitas outras classes i1nportantes. Portanto, você deve se1npre iinportar esse espaço de
no1ne na 1naioria dos aplicativos. O lDE do Visual Basic .NET fará isso auto1naticamente para
aplicativos que forem criados quando ele estiver e1n uso.
Dentro da única classe definida e1n seu arquivo, você declara apenas uma constante, ITEM_COUNT
(linha 3), e uma sub-rotina Mai n (linha 4). A constante é usada para substituir a inserção do nú-
rnero 10 e1n todo o código, prevendo o caso de se querer alterar o valor posteriormente. É muito
mais fácil alterar só o valor da constante, e1n vez de ter de procurar todas as ocorrências desse va-
lor no aplicativo inteiro. O uso de u1na constante ta1nbé1n mostra que o desenvolvedor sabe que
os valores estão relacionados. Se tivéssemos repetido o nú1nero 10 etn todos os locais e exami-
násse,nos esse código seis meses depois, podería1nos não le,nbrar se todos indicaria,n o mes1no
valor ou se seria somente uma coincidência.
Introdução ao .NET Framework

O procedimento Shared Sub Ma i n é, cotno você já viu 1nuitas vezes, o pritneiro método executa-
do e,n u.tn aplicativo. Dentro do procedimento, você declara u1n array de strings (linha 6) e o pre-
enche co,n o método Console. Readl i ne.
A linha 7 é digna de nota. Dentro do item exibido con1 Conso 1e. Wri teli ne (ou Conso 1e. Wri te),
você pode inserir vários caracteres, como o item {O} no n1eio da string da linha 7. Posteriormen-
te, cada u1nadessas linhas será preenchida com variáveis. Essas são incluídas depois da string na
cha1nada de Conso 1e. Wri tel i ne, co1no fizemos co1n a constante ITEM_COUNT.

Usar a abordagem de caracteres na construção de uma string pode ser útil,


NOTA mas, se fará ou não sentido dependerá um pouco de critérios pessoais. Nessa
técnica, cada valor substituirá um caractere na ordem que eles aparecerem,
começando com Oque é o primeiro. As variáveis podem ser numéricas, alfa-
numéricas ou qualquer outro tipo que possa ser convertido em uma string. Por
exemplo, se você quisesse usar essa técnica para escrever uma string com
quatro variáveis incluídas, ela teria a seguinte aparência:

Console . Writeli ne("{O}+{l} = {2} : {3}", 1, 1, 2,


"Bertrand Russel 1, 1912")
Os desenvolvedores experientes do Visual Basic podem estar um pouco mais
familiarizados com uma abordagem alternativa. Nela você constrói a string
concatenando strings e variáveis. A string anterior poderia ser construída e
exibida com o código:
Console . Writeline(valuel & "+" & value2 & "=" & result & ": " &
sSource)
Embora isso possa parecer mais 'natural', você pode esquecer de incluir um
caractere de concatenação("&") quando adicionar as strings. Seu programa fa-
lharia na compilação ou na execução.

Cada linha da entrada é lida(linha I O) e exibida e,n utn dos elementos do array. Observe que es-
ses ele1nentos são numerados de O a 9 (linha 9).
Para concluir, os ele1nentos são exibidos na tela en1 orde1n inversa. Isso é feito co,n o uso da
cláusula Step da instrução For ... Next (linha 14). Eles são exibidos utn por vez na saída atual,
co1no ven1os na linha 15. A Listagem 8.2 demonstra esse tipo de saída.

CôDIGO/ LISTAGEM 8.2 Executando o Aplicativo do Console


RESULTADO

1 [c:\code] Consol el. exe


2 Insira 10 itens . Pressi one ENTER entre os itens.
3 Porco-da-terra
4 Rat o gigante da Índi a
5 Casuar
6 Dugão
7 Équidna
8 Tentilhão
1 210 Dia8

CôDIGO/ LISTAGEM 8.2 Executando o Aplicativo do Console (cont ínuação)


. RESULTADO

9 Girafa
10 Hipopótamo
11 Iguana
12 Chacal

13 Itens em ordem inversa:


14 Chacal
15 Iguana
16 Hipopótamo
17 Girafa
18 Tentilhão
19 Équidna
20 Dugão
21 Casuar
22 Rato gigante da Índia
23 Porco-da-terra

Redirecionamento
Redirecionamento significa apenas'enviar algo para um local diferente' . Quando lida1nos com a
classe Console, isso quer dizer que você pode alterar o local onde fará a leitura ou exibição. Por
exemplo, ela poderia ser usada para exibir o resultado de u1n aplicativo que recebesse entradas
de linhas de comandos ou de un1 arquivo. De 1naneira se1nelhante, você poderia e1npregar Con-
sole. Wri tel i ne quando depurasse o aplicativo em testes e, em seguida, o redirecionasse a urn
arquivo a fi1n de criar u1na ferramenta simples de registro para ele.
Você pode redirecionar a entrada, o resultado ou as informações de erro de seu programa. Essas
infonnações pode1n ser redirecionadas para qualquer destino onde houver TextReader (para en-
tradas) ou Textl~riter (para saídas e erros). Observe que não é possível criar nenl1uma dessas
duas classes diretarnente, já que são abstratas. E1n vez disso, é preciso gerar urna das classes que
imple1nentará ou herdará características de TextReader ou TextWri ter (veja o Dia 7, "Traba-
lhando co1n Objetos" e o Dia 14, "Introdução à Prograrnação Orientada a Objetos", para obter
mais detalhes sobre a abstração e a herança). Algumas das imple1nentações dessas duas classes
permite1n ler e gravar em arquivos, locais na rede e assi1n por diante. A Listagem 8.3 mostra
co1n.o se pode alterar o exemplo mostrado na Listagern 8.2 para que envie o resultado para um ar-
quivo em vez de para a janela das linhas de co1nando. Observe que os co1nandos de Conso-
1e. Wri tel i ne não fora1n alterados; somente o destino foi.

CôDIGO LISTAGEM 8.3 Redirecionando a Saída do Console


1 Imports System
2 Imports System. IO
Introdução ao .NET Framework 211

CÓDIGO LISTAGEM 8.3 Redirecionando a Saída do Console (continuação)


3 Public Class ConsoleTest
4 Private Const ITEM COUNT As Integer = 10

5 Shared Sub Main()


6 Dim I As Integer
7 Dim sltems(ITEM_COUNT)As String
8 Dim oFile As TextWriter = File.CreateText(''Output.txt'')
9 Dim oOut As TextWriter = Console .Out

10 Console.Writeline(''Insira {O) itens. Pressione ENTER entre os


• itens .",_ ITEM_COUNT)
11 For I = O To ITEM COUNT-1
12 sltems(l) = Console.Readline
13 Next

14 Console.Writeline()
15 Console.SetOut(oFile)
16 Console.Writeline("ltens em ordem inversa:")
17 For I = ITEM_COUNT - 1 To O Step -1
18 Console.Writeline(sltems(I))
19 Next

20 oFile.Close()

21 Console.SetOut(oOut)
22 Console.Writeline(''Concluído'')
23 Console.Readline()

24 End Sub
25 End Class

Executando o aplicativo:
1 [c:\code]Console2.exe
2 Insira 10 itens. Pressione ENTER entre os itens.
3 Porco-da-terra
4 Rato gigante da Índia
5 Casuar
6 Dugão
7 Équidna
8 Tentilhão
9 Girafa
10 Hipopótamo
11 Iguana
12 Chacal
1 212 Dia 8

13
14 Concluído

ANALISE A única alteração entre as Listage1n 8.1 e 8.2 foi o acréscimo das linhas 2, 8, 9, 15,
20, 21 e 22. Essas são as linhas que crian1 o arquivo, e provoca1n e encerram o redire-
ciona1nento da saída. A linha 2 importa o espaço de no1ne System. IO. Ele será necessário já que
contém a definição para as classes TextWri ter e Fi 1e que você usará depois. A linha 8 gera o ar-
quivo Output. txt en1pregando o método CreateText da classe Fi 1e. Observe que na verdade não
é preciso criar uma instância da classe Fi 1e, já que o n1étodo CreateText é co,npartilhado. Se já
houver um arquivo conJ esse nom.e, ele será excluído. Se em vez disso quisern1os continuar apre-
encher u1n arquivo existente, deve1nos utilizar AppendText no lugar de CreateText. A linha 9 é
usada para salvar o destino original da saída, portanto ele poderá ser configurado mais uma vez na
linha 21. A linha 15 provoca o redirecionamento para seu arquivo. Todas as saídas que empre-
gue1n Conso 1e .l~ri te e Conso 1e. Wri tel i ne após esse redireciona1nento serão enviadas para seu
arquivo e1n vez de para a janela das linhas de comandos. A últirna linha irnportante é a 20. Se não
conseguirmos fechar o arquivo, o conteúdo não poderá ser gravado e tern1inaren1os com um ar-
quivo sern bytes (vazio).

O código da Listagem 8.3 deve produzir um arquivo Output . txt co,n o conteúdo a seguir:

.
1
RESULTADO 1 Itens em ordem 1nversa:
2 Chacal
3 Iguana
4 Hipopótamo
5 Girafa
6 Tentilhão
7 Équidna
8 Ougão
9 Casuar
10 Rato gigante da Índia
11 Porco-da-terra

Envi ronment (Ambiente)


Saber seu lugar em geral produz a diferença entre sucesso e constrangilnento. E essa percepção
ve1n freqüentemente da vizinhança, ou do ambiente. De maneira se,nelhante, e1n programação,
você é envolvido por u1n an1biente específico. O a,nbiente e1n que seus progra1nas são executa-
dos é co1nposto de infonnações sobre o siste,na operacional, assim como 1nuitas variáveis e ou-
tras configurações que afetam seu computador. .Esse ambiente pennite que você consulte
configurações para o usuário, como o local do diretório de seus arquivos temporários, o conteú-
do de seu ca1ninho de pesquisa ou até outros itens sobre a linha de comandos. Algumas das pro-
priedades e 1nétodos mais i1nportantes da classe Envi ronment são listados na Tabela 8.2. Observe
que todas essas propriedades e 1nétodos são co1npartilhados.
Introdução ao .NET Framework

T ABELA 8.2 Métodos e Propriedades da classe Environment

Membro Descrição
Propriedades
Commandline Representa a linha de comandos completa que iniciou o aplicati-
vo.
CurrentDirectory Retorna o caminho do diretório atual.
OSVersion Retorna informações sobre o sistema operacional atual, por exem-
plo, se é o Windows 9x, o NT ou o 2000.
SystemDirectory Retorna o caminho do diretório do sistema (\winnt\system32 no
Windows NT ou no 2000).
Version Retorna informações sobre a versão de uma montagem.

Métodos
Exit Encerra um aplicativo, opcionalmente retornando um código de
erro que pode ser usado pelo sistema operacional.
GetCommandlineArgs Retorna todos os itens listados na linha de comandos quando o
aplicativo foi iniciado. Esse retorno é feito na forma de um array de
strings. O próprio executável é o elemento zero (primeiro) do ar-
ray.
GetEnvironmentVariable Retorna o valor de uma variável de ambiente solicitada. Traz infor-
mações armazenadas no ambiente com o comando Set, como o
caminho de pesquisa (path), o diretório para arquivos temporários
(temp) ou outras configurações.
GetlogicalDrives Retorna a lista de unidades disponíveis. Esse retorno é feito na for-
ma de um array de strings. O primeiro (item O) elemento geral-
mente é A:\ .

A classe Env i ronment é útil quando você precisa de informações sobre o siste1na que está ao re-
dor da execução de seu progra1na, co1no quando tem de saber onde gravar seus arquivos tempo-
rários ou e1n que siste1na operacional está sendo executado.

Random
Random é u1na classe si,nples, destinada a criar nú1neros aleatórios, e,n geral u111 inteiro (Integer)
ou u,n duplo (Doub 1e). Os ,nétodos importantes dessa classe estão listados na Tabela 8.3.

T ABELA 8.3 M étodos da Classe Random

Método Descrição
Next Retorna um inteiro entre Oe o valor máximo possível para um inteiro
(aproximadamente 2 bilhões).
Next(MaxValue) Retorna um interiro entre Oe o valor de MaxVa 1ue (algum inteiro).
1 214 Dia8

TABELA 8.3 Métodos da Classe Random (continuação)

Método Descrição
Next(MinValue, Retorna um inteiro entre os valores mínimo e máximo. Essa é a varia-
MaxValue) ção mais usada quando se precisa de 1 como valor mínimo.
NextDouble Retorna um tipo duplo entre O e 1.

Por exeinplo, se você quisesse gerar utn inteiro aleatório entre l e 100 (inclusive), escreveria
Dim oRand As New Random
Dim iValue As Integer = oRand.Next(l,100)

Math
A classe Math contém n1uitas das constantes e funções 1nate1náticas irnportantes. A maioria delas
são métodos compartilhados e, portanto, poden1 ser usados sem a criação de u1na instância da
classe Math. Os métodos rnais relevantes são descritos na Tabela 8.4. Se você exa1ninar a classe
Math na ajuda (Help), verá que há muitos outros .tn.étodos disponíveis.

TABELA 8.4 Métodos da Classe Math


Método Descrição
Retorna o valor absoluto de um número (se for negativo, ele retornará o valor
Abs positivo do número).
Cós Retorna o cosseno de um ângulo (medido em radianos; veja a Nota a seguir).
E Retorna um tipo duplo representando o valor de e (2.7182818284590451).
Max Retorna o valor máximo entre dois valores.
Min Retorna o valor mínimo entre dois valores.
PI Retorna um tipo duplo representando o valor de pi (3.1415926535897931).
Round Arredonda um número para o número inteiro mais próximo.

NOTA
- Para aqueles entre nós que dormiram durante as aulas de geometria, um ra-
diano é aproximadamente igual a 57 .296 graus. Por que um número tão redon-
do? Os radianos estão relacionados à circunferência de um círculo - a medida
exata é
#Radianos= (#graus* pi) / 180
Os radianos são usados em computação devido aos cálculos e, portanto, estão
além do escopo deste livro. Simplesmente lembre-se de converter seus ângu-
los de graus para radianos antes de empregar qualquer dos métodos de Math
relacionados aos ângulos.
Introdução ao .NET Framework

A classe Math em geral é útil para calcular valores. Mesmo se você não letnbrar (ou nunca tiver
aprendido) o que é uma tangente hiperbólica, é na classe Math que a encontrará.

Classes de Conjuntos no .NET Framework


Você já conheceu o tipo de dados Array no Dia 3, "lntrodução à Progra,nação co1n o Visual Ba-
sic .NET". O .NET Framework possui várias outras classes de conjuntos que adicionam mais re-
cursos a Array. Essas classes pennitem o annazena,nento de un1a lista de infonnações
exatan1ente co1no nos arrays, 1nas, alétn disso, elas tê1n recursos como a ordenação de listas e a
possibilidade de incluir e recuperar com maior facilidade na lista. Várias classes de conjuntos (a
maioria no espaço de notne Sys tem. Co 11 ect i ons) estão disponíveis. Algu,nas serão descritas
ainda nesta lição. Se precisar de outros tipos de coleções, verifique nesse espaço de nome antes
de procurar e1n outro local.

Arraylist
ArrayL i st é o conjunto que n1ais se parece com un1 Array. A principal diferença é que foi proje-
tado para permitir u,n cresci,nento fácil conforme forem sendo adicionados mais elementos.
Co,no as outras classes do espaço de nome System. Co 11 ect i ons, ArrayL i st foi criado para arma-
zenar u,n conjunto de variáveis Object. Portanto, pode ser usado para conter qualquer tipo de
dado. O uso da classe ArrayL i st será adequado se você tiver um conjunto 1nuito dinâmico que
possa aumentar ou di,ninuir con1 o passar do te1npo e se não precisar dos recursos dos outros
conjuntos.
Você pode criar uma nova instância da classe ArrayL is t usando um dos construtores disponíveis.
U,na versão pennite a definição da capacidade inicial do conjunto, e outra configura o tamanho
inicial COlTIO l6:
Dim arrlist As New Arraylist
' cria um novo Arraylist,com 16 membros inicialmente
Dim arrlist2 As New Arraylist(20)
' cria um novo Arraylist,com 20 membros inicialmente
Dim arrlist3 As Arraylist
Set arrlist3 = New Arraylist(52)
' cria um novo Arraylist,com 52 membros inicialmente
As outras propriedades e métodos importantes da classe Arraylist são usados para adicionar,
recuperar ou excluir membros do conjunto. A Tabela 8.5 resume alguns dos principais mem-
bros.
1 216 Dia8

T ABELA 8.5 Métodos e Propriedades da Classe Arrayl i st

Membro Descrição
Propriedades
Capacity Otamanho atual da classe Arrayl i st. Configurado pela primeira vez
quando ela é criada (16 por padrão), podendo aumentar conforme
mais elementos forem adicionados.
Count A quantidade efetiva de itens na classe Arraylis t.
Item Retorna um elemento específico da classe Arrayl i st.
Métodos
Add Adiciona um novo item à ArrayL i st. Se isso fizer com que Count ul-
trapasse Capaci ty, essa propriedade será aumentada (com sua
quantidade inicial - 16 por padrão).
Clear Remove todos os itens de ArrayLi st. Count é configurada com O,
mas Capaei ty não é alterada.
IndexOf Retorna a posição de um certo objeto na classe Arrayl i st. Esse mé-
todo é útil quando usado depois de uma ordenação.
Insert Adiciona um novo elemento à Arrayli st em uma posição solicitada.
Remove Remove o objeto solicitado de Arrayli st.
RemoveAt Remove o elemento da posição solicitada.
Sort Ordena os membros de ArrayL i st.
ToArray Copia toda ou parte de uma classe Arraylist em um array.
TrimToSize Diminui Arrayl i st de modo que tanto Count quanto Capaci ty sejam
iguais à quantidade atual de elementos na classe.

O uso da classe Arrayl i st é 1nais adequado na substituição de arrays quando sabemos que o ta-
n1anl10 au1nentará, mas não tivermos noção de até onde o conjunto avançará. Seu crescimento
ili111itado pennite que os itens sejam adicionados quando necessário.

Queue e Stack
Os conjuntos Queue e Stack são sen1elhantes. São dois tipos 'clássicos' de co1~untos, sendo úteis
e,n 1nuitos esforços de progra1nação. As duas classes são conjuntos que permitirão que você adi-
cione co1T1 facilidade novos itens ..Em geral remove1n o ite1n quando é visualizado porque foram
projetadas para armazenar o conjunto te1nporaria1nente. Elas difere1n no modo co1no os itens são
adicionados em cada conjunto e, principalmente, em como são removidos dos conjuntos.
A classe Queue é um conjunto 'pri1neiro a entrar, pri1neiro a sair' (FJFO, first-in, first-out). Isso
significa que os itens são re1novidos da fila na 1nes1na orde1n que foran1 adicionados. Essa carac-
terística é se1nelhante à da 1naioria das fi las (ou formações em seqüência) que você possa ter vis-
to. E1n geral, e1n u1n ponto de ônibus, na fila do almoço ou na passage1n pela alfândega, as
pessoas que chegam pri1neiro são atendidas antes. As filas são freqüente1nente usadas em pro-
Introdução ao .NET Framework

grarnação quando esse co1npo1tamento é desejado. Por exe1nplo, quando dois programas (ou ob-
jetos) estão se comunicando, as 1nensagens são colocadas ern urna fila para o objeto receptor. Em
seguida, ele poderá processá-las na ordem que fora1n recebidas. A Tabela 8.6 descreve alguns
dos métodos e propriedades i1npo1tantes da classe Queue.

TABELA 8.6 Métodos e Propriedades da Classe Queue


Membro Descrição
Propriedades
Count A quantidade de itens na fila.
Métodos
Clear Remove todos os itens da fila.Nota
Dequeue Extrai e retorna um objeto para a fila.
Enqueue Insere um novo objeto na fila.
Peek Permite que você examine o próximo item sem removê-lo da fila. Isso é
útil porque removê-lo poderia impedir outro método de lidar com a fila
adequadamente.

Por que os métodos são chamados de Dequeue e Enqueue? Por que não Add e Remo-
ve? É simplesmente uma questão de manter os nomes tradicionais. Os programa-
NOTA
dores sempre se referiram ao ato de adicionar um item a uma fila como enfileirar
o item, portanto, esse termo, assim como desenfileirar, foram adotados.

A e.lasse Stack é um conjunto 'primeiro a entrar, último a sair' (FILO, first-in, last-out). Isso sig-
nifica que os itens são rernovidos da pilha na ordern inversa à qual forarn adicionados. A orde111
FILO é análoga a uma pilha de pratos: o prato adicionado por últirno sempre é removido primei-
ro. As pilhas são a solução clássica para lidar com proble1nas que requerern a inversão de uma
ordem de operações. Muitos cálculos são processados internamente corn a ajuda das pilhas. A
Tabela 8.7 descreve alguns dos rnétodos e propriedades da classe Stack.

TABELA 8.7 Métodos e Propriedades da Classe Stack


Membro Descrição
Propriedades
Count A quantidade de itens na pilha.
Métodos
Clear Remove todos os itens da pilha.
Remove e retorna o próximo item para a pilha. Exatamente como a fila possui
Pop Enqueue e Dequeue, os dois métodos usados tradicionalmente para lidar com pi-
lhas são Pop e Push.
1 218 Dia8

T ABELA 8.7 Métodos e Propriedades da Classe Stack (continuação)

Membro Descrição
Push Insere um novo objeto na pilha.
Peek Permite que você examine o próximo item da pilha sem removê-lo. Queue e
Stack são conjuntos interessantes, em parte por uma perspectiva histórica,
mas também porque resolvem problemas específicos de programação. Quan-
do for necessário um conjunto com o comportamento desses dois objetos, é
recomendável lembrar deles.

SortedL;st
A classe Sortedl i st possui características tanto de Arrayl is t quanto de NameVa 1ueCo 11 ect i on,
assin1 co1no alguns recursos úteis adicionais específicos. Se1nelhante à ArrayL i st, a classe Sor-
tedL i st pode aumentar, e apresenta as mes1nas propriedades Count e Capaci ty daquele conjun-
to. Como e1n NameVa 1ueCo 11 ect i on, cada item é identificado por um no1ne. Alé1n disso, os
valores de SortedL i st são ordenados com base no no1ne fornecido a cada ite1n. Assi1n, ela será
útil sempre que você precisar de uma lista de itens organizados que possa ' crescer", como os par-
ticipantes de u1na conferência ou os resultados de u1na bateria de provas de u1na turma escolar. A
Tabela 8.8 descreve alguns dos métodos e propriedades significativos da classe Sortedl i st.

TABELA 8.8 Métodos e Propriedades da Classe Sortedl is t

Membro Tipo Descrição


Propriedades
Capacity O tamanho atual da classe SortedL i st. Configurado pela
primeira vez quando ela é criada (16 por padrão), poden-
do aumentar conforme mais elementos forem adiciona-
dos.
Count A quantidade efetiva de itens em SortedL is t .
Métodos
Add Adiciona um novo item à Sortedlist. Se