Curso Programando com C# e o Visual Studio .NET 2005
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 1
Curso Programando com C# e o Visual Studio .NET 2005
Nota sobre direitos autorais:
Este e-book é de autoria de Herbert Moroni Cavallari da Costa Gois, sendo
comercializado
diretamente
www.linhadecodigo.com.br
ou
www.mercadolivre.com.br,
através
através
mediante
do
site
do
site
contato
www.juliobattisti.com.br
de
e
leilões
Mercado
Livre:
através
do
email:
batisti@hotmail.com ou webmaster@juliobattisti.com.br, diretamente pelo autor ou
por Júlio Battisti. No Mercado Livre, somente o usuário GROZA é que tem
autorização para comercializar este e-book. Nenhum outro usuário/email e/ou
empresa está autorizada a comercializar este ebook.
Ao adquirir este ebook você tem o direito de lê-lo na tela do seu computador e de
imprimir quantas cópias desejar. É vetada a distribuição deste arquivo, mediante
cópia ou qualquer outro meio de reprodução, para outras pessoas. Se você recebeu
este ebook através do e-mail ou via ftp de algum site da Internet, ou através de
um CD de Revista, saiba que você está com uma cópia pirata, ilegal, não
autorizada, a qual constitui crime de Violação de Direito Autoral, de acordo com a
Lei 5988. Se for este o caso entre em contato com o autor, através do e-mail
webmaster@juliobattisti.com.br, para regularizar esta cópia. Ao regularizar a sua
cópia você irá remunerar, mediante uma pequena quantia, o trabalho do autor e
incentivar que novos trabalhos sejam disponibilizados. Se você tiver sugestões
sobre novos cursos que gostaria de ver disponibilizados, entre em contato pelo email: webmaster@juliobattisti.com.br.
Visite periodicamente o site www.juliobattisti.com.br para ficar por dentro das
novidades:
•
Cursos de informática.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 2
Curso Programando com C# e o Visual Studio .NET 2005
•
Guias de Estudo para os Exames de Certificação da Microsoft.
•
Artigos e dicas sobre Certificações da Microsoft.
•
Artigos sobre Carreira e Trabalho.
•
Dicas de livros e sites sobre diversos assuntos.
•
Simulados
•
ESTE E-BOOK NÃO PODE SER FORNECIDO EM UM CD
gratuitos,
em
português,
para
os
exames
da
Microsoft.
OU DVD DE NENHUMA REVISTA
•
SE
VOCÊ
ATRAVÉS
OUTRO
OBTEVE
DO
UMA
E-MULE,
PROGRAMA
CÓPIA
KAZAA,
DE
DESTE
E-BOOK
MORPHEUS
OU
COMPARTILHAMENTO,
SAIBA QUE VOCÊ ESTÁ COM UMA CÓPIA ILEGAL,
NÃO AUTORIZADA
•
USAR UMA CÓPIA NÃO AUTORIZADA É CRIME DE
VIOLAÇÃO DE DIREITOS AUTORAIS, COM PENA
PREVISTA DE CADEIA
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 3
Curso Programando com C# e o Visual Studio .NET 2005
PRÉ-REQUISITOS PARA O CURSO:
Para que você possa acompanhar as lições deste curso é necessário que você já
tenha preenchido os seguintes pré-requisitos:
•
Conhecimento básico do Windows 98, 2000 ou XP, tais como:
Criação de pastas e subpastas.
Utilização do mouse e do teclado.
Operações básicas com arquivos e pastas, usando o Windows
Explorer.
Conhecer conceitos tais como ícones, área de trabalho, janelas do
Windows, uso de menus e outras configurações básicas do Windows.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 5
Curso Programando com C# e o Visual Studio .NET 2005
Palavras do autor:
A proposta desde curso é ajudá-lo a entrar no mundo da programação usando a
linguagem C# e a ferramenta Visual Studio .NET 2005. Para tanto, não exite em
fazer os exemplos propostos. Aprender a programar é como dirigir, você aprende
fazendo, para isso apresentamos uma série de exemplos passo-a-passo e conforme
vamos nos aprofundando nos exemplos e as duvidas vão surgindo discutimos a
teoria, assim fica mais fácil assimilar e memorizar o assunto proposto.
Também estou a disposição para responder eventuais dúvidas sobre o conteúdo do
curso, envie-me também suas sugestões para que possamos sempre melhorar o
material proposto. Meu e-mail para contato é herbertmoroni@hotmail.com ou
moroni@weblitenet.com.br.
Ao final deste curso você vai dominar a linguagem de programação C# e vai saber
como
tirar
proveito
dos
principais
recursos
do
Visual
Studio
.NET
2005,
proporcionando melhor produtividade no desenvolvimento de sistemas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 6
Curso Programando com C# e o Visual Studio .NET 2005
Índice do Curso
Índice do Curso............................................................................................ 7
Introdução ................................................................................................ 10
Módulo 1.............................................................................................................................................13
Bem vindo ao C# e ao Visual Studio.NET 2005 ..................................................................13
Lição 1 – Bem vindo ao C# e ao Visual Studio .NET 2005 ........................................13
Lição 2 – Usando o CSC para compilar seu programa.................................................28
Lição 3 – Criando sua primeira aplicação Windows com C# e o Visual Studio
.NET.................................................................................................................................................34
Lição 4 – Criando documentação usando XML e cometários.....................................47
Módulo 2.............................................................................................................................................56
Variáveis.............................................................................................................................................56
Lição 5 – Entendo variáveis e tipos de dados .................................................................56
Lição 6 – Nomeando uma variável ......................................................................................59
Lição 7 – Palavras Reservadas do C# ................................................................................61
Lição 8 – Declarando variáveis .............................................................................................62
Lição 9 – Atribuindo valor a variáveis ................................................................................63
Lição 10 – Tipos de dados ......................................................................................................64
Lição 11 – Adicionando valor a uma variável..................................................................67
Lição 12 – Operadores .............................................................................................................69
Módulo 3.............................................................................................................................................81
Métodos e Escopo ...........................................................................................................................81
Lição 13 – Entendento métodos ...........................................................................................81
Lição 14 – Entendento Escopo ..............................................................................................86
Lição 15 – Criando e Chamando Métodos.........................................................................89
Módulo 4...........................................................................................................................................107
Estruturas de Decisão .................................................................................................................107
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 7
Curso Programando com C# e o Visual Studio .NET 2005
Lição 16 – Entendendo as Estruturas de Decisão........................................................107
Lição 17 – Usando o if............................................................................................................108
Lição 18 – Usando o switch..................................................................................................118
Módulo 5...........................................................................................................................................129
Estruturas de Repetição .............................................................................................................129
Lição 19 – Usando o while ....................................................................................................129
Lição 20 – Usando o do .........................................................................................................134
Lição 21 – Usando o for.........................................................................................................138
Lição 22 – Conhecendo o foreach......................................................................................143
Módulo 6...........................................................................................................................................144
Gerenciando Erros e Exceções .................................................................................................144
Lição 23 – Conhecendo os três tipos de erros ..............................................................144
Lição 24 – Encontrando erros com o Visual Studio.NET 2005................................145
Lição 25 – Usando a janela Watch ....................................................................................158
Lição 26 – Usando a janela Command.............................................................................163
Lição 27 – try..catch ...............................................................................................................166
Lição 28 – Usando try...catch aninhados........................................................................176
Lição 29 – Programação defensiva....................................................................................180
Lição 30 – Exit try....................................................................................................................181
Módulo 7...........................................................................................................................................183
Arrays e Coleções .........................................................................................................................183
Lição 31 – Usando Arrays .....................................................................................................183
Lição 32 – Coleções.................................................................................................................197
Módulo 8...........................................................................................................................................205
Aprofundando em Windows Forms.........................................................................................205
Lição 33 – Trabalhando com múltiplos formulários ....................................................205
Lição 34 – Passando valores entre Forms ......................................................................212
Lição 35 – Posicionando os formulários na tela............................................................217
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 8
Curso Programando com C# e o Visual Studio .NET 2005
Lição 36 – Controlando os eventos dos formulários...................................................218
Módulo 9...........................................................................................................................................221
Usando controles do Windows Forms....................................................................................221
Lição 37 – Usando o controle dateTimePicket...............................................................221
Lição 38 – Usando os controles radioButton, checkBox, listBox e comboBox..226
Módulo 10 ........................................................................................................................................238
Bancos de dados com ADO.NET ..............................................................................................238
Lição 39 – Conceitos básicos de banco de dados ........................................................238
Lição 40– Usando o Visual Studio 2005 para manipular dados de um banco de
dados. ...........................................................................................................................................245
Módulo 11 ........................................................................................................................................260
Imprimindo......................................................................................................................................260
Lição 41 – Imprimindo a partir de uma textBox ..........................................................260
Módulo 12 ........................................................................................................................................274
Distribuindo sua aplicação.........................................................................................................274
Lição 42 – Criando um projeto de instalação ................................................................275
Lição 43 – Executando o programa de instalação .......................................................295
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 9
Curso Programando com C# e o Visual Studio .NET 2005
Introdução
Neste curso você vai aprender a usar a linguagem de programação C# e utilizar
seus recursos para desenvolver aplicações para Windows através da ferramenta
Visual Studio .NET 2005.
O C#, junto com o Visual Studio .NET 2005 compõe uma ferramenta extremamente
robusta e fácil de utilizar, com perfeito suporte a todas as novas ondas que rondam
o mundo da informática e tecnologia.
O Visual Studio .NET 2005 é a melhor ferramenta de desenvolvimento de aplicações
para a plataforma .NET. Com uma interface amigável e integrada com os ambientes
e de fácil entendimento, proporciona aos desenvolvedores a criação de aplicações
sofisticadas com todos os recursos existentes, sem ter que ficar criando parte de
código em um aplicativo e o restante no outro. É possivel com o Visual Studio
gerenciar recursos da máquina e local e de um possível servidor, criar aplicações
para Windows, web e dispositivos móveis.
Capítulo 1: Neste capítulo você vai iniciar no desenvolvimento usando o Visual
Studio .NET 2005, vai aprender a criar aplicações Windows e a utilizar o CSC para
compilar seu programa pelo prompt de comando. Vai aprender também como gerar
documentação XML a partir de comentários que podem ser inseridos em seus
programas.
Capítulo 2: Neste capítulo você vai aprender sobre variáveis, tipos de dados,
conversão de tipos de dados, operadores, o que é Common language Runtime e
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 10
Curso Programando com C# e o Visual Studio .NET 2005
Common Type System, além disso vai receber dicas sobre como nomear suas
variáveis.
Capitulo 3: Neste capitulo você vai entender o que são métodos e escopo. Vai
aprender a criar e usar métodos.
Capítulo 4: Neste capítulo você vai aprender sobre estruturas de DECISÃO, vai
saber como usar o IF e o SWITCH.
Capítulo 5: Neste capítulo você vai aprender sobre estruturas de REPETIÇÃO, vai
saber como usar o WHILE, o DO, o FOR e vai conhecer o FOREACH.
Capítulo 6: Neste capítulo você vai aprender como encontrar erros utilizando o
Visual Studio .NET, vai também aprender a usar o Try..Catch..Finally para tratar
seus erros em tempo de execução. Não bastando vai aprender a programar
defensivamente, evitando erros.
Capítulo 7: Neste capítulo você vai aprender a criar e manipular dados de Arrays e
Coleções.
Capítulo 8: Neste capítulo você vai aprender a usar múltiplos formulários no seu
programa, passar valor entre eles, posicioná-los na tela e controlar seus eventos.
Capítulo 9: Neste capítulo você vai aprender a usar os controles disponíveis para
suas
aplicações
Windows,
para
isso
estudaremos
o
uso
dos
controles:
DateTimePicket, RadioButton, CheckBox, ListBox, ComboBox.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 11
Curso Programando com C# e o Visual Studio .NET 2005
Capítulo 10: Neste capítulo você vai aprender os conceitos principais de banco de
dados e como inserir, apagar e alterar registros.
Capítulo 11: Neste capítulo você vai aprender a imprimir informações de seus
programas, vai aprende também a implementar os recurso de configurar impressão
e visualizar impressão.
Capítulo 12: Neste capítulo você vai aprender como distribuir suas aplicações
criando um instalador.
Para enviar suas dúvidas referentes aos assuntos e exemplos abordados neste
curso, para enviar sugestões de alterações/correções, para sugerir novos cursos,
para criticar e para elogiar (porque não?), é só entrar em contato pelo e-mail:
moroni@weblitenet.com.br.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 12
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 1
Bem vindo ao C# e ao Visual Studio.NET 2005
Neste capitulo você vai se familiarizar com a linguagem C# e o ambiente de
desenvolvimento do Visual Studio .NET 2005. Para isso vai criar uma sua primeira
aplicação.
Lição 1 – Bem vindo ao C# e ao Visual Studio .NET
2005
Vamos primeiramente conhecer um pouco do Visual Studio.NET, a ferramenta que
utilizaremos para desenvolver nossos aplicativos e criar nosso primeiro exemplo.
1 – Entre no Visual Studio.NET, eu estou usando a versão 2005, mas os exercícios
funcionam em qualquer versão.
Você pode entrar no Visual Studio.NET através do menu Iniciar / Programas /
Microsoft Visual Studio .NET / Microsoft Visual Studio .NET , sinta-se a
vontade para criar qualquer atalho para ele.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 13
Curso Programando com C# e o Visual Studio .NET 2005
A imagem anterior mostra o Visual Studio .NET assim que o iniciamos, é exibida a
pagina Start Page onde podemos abrir rapidamente os ultimos projetos criados
através da caixa Recent Projects.
2 – No menu File, aponte em New, e clique em Project. (Ou clique Ctrl+Shift+N).
A caixa de dialogo New Project aparece. Ela permite que criemos um novo
projeto usando vários templates, como um Windows Application, Class Library,
Console Application e vários outros.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 14
Curso Programando com C# e o Visual Studio .NET 2005
3 – No painel Project Type, clique em Visual C# Projects, aqui estão todos os
templates disponíveis para a linguagem C#.
4 – No painel Templates clique em Console Application.
5 – No campo nome digite, ClassicoHelloWorld.
Perceba que você pode ainda alterar o caminho onde sua aplicação será
salva e o nome da sua Solução.
6 – Clique em OK.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 15
Curso Programando com C# e o Visual Studio .NET 2005
A barra de menus (menu bar) possibilita o acesso aos comandos que você usa
no ambiente de programação. Você pode usar o teclado ou o mouse para acessar o
menu ou atalhos exatamente como usa em outros programas baseados em
Windows.
A barra de ferramentas (toolbar) é localizada embaixo da barra de menus e
disponibiliza botões que executam os comandos usados com mais freqüência. Não
confunda toolbar com toolbox.
A janela Solution Explorer mostra os nomes dos arquivos associados com o seu
projeto. Você pode dar um clique duplo sobre o nome do arquivo para exibi-lo no
painel de código (Code pane). Vamos examinar os arquivos que o Visual Studio
criou como parte do seu projeto:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 16
Curso Programando com C# e o Visual Studio .NET 2005
•
ClassicoHelloWorld.sln organiza os projetos de cada solução, uma solução
pode ter vários projetos, seu nome é representado no primeiro item na
janela Solution Explorer só que sem a extensão do arquivo.
•
ClassicoHelloWorld.csproj este é o arquivo do projeto C#. Pode ser
associado a vários arquivos de código. É reconhecido no Solution Explorer
pelo nome do projeto apenas, no entanto é gravado no disco com a
extensão .csproj.
•
Program.cs é um arquivo de código do C#. Você vai escrever seu código
neste
arquivo.
O
Visual
Studio
já
adicionou
algum
código
nele
automaticamente, examinaremos esse código mais adiante.
•
AssemblyInfo.cs este é um outro arquivo de código do C#. Você pode usar
esse arquivo para adicionar atributos ao seu programa, como por exemplo,
nome do autor, data que o programa foi escrito e outros. Vamos examina-lo
também mais adiante no curso.
Aos poucos nós vamos explorando mais o Visual Studio, vamos ao nosso primeiro
exemplo.
O arquivo Program.cs define uma classe chamada Program que contém um
método chamado Main. Todos os métodos precisam ser definidos dentro de uma
classe. O método Main é especial porque ele é o primeiro a ser executado quando
o programa é iniciado, por isso ele precisa ser designado como static (estático),
métodos e classes vão ser discutidos em detalhes mais adiante no curso.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 17
Curso Programando com C# e o Visual Studio .NET 2005
Importante: O C# é case-sensitive, ele diferencia letras minúsculas de
maiúsculas, um M é interpretado diferente de um m. Consequentemente Main é
diferente de main.
Nosso primeiro exemplo é bem simples, e um clássico para quem esta aprendendo
qualquer linguagem, ele escreve Hello World no console.
7 – Dentro do método Main, entre os colchetes digite: Console
A classe Console contém os métodos para exibir mensagens na tela e pegar as
entradas do teclado. Tudo que o usuário digita no teclado pode ser lido através da
classe Console. A classe Console só é significante para aplicações que rodam no
prompt de comando como neste nosso primeiro exemplo.
8 – Agora digite um ponto depois de Console.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 18
Curso Programando com C# e o Visual Studio .NET 2005
Uma lista aparece, ela é chamada de IntelliSense, esse não é um recurso
exclusivo do Visual Studio mas ajuda muito na programação principalmente em
linguagens case-sensitive, como é o C#. O IntelliSense exibe todos os métodos,
propriedades e campos da classe.
9 – Selecione WriteLine, você pode usar o Mouse ou o Teclado, tecle Enter ou dê
um clique duplo sobre o WriteLine.
O IntelliSense é fechado e o método WriteLine é adicionado ao código. Como a
seguinte imagem:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 19
Curso Programando com C# e o Visual Studio .NET 2005
Quando o IntelliSense aparece você também pode pressionar W para ir direto para
o primeiro membro do método Console que começar com w.
10 – Abra parênteses (
É mostrado uma outra forma do IntelliSense, esse mostra os parâmetros do
método WriteLine. O método WriteLine tem o que chamamos de Sobrecarga
(Overload). Para cada sobrecarga do método WriteLine usamos parâmetros
diferentes. Cada sobrecarga e seus respectivos parâmetros podem ser visualizados
clicando com o mouse na seta do IntelliSense
ou navegando pelas setas do
teclado.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 20
Curso Programando com C# e o Visual Studio .NET 2005
11 – Feche os parênteses ) e digite ponto-e-virgula, vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 21
Curso Programando com C# e o Visual Studio .NET 2005
12 – Digite entre os parênteses a string “Hello World”, string deve ficar entre
aspas. Vamos aprender sobre os tipos de dados em detalhes também, o importante
agora é saber que string é um tipo de dado. Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 22
Curso Programando com C# e o Visual Studio .NET 2005
Pegue o habito de digitar os pares de caracteres juntos, como ( e ) e { e }, antes
de entrar com seus respectivos conteúdos. Assim você evitará alguns erros por
esquecer de fechar.
13 – Vamos agora compilar nossa aplicação. No menu Build, clique em Build
Solution. Se tudo estiver certinho vai aparecer a seguinte linha na janela Output:
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========
Para exibir a janela Output na barra de menus clique em View, Output ou pressione
Ctrl+W+O.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 23
Curso Programando com C# e o Visual Studio .NET 2005
Um asterisco depois do nome do arquivo no painel de código indica que foram
feitas modificações no código do respectivo arquivo e que essas alterações não
foram salvas. Você pode salvar manualmente antes de compilar a aplicação, mas
ao compilar o Visual Studio salva automaticamente todos os arquivos da aplicação.
14 – No menu Debug, clique em Start Without Debugging para executar o
programa no prompt de commando.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 24
Curso Programando com C# e o Visual Studio .NET 2005
O programa vai escrever Hello World como a ilustração acima.
Nós escolhemos Start Without Debugging para forçar uma pausa no final da
execução. Se clicássemos em Start ele iria executar o programa e fechar o prompt
de comando logo após a execução, seria tão rápido que não conseguiríamos ver o
que foi escrito, experimente.
15 – Com o foco no prompt de comando pressione qualquer tecla.
A janela irá fechar e retornaremos para o Visual Studio.
16 - Na janela Solution Explorer, clique no botão Show All Files.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 25
Curso Programando com C# e o Visual Studio .NET 2005
Aparecem os nomes bin e obj depois do nome do projeto. Esses dois
correspondem a pastas com seus respectivos nomes. Essas pastas são criadas
quando você executa a aplicação e contem uma versão executável do programa e
outros arquivos necessários para depurar o programa.
17 – Ainda na janela Solution Explorer, clique no sinal de + à esquerda do nome
bin.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 26
Curso Programando com C# e o Visual Studio .NET 2005
Um outro nome aparece representando uma outra pasta chamada debug.
18 – Clique no sinal de + de debug.
Repare nos arquivos: ClassicoHelloWorld.exe e ClassicoHelloWorld.pdb.
O arquivo .exe é o executável da aplicação.
O arquivo .pdb armazena informações de depuração da aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 27
Curso Programando com C# e o Visual Studio .NET 2005
O arquivo ClassicoHelloWorld.vshost.exe só aparece no Visual Studio 2005, ele
é usado para melhorar a performance da depuração de erros.
Como vimos até agora, o Visual Studio compilou automaticamente nosso programa
e criou os arquivos necessários automaticamente, durante o processo de
compilação. Em resumo a compilação é o processo que transforma seus arquivos
fonte em um arquivo executável pelo sistema operacional, um .exe por exemplo.
Lição 2 – Usando o CSC para compilar seu programa
1 - Com o Visual Studio fechado, na barra de ferramentas do windows clique em
Iniciar, Executar, digite notepad em Abrir e clique em OK.
2 - Digite o seguinte código no notepad.
using System;
namespace txtHello
{
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 28
Curso Programando com C# e o Visual Studio .NET 2005
class Class1
{
static void Main(string[] args)
{
Console.WriteLine("Hello World");
}
}
}
3 – Salve o arquivo com o nome teste.cs
Para isso será necessário escolher Todos os arquivos na opção Salvar como tipo no
notepad quando você clicar em Arquivo \ Salvar.
4 – Feche o notepad.
5 – No menu Iniciar, vá em Programas / Visual Studio .NET / Visual Studio
.NET Tools e clique em Visual Studio .NET Command Prompt.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 29
Curso Programando com C# e o Visual Studio .NET 2005
Para
compilarmos
manualmente
nosso
programa
são
necessárias
algumas
mudanças no ambiente do sistema operacional como alterações em algumas
variáveis de ambiente, PATH, LIB e INCLUDE. Essas mudanças incluem adicionar
pastas contendo bibliotecas e utilitários .NET.
6 – No prompt, vá até a pasta que você salvou o arquivo teste.cs.
7 – Digite dir e tecle enter.
Ele vai listar os arquivos da pasta, no caso vai mostrar o arquivo teste.cs.
8 – Digite: csc /out:hello.exe teste.cs
Isso vai criar um executável chamado hello.exe.
9 – Digite dir e tecle enter.
Agora você não vê apenas o arquivo teste.cs, foi adicionado um arquivo chamado
hello.exe, ele é o resultado da compilação do seu arquivo fonte teste.cs.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 30
Curso Programando com C# e o Visual Studio .NET 2005
10 – Digite hello e tecle enter.
O programa será executado, no caso, será escrito a palavra “Hello World”, no
prompt semelhante ao que ocorreu com o exemplo da lição 1.
11 – Digite del hello.exe e tecle enter.
Isso apagara o arquivo executável.
12 – Digite csc teste.cs
Ao omitir o parâmetro /out o compilador cria um arquivo executável com o mesmo
nome do arquivo fonte. Será criado então o arquivo teste.exe, execute este
arquivo para testá-lo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 31
Curso Programando com C# e o Visual Studio .NET 2005
13 – Abra novamente o arquivo teste.cs, pode ser no próprio notepad ou no Visual
Studio .NET.
14 – Apague a primeira linha de código. Vai ficar assim:
namespace txtHello
{
class Class1
{
static void Main(string[] args)
{
Console.WriteLine("Hello World");
}
}
}
15 – Compile e teste a aplicação, novamente fica a sua escolha, use o prompt de
comando ou o Visual Studio .NET. Uma recomendação, compile manualmente pelo
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 32
Curso Programando com C# e o Visual Studio .NET 2005
prompt para se familiarizar melhor com ele, já que não falaremos muito mais
sobre ele no curso.
16 – Ao compilar ele vai emitir um erro. Como este:
teste.cs(7,4): error CS0246: The type or namespace name 'Console' could not be
found (are you missing a using directive or an assembly reference?)
17
–
Mude
a
linha
com
Console.WriteLine("Hello
World");
para
System.Console.WriteLine("Hello World");
18 - Compile e teste novamente.
A compilação é concluída com sucesso e o programa funciona normalmente só que
desta vez sem a diretiva using System;
Como parte do Microsoft .NET Framework o C# pode fazer uso de uma série de
classes de utilidades que executam uma gama de operações úteis. Essas classes
são organizadas no que chamamos de namespaces, eles contem um conjunto de
classes relacionadas e também podem conter outros namespaces.
System é um namespace. O namespace System é o mais importante porque
contém as classes que a maior parte das aplicações utiliza para interagir com o
sistema operacional.
A classe Console é uma classe do namespace System.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 33
Curso Programando com C# e o Visual Studio .NET 2005
O método Writeline é um método da classe console que escreve uma mensagem
no prompt de comando.
Os namespaces ajudam a reduzir a complexidade de um programa e a facilitar sua
manutenção.
Podemos criar nossos próprios namespaces.
Programas pequenos e crianças pequenas têm uma coisa obvia em comum, eles
crescem. Com o crescimento de um programa surgem dois problemas:
1º - Quanto mais código maior a complexidade do programa e mais difícil
sua manutenção.
2º - Mais código usualmente representa mais nomes de dados, funções,
classes, etc. Facilitando os erros por conter nomes iguais.
Os namespaces tem a função de ajudar a solucionar esses dois problemas. Para
usar um namespace lembre-se que é necessário fazer uma referencia ao mesmo
através de uma diretiva using seguido do nome do namespace no começo do
bloco de código. Você pode fazer referencia a vários namespaces no seu arquivo
de código. Um em cada linha. Um após o outro.
Lição 3 – Criando sua primeira aplicação Windows
com C# e o Visual Studio .NET
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 34
Curso Programando com C# e o Visual Studio .NET 2005
Até agora por motivo didático usamos somente o prompt de comando para criar os
nossos exemplos. Como sabemos esse tipo de aplicação não é muito útil nos dias
de hoje. O Visual Studio .NET conta com diversos recursos importantes para o
desenvolvimento de aplicações Windows.
1 – Entre no Visual Studio .NET.
2 – Crie um novo projeto, só que desta vez do tipo Windows Application,
chamado WinHello.
O Visual Studio .NET cria e mostra um formulário baseado em Windows no modo
Design.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 35
Curso Programando com C# e o Visual Studio .NET 2005
Vamos agora criar a nossa interface com o usuário.
3 – Na barra de ferramentas do Visual Studio .NET clique em ToolBox. O ícone da
ToolBox aparece a esquerda do formulário. Você também pode localizar a ToolBox
através do menu View > ToolBox.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 36
Curso Programando com C# e o Visual Studio .NET 2005
4 – Arraste da barra de ferramentas o controle Label e posicione-o no canto
superior esquerdo do formulário.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 37
Curso Programando com C# e o Visual Studio .NET 2005
Para colocar um controle no formulário você pode também dar um clique duplo
sobre ele na barra de ferramentas ou clicar uma vez sobre ele na barra de
ferramentas e depois clicar no formulário. O clique duplo posiciona o controle no
canto superior esquerdo. A segunda opção coloca o controle no local onde você
clicar.
5 – Coloque também no formulário um controle TextBox e um controle Button.
Como na próxima ilustração:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 38
Curso Programando com C# e o Visual Studio .NET 2005
6 – Na janela Solution Explorer, clique no botão View Code.
O código do arquivo Form1.cs aparece.
Para voltar ao modo design, também na janela Solution Explorer clique em View
Design.
Form1.cs tem todo o código gerado automaticamente pelo Visual Studio .NET.
Note os seguintes elementos no código.
•
As diretivas usadas no inicio do código referenciando aos namespaces.
using System;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 39
Curso Programando com C# e o Visual Studio .NET 2005
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
•
O Visual Studio .NET usa o mesmo nome do projeto para criar o namespace
principal.
namespace WinHello
{
…
}
•
Uma classe chamada Form1 dentro do namespace WinHello.
namespace WinHello
{
public class Form1 ...
{
...
}
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 40
Curso Programando com C# e o Visual Studio .NET 2005
•
O constructor (construtor), é um método especial que tem o mesmo nome
da classe. Ele é o primeiro método a ser executado quando o programa é
iniciado.
public class Form1 ...
{
...
public Form1()
{
...
}
}
•
Um método chamado InitializeComponent. O código dentro deste método
configura as propriedades dos controles que adicionamos no modo Design.
Atenção, não modifique o conteúdo do InitializeComponent diretamente no
código, use a janela Properties no modo Design. Vamos aprender mais sobre
os
métodos
nos
próximos
tutoriais.
Este
método
esta
no
arquivo
Form1.designer.cs no Visual Studio .NET 2005.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 41
Curso Programando com C# e o Visual Studio .NET 2005
private void InitializeComponent()
{
this.label1 = new System.Windows.Forms.Label();
this.button1 = new System.Windows.Forms.Button();
this.textBox1 = new System.Windows.Forms.TextBox();
this.SuspendLayout();
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(13, 13);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(35, 13);
this.label1.TabIndex = 0;
this.label1.Text = "label1";
//
// button1
//
this.button1.Location = new System.Drawing.Point(150, 50);
this.button1.Name = "button1";
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 42
Curso Programando com C# e o Visual Studio .NET 2005
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.TabIndex = 1;
this.button1.Text = "button1";
this.button1.UseVisualStyleBackColor = true;
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(16, 50);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(100, 20);
this.textBox1.TabIndex = 2;
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F,
13F);
this.AutoScaleMode =
System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(292, 273);
this.Controls.Add(this.textBox1);
this.Controls.Add(this.button1);
this.Controls.Add(this.label1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout();
}...
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 43
Curso Programando com C# e o Visual Studio .NET 2005
Vamos agora definir as propriedades dos controles que colocamos no Form.
7 – Volte para o modo Design.
Para voltar ao modo design, também na janela Solution Explorer clique em View
Design.
8 – De um clique sobre o Button1 para selecioná-lo.
9 – Na janela Properties, altere a propriedade Text do button1 para OK.
Se não localizar a janela Properties, clique em F4, ou no menu View, clique em
Properties Window.
10 – Altere também a propriedate Text do Label1 para Digite o seu nome
11 – Altere agora a propriedade Text do controle textBox1 para aqui.
Note que as propriedades modificadas na janela Properties ficam em negrito.
Assim você pode saber se elas estão com seu valor padrão ou não.
12 – Selecione o formulário clicando sobre ele.
Note que aparecem alguns marcadores envolta do formulário. Eles ajudam a
redimensionar o formulário.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 44
Curso Programando com C# e o Visual Studio .NET 2005
13 - Clique sobre o marcador central na parte de baixo do Form1 e mantendo o
botão pressionado arraste para cima.
Isso serve para os outros controles também, clique sobre os outros controles e note
os marcadores.
Vamos agora escrever o código para o nosso programa.
14 – No painel de código de um clique duplo sobre o Button1.
Note que ele vai diretamente para o painel de código e é criado automaticamente o
seguinte código.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 45
Curso Programando com C# e o Visual Studio .NET 2005
private void button1_Click(object sender, System.EventArgs e)
{
}
Tudo que for digitado dentro deste código será executado assim que o Button1 for
clicado quando o programa estiver executando.
15 - Digite o seguinte código:
Tenha atenção com esse código, ele deve ser digitado exatamente como se segue,
lembre-se que o C# é case-sensitive. É necessário também o ponto-e-virgula no
final da linha.
MessageBox.Show("Hello " + textBox1.Text);
Vai ficar assim:
private void button1_Click(object sender, System.EventArgs e)
{
MessageBox.Show("Hello " + textBox1.Text);
}
16 – Execute o programa.
Para executar o programa você pode clicar e F5, ou no menu Debug clicar em
Start Debugging.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 46
Curso Programando com C# e o Visual Studio .NET 2005
Automaticamente o Visual Studio .NET salva o programa, compila e o executa. A
seguinte janela aparece:
17 – Digite seu nome e clique em OK.
Uma janela aparece exibindo a mensagem “Hello seu-nome”.
18 - Clique em Ok para fechar a janela com a mensagem.
19 – Na janela executando o Form1 clique em fechar.
Lição 4 – Criando documentação usando XML e
cometários
Podemos facilitar o processo de documentação de nossos programas usando XML.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 47
Curso Programando com C# e o Visual Studio .NET 2005
Vamos fazer um exemplo pratico pra ver como isso é possível.
1 – Entre no Visual Studio .NET e crie uma Console Application chamada
Documentacao.
2 – No painel de código modifique o nome da classe de Program para
BemVindos, não pode haver espaços entre as palavras quando se nomeia uma
classe.
3 – Adicione o seguinte código dentro do namespace Documentacao:
/// <summary>
/// <remarks>
/// Este programa escreve "Hello World"
/// usando o método WriteLine da
/// Classe Syste.Console
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 48
Curso Programando com C# e o Visual Studio .NET 2005
/// The main entry point for the application.
/// </remarks>
/// </summary>
Vai ficar como a imagem abaixo:
4 – Dentro do método Main digite o código que escreve “Hello World” no prompt
de comando. Se tiver duvida consulte a lição 1.
5 – Na janela Solution Explorer clique sobre o arquivo Program.cs.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 49
Curso Programando com C# e o Visual Studio .NET 2005
6 – Na janela Properties, modifique o nome do arquivo Program.cs para
BemVindos.cs
Se você for verificar o nome do arquivo pelo Explorer do Windows verá que o nome
do arquivo foi realmente modificado.
Mudao o nome da classe não muda o nome do arquivo, é uma boa pratica sempre
mudar o nome do arquivo após a mudança do nome da classe.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 50
Curso Programando com C# e o Visual Studio .NET 2005
7 – Entre no prompt de comando. Qualquer duvida sobre isso visite a lição 2.
8 – Navegue até a pasta dos arquivos do projeto.
9 – Digite csc /doc:Hello.xml BemVindos.cs
Esse comando extrai os comentários XML inseridos junto com o código.
10 – Através do Explorer do Windows, vá até a pasta do programa e de um clique
duplo sobre o arquivo Hello.xml
Você vai visualizar o código XML com os comentários que inserimos no código no
Internet Explorer.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 51
Curso Programando com C# e o Visual Studio .NET 2005
Existe uma variedade enorme de tags XML que podem ser usadas na documentação
do código, iremos listar as mais usadas logo abaixo.
O comentário XML é sempre adicionado após barras triplas, ou seja, uma barra a
mais que usamos para comentar o código, como o exemplo abaixo:
/// <remarks>
/// Este programa escreve "Hello World"
/// usando o método WriteLine da
/// Classe Syste.Console
/// The main entry point for the application.
/// </remarks>
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 52
Curso Programando com C# e o Visual Studio .NET 2005
Abaixo segue uma lista das tags XML mais usadas. Lembre-se que com XML você
pode criar suas próprias tags.
TAG
<summary> … </summary>
PROPÓSITO
Para
uma
breve
descrição
de
uma
classe, método ou propriedade.
<remarks> … </remarks>
Para uma descrição mais detalhada.
<para> ... </para>
Permite delinear parágrafos dentro da
tag <remarks>
<list type="…"> … </list>
Permite usar marcadores para formatar
uma descrição. Os tipos de marcadores
podem ser “bullet”, “number” e “table”.
<example> … </example>
Para disponibilizar um exemplo de como
usar um método, propriedade ou outro
membro da biblioteca.
<code> … </code>
Para indicar que o texto incluído é
código da aplicação.
<c> … </c>
Para indicar que o texto incluído é
código da aplicação. É usada para linhas
de código que precisam ser separadas
da descrição.
<see cref="member"/>
Indica uma referencia a outro membro
ou campo. O compilador verifica se o
membro realmente existe.
<exception> … </exception>
Para fazer a descrição de uma exceção.
<permission> … </permission>
Para documentar a acessibilidade.
<param name="name"> … </param>
Para documentar um parâmetro de um
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 53
Curso Programando com C# e o Visual Studio .NET 2005
método.
<returns> … </returns>
Para documentar um valor e seu tipo
retornado de um método.
<value> … </value>
Para descrever uma propriedade.
Existe uma maneira mais fácil de gerar sua documentação XML, usando o Visual
Studio sem precisar do prompt de comando.
11 – Na janela Solution Explorer, clique com o botão direito do mouse e selecione
Properties, como a imagem seguinte.
12 – Na janela que se abre, clique na guia Build e marque a opção XML
Documentation file, como na próxima imagem.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 54
Curso Programando com C# e o Visual Studio .NET 2005
13 – No menu Build, clique em Build Solution ou pressione F6.
Seu arquivo de documentação é gerado. Você pode alterar o nome do arquivo que
será gerado na caixa de texto que segue a opção XML documentation file, pode
alterar também o caminho do local onde o arquivo será gerado. Por padrão ele tem
o mesmo nome do projeto e é criado na pasta bin\debug dentro do projeto.
Você pode agora ir clicar em Show All Files na janela Solution Explorer e
navegar até o local onde o arquivo XML foi criado para visualizá-lo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 55
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 2
Variáveis
Lição 5 – Entendo variáveis e tipos de dados
Antes de falarmos sobre os tipos de dados vamos conhecer um pouco mais da
plataforma .NET.
Uma aplicações desenvolvida utilizando uma linguagem de programação como
Delphi ou Visual Basic é executada encima do sistema operacional, ou seja, ela
acessa DLLs, APIs e outros recursos diretamente do sistema operacional.
Isso não acontece com o .NET, esse acessa seus recursos do .NET Framework. O
.NET Framework é um conjunto de DLLs que disponibiliza os recursos que podem
ser usados na plataforma .NET.
O objetivo do .NET Framework é simplificar o desenvolvimento de software. Alguns
dos seus benefícios são:
•
Baseado em padrões WEB: suporta a maioria das tecnologias disponíveis
para a Internet incluindo HTML, XML, SOAP, XSLT, XPath, e outros.
•
Modelo de aplicação unificado: as classes do .NET Framework estão
disponíveis para qualquer linguagem com suporte à plataforma.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 56
Curso Programando com C# e o Visual Studio .NET 2005
•
Fácil de se usar: o código é organizado hierarquicamente em namespaces e
classes. Os tipos de dados são unificados entre as linguagens compatíveis
com a plataforma. Vamos estudar melhor sobre os tipos de dados.
Namespaces e classes vão ser tratados no futuro.
•
Classes extensíveis: A hierarquia do .NET Framework não é oculta ao
desenvolvedor, você pode acessar e extender classes do .NET Framework
(menos as classes seladas) usando herança.
Você vai entender melhor os benefícios do .NET Framework durante o curso. Como
você pode ver ele é muito importante para a plataforma .NET.
Por sua vez, um dos principais componentes do .NET Framework é a CLR ou
Common
Language
Runtime.
A
CLR
fornece
vários
benefícios
para
o
desenvolvedor, tais como:
•
Tratamento de erros
•
Segurança
•
Depuração
•
Controle de versão
Estes benefícios estão disponíveis em qualquer linguagem criada para a CLR. Isto
quer dizer que a CLR pode servir a uma variedade de linguagens e pode oferecer
um conjunto comum de ferramentas para estas linguagens. A Microsoft criou o C#
e o VB .NET, como as principais linguagens para a CLR.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 57
Curso Programando com C# e o Visual Studio .NET 2005
Quando um compilador compila para a CLR, o código é chamado de código
gerenciado. Código gerenciado é simplesmente código que tira vantagem dos
serviços oferecidos pela CLR.
Quando você declara uma variável no C# você precisa determinar qual tipo de dado
será armazenado nela. O tipo de dado vai dizer quais valores são possíveis de se
armazenar nessa variável.
Quem define as regras para os tipos de dados como declaração, uso e
gerenciamento dos tipos é o CTS ou common type system que faz parte do CLR.
Através do CTS é possível o desenvolvimento em linguagens diferentes na mesma
plataforma e ter total integração entre elas, além disso, ele é responsável por
garantir o tipo de dado e aumentar o desempenho da execução.
Variáveis são espaços na memória do computador reservador para armazenar
dados.
A referencia aos dados de uma variável pode ser feita de duas maneiras:
1. Por valor, chamado de Value-Type.
2. Por referência, chamada de Reference-Type
A principal diferença entre os dois tipos é que quando você faz referencia a uma
variável Value-Type ela contém diretamente um dado, enquanto uma variável
Reference-Type contém uma referencia ao dado. Vamos analisar um pouco melhor
esses dois tipos de variaveis:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 58
Curso Programando com C# e o Visual Studio .NET 2005
Value-Type
•
Contém diretamente o dado.
•
Cada copia da variável contém uma copia do dado.
•
Operações em uma variável não afetam a sua cópia.
•
Exemplos
de
variáveis
Value-Type
são:
integers,
doubles,
floats,
e
structures.
Reference-Type
•
Armazenam uma referencia ao dado(conhecido como objetos)
•
Duas variáveis Reference-Type podem conter referencia a um mesmo
objeto.
•
Operações em uma afetam a outra.
•
Exemplos de Reference-Type são: strings, arrays, e classes.
Vamos aprender agora como declarar variáveis, seus principais tipos e como
atribuir e recuperar valores delas.
Lição 6 – Nomeando uma variável
A documentação do Microsoft .Net Framework da as seguintes recomendações para
a nomeação das variáveis:
•
Evite usar underline;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 59
Curso Programando com C# e o Visual Studio .NET 2005
•
Não crie variáveis que apenas se diferenciem apenas pela sua forma.
Exemplo: minhaVariavel e outra chamada MinhaVariavel;
•
Procure iniciar o nome com uma letra minúscula;
•
Evite usar todas as letras maiúsculas;
•
Quando o nome tiver mais que uma palavra, a primeira letra de cada
palavra após a primeira deve ser maiúscula (conhecido como notação
camelCase);
•
Não use notação Húngara.
Convenção PascalCasing
Para usar a convenção PascalCasing para nomear suas variáveis, capitalize o
primeiro caractere de cada palavra. Exemplo:
void InitializeData();
A microsoft recomenda usar o PascalCasing quando estiver nomeando classes,
métodos, propriedades, enumeradores, interfaces, constantes,
campos somente
leitura e namespaces.
Convenção camelCasing
Para usar esse tipo de convenção, capitalize a primeira letra de cada palavra menos
da primeira. Como o exemplo:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 60
Curso Programando com C# e o Visual Studio .NET 2005
int loopCountMax;
A Microsoft recomenda usar essa convenção na nomeação de variáveis que definem
campos e parâmetros.
Para
maiores
informações
sobre
convenção
de
nomes
pesquise
“Naming
Guidelines”, na documentação do Visual Studio.
Lição 7 – Palavras Reservadas do C#
A linguagem C# reserva setenta e cinco palavras para seu próprio uso. Estas
palavras são chamadas de palavras reservadas e cada uma tem um uso particular.
Palavras reservadas também não são permitidas como nome de variáveis.
Segue uma lista que identifica todas estas palavras:
abstract
as
base
Bool
break
byte
case
Catch
char
checked
class
Const
continue
decimal
default
Delegate
do
double
else
Enum
event
explicit
extern
false
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 61
Curso Programando com C# e o Visual Studio .NET 2005
finally
fixed
float
for
foreach
goto
if
implicit
in
int
interface
internal
is
lock
long
namespace
new
null
object
operator
out
override
params
private
protected
public
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
No painel de código do Visual Studio .NET as palavras reservadas são identificadas
pela cor de letra azul.
Lição 8 – Declarando variáveis
Antes de usar uma variável é necessário declará-la.
Quando declaramos uma variável, alocamos espaço para a mesma na memória do
computador. Sempre que declaramos uma variável precisamos dizer que tipo de
dado pode ser armazenado nela. O tipo de dado indica qual o tamanho do espaço
vai ser reservado para a variável.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 62
Curso Programando com C# e o Visual Studio .NET 2005
O C# pode armazenar diferentes tipos de dados: como inteiros, números de ponto
flutuante, textos e caracteres.
Declaramos especificando o tipo de dado seguido do nome da variável como no
exemplo:
int contador;
Esse exemplo declara uma variável chamada contador do tipo integer. Ou seja, ela
deverá armazenar números inteiros, mais a frente estudaremos melhor o que
armazenar em cada tipo de dado.
Podemos também declarar múltiplas variáveis de uma vez, fazemos isso da
seguinte maneira:
int contador, numeroCarro;
Estamos declarando nesse exemplo duas variáveis do tipo integer, uma chamada
contador e a outra numeroCarro.
Lição 9 – Atribuindo valor a variáveis
Depois de declarar sua variável você precisa atribuir um valor a ela. No C# você
não pode usar uma variável antes de colocar um valor nela, isso gera um erro de
compilação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 63
Curso Programando com C# e o Visual Studio .NET 2005
Exemplo de como atribuir um valor a uma variável:
int numeroFuncionario;
numeroFuncionario = 23;
Primeiro nós declaramos nossa variável do tipo integer. Depois atribuímos o valor
23 a ela. Entendemos pelo sinal de igual como recebe. Assim numeroFuncionario
recebe 23.
Podemos também atribuir um valor a variável quando a declaramos, dessa forma:
int numeroFuncionario = 23;
Isso faz à mesma coisa que o exemplo anterior, só que tudo em uma linha.
Mais um exemplo:
char letraInicial = ‘M’;
Lição 10 – Tipos de dados
A seguinte tabela mostra os tipos do C# com sua referencia no Framework.
Os tipos da tabela abaixo são conhecidos como tipos internos ou Built-in.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 64
Curso Programando com C# e o Visual Studio .NET 2005
C# Type
.NET Framework type
bool
System.Boolean
byte
System.Byte
sbyte
System.SByte
char
System.Char
decimal
System.Decimal
double
System.Double
float
System.Single
int
System.Int32
uint
System.UInt32
long
System.Int64
ulong
System.UInt64
object
System.Object
short
System.Int16
ushort
System.UInt16
string
System.String
Cada tipo no C# é um atalho para o tipo do Framework. Isso quer dizer que se
declararmos a variável desta forma:
string nome;
ou dessa forma
System.String nome;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 65
Curso Programando com C# e o Visual Studio .NET 2005
teremos o mesmo resultado. O atalho serve apenas para facilitar na hora de
desenvolver a aplicação.
A seguinte tabela mostra os tipos de variáveis e os valores possíveis de se
armazenar em cada uma delas.
C# Type
Valores possíveis de se armazenar
bool
Verdadeiro ou Falso (Valores booleandos)
byte
0 a 255 (8 bits)
sbyte
-128 a 127 (8 bits)
char
Um caractere (16 bits)
decimal
±1.0 × 10−28 a ±7.9 × 1028 (128 bits)
double
±5.0 × 10−324 a ±1.7 × 10308 (64 bits)
float
±1.5 × 10−45 a ±3.4 × 1038 (32 bits)
int
-2,147,483,648 a 2,147,483,647 (32 bits)
uint
0 a 4,294,967,295 (32 bits)
long
–9,223,372,036,854,775,808 a
9,223,372,036,854,775,807 (64 bits)
ulong
0 a 18,446,744,073,709,551,615 (64 bits)
object
Qualquer tipo.
short
-32,768 a 32,767 (16 bits)
ushort
0 a 65,535 (16 bits)
string
Seqüência de caracteres (16 bits por caractere)
Todos os tipos na tabela com exceção dos tipos object e string são conhecidos
como tipos simples.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 66
Curso Programando com C# e o Visual Studio .NET 2005
Para retornar o tipo de qualquer variável do C# você pode usar o método
GetType(); Como no exemplo:
Console.WriteLine(minhaVariavel.GetType());
Isso retornaria o tipo da variável minhaVariavel.
Lição 11 – Adicionando valor a uma variável
É muito comum precisarmos adicionar ou subtrair valores de uma variável usando
no calculo o valor que já esta armazenado na mesma.
O código seguinte declara uma variável do tipo integer chamada contador e
armazena o valor 2 nesta variável, depois incrementa o valor 40:
int contador;
contador = 2;
contador = contador + 40;
No final do código acima a variável contador tem qual valor?
A resposta é 42, claro, criamos a variável, adicionamos o valor 2 nela e após,
pegamos o valor dela (que era 2) e adicionamos 40, e armazenamos o valor na
mesma.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 67
Curso Programando com C# e o Visual Studio .NET 2005
Preste atenção na seguinte linha de código:
contador = contador + 40;
Perceba que para somar o valor a variável precisamos repetir o nome da variável.
Podemos fazer da seguinte forma também em C#:
contador += 40;
Isso teria o mesmo resultado e é uma maneira mais elegante.
Você pode subtrair também valores, como o exemplo:
contador -= 23;
Isso subtrairia 23 do valor da variável.
Na verdade você pode fazer isso com todos os operadores aritméticos, como
multiplicação e divisão também. Você vai aprender sobre operadores no próximo
capitulo.
Para saber mais você pode consultar a documentação do Visual Studio e procurar
por “assignment”.
Embora não tenhamos feito nenhum exercício até aqui neste capitulo você
aprendeu como declarar uma variável, de que forma nomear as variáveis, quais as
palavras que não podem ser usadas na nomeação de variáveis e quais os tipos de
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 68
Curso Programando com C# e o Visual Studio .NET 2005
dados e valores que eles suportam. Os exercícios sobre esse conteúdo serão feitos
sempre, já que sempre faremos uso de variáveis em nossos programas, assim fique
tranqüilo aos pouco isso será bem familiar a você.
Lição 12 – Operadores
Operadores Aritméticos:
O C# suporta os símbolos aritméticos que todos nós conhecemos para as operações
aritméticas básicas como adição (+) e subtração (-), ele utiliza o asterisco (*) para
multiplicação e barra pra frente (/) para divisão. Esses símbolos são chamados
operadores, e “operam” os valores das variáveis. Exemplo:
long salario;
salario = 500 * 20;
A expressão acima multiplica 500 por 20 e armazena o resultado na variável
salario.
Entretanto você não pode usar os operadores para qualquer tipo de dado. Os
operadores matemáticos, por exemplo, só podem ser usados para os tipos char,
int, long, float, double e decimal. Eles não podem ser usados para string e bool.
Exemplo:
Console.WriteLine(“Londrina” – “São Paulo”);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 69
Curso Programando com C# e o Visual Studio .NET 2005
Isso vai gerar um erro porque você não pode subtrair uma string de outra.
Console.WriteLine(“43” – “11”);
Isso também vai gerar um erro, porque valores entre aspas são sempre strings,
para efetuar a subtração o correto é:
Console.WriteLine(43 – 11);
Vamos fazer um exemplo pratico de como utilizar os operadores.
1 – Crie um novo projeto no Visual Studio do tipo Windows Application chamado
Operadores.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 70
Curso Programando com C# e o Visual Studio .NET 2005
2 – Arraste para o Form1 os seguintes controles:
•
3 Label
•
3 TextBox
•
1 Button
•
1 GroupBox
•
5 RadioButton
3 – Organize-os como a figura abaixo:
4 – Configure as propriedades dos controles conforme a tabela abaixo:
Controle
Propriedade
Valor
Label1
Text
Valor1
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 71
Curso Programando com C# e o Visual Studio .NET 2005
Label2
Text
Valor2
Label3
Text
Resultado
Button
Text
Calcular
GroupBox
Text
Operador
RadioButton1
Text
+ Adição
RadioButton2
Text
- Subtração
RadioButton3
Text
* Multiplicação
RadioButton4
Text
/ Divisão
RadioButton5
Text
% Resto Divisão
Vai ficar como a figura abaixo:
5 – Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 72
Curso Programando com C# e o Visual Studio .NET 2005
Clique na TextBox1, pressione a tecla Tab do teclado, verifique que conforme você
clica na tecla ele passa de um controle a outro.
Clique sobre os operadores, veja que você só pode selecionar um, essa é uma
característica do controle RadioButton que não tinha sido usado até aqui. A
GroupBox agrupa todos os RadioButtons dentro dela de forma que apenas um
deles pode ser selecionado.
6 – Finalize a execução, para isso você pode simplesmente fechar a janela do
Form1 ou clicar no botão Stop Debugging na barra de ferramentas.
7 - Vamos agora digitar o código que efetuará os cálculos, esse código vai ser
executado quando o botão Calcular for clicado. De um clique duplo sobre o
Button1 para digitarmos o seguinte código. (Atenção na hora de digitar, lembre-se
que o C# é case-sensitive ou seja, diferencia maiúsculas de minúsculas).
long primeiroValor, segundoValor, resultado;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 73
Curso Programando com C# e o Visual Studio .NET 2005
primeiroValor = int.Parse(textBox1.Text);
segundoValor = int.Parse(textBox2.Text);
if (radioButton1.Checked)
{
resultado = primeiroValor + segundoValor;
textBox3.Text = resultado.ToString();
}
else if (radioButton2.Checked)
{
resultado = primeiroValor - segundoValor;
textBox3.Text = resultado.ToString();
}
else if (radioButton3.Checked)
{
resultado = primeiroValor * segundoValor;
textBox3.Text = resultado.ToString();
}
else if(radioButton4.Checked)
{
resultado = primeiroValor / segundoValor;
textBox3.Text = resultado.ToString();
}
else if(radioButton5.Checked)
{
resultado = primeiroValor % segundoValor;
textBox3.Text = resultado.ToString();
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 74
Curso Programando com C# e o Visual Studio .NET 2005
Digitamos nosso código dentro do procedimento:
private void button1_Click(object sender, System.EventArgs e)
{
}
Esse procedimento é executado sempre que o Button1 é clicado. Sendo assim
quando o botão é clicado, primeiro:
Declaramos as variáveis primeiroValor, segundoValor e resultato do tipo Long.
O tipo Long é usado aqui porque armazena uma grande variedade de números.
Perceba que declaramos as três variáveis em apenas uma linha de código.r.
long primeiroValor, segundoValor, resultado;
Depois atribuímos os valores das caixas de texto as variáveis primeiroValor e
segundoValor.
primeiroValor = int.Parse(textBox1.Text);
segundoValor = int.Parse(textBox2.Text);
Como o valor que esta na caixa de texto é do tipo string convertemos para int
usando int.Parse. Você pode usar o método Parse sempre que precisar converter
um tipo de dados em outro. Para usa-lo digite o tipo do dado ponto Parte como o
exemplo acima ou o seguinte exemplo:
long.Parse(textBox2.Text);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 75
Curso Programando com C# e o Visual Studio .NET 2005
Voltando ao nosso exemplo, depois de atribuir os valores as variáveis vamos
verificar qual operação executar, para isto usamos a propriedade checked de cada
RadioButton.
if (radioButton1.Checked)
ou
else if (radioButton2.Checked)
Se o valor da propriedade Checked do RadioButton for True quer dizer que ele esta
selecionado,
então
executamos
o
calculo
correspondente
ao
RadioButton
selecionado e atribuímos o resultado a variável resultado.
Agora atribuímos o valor da variável resultado à propriedade Text do textbox3
para que seja exibida na tela.
textBox3.Text = resultado.ToString();
Perceba que precisamos converter o valor da variável resultado para String.
Fizemos isto utilizando o método ToString. Você pode usar o método ToString
sempre que precisar converter um tipo de dados para string.
8 – Execute o programa.
9 – Digite 9 para o valor1 e 2 para o valor2, selecione adição e clique em calcular.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 76
Curso Programando com C# e o Visual Studio .NET 2005
Faça testes com os outros operadores.
Subtração:
Multiplicação:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 77
Curso Programando com C# e o Visual Studio .NET 2005
Divisão, perceba que ele retorna um resultado em inteiro, o numero inteiro mais
próximo do resultado:
Resto da Divisão, perceba que ele retorna o resto da divisão, 9 dividido por dois
resulta em 4 com resto 1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 78
Curso Programando com C# e o Visual Studio .NET 2005
10 – Pare a aplicação.
Precedência de Operadores:
Operações dentro dos parênteses são sempre executadas primeiro, como nas
operações matemáticas.
Em C#, operadores multiplicativos (*, /, %) tem precedência sobre os aditivos (+,
-).
Vamos dar a ordem de precedência da seguinte expressão:
2+3*4
2+3*4
2 + 12
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 79
Curso Programando com C# e o Visual Studio .NET 2005
14
Para efetuar a soma primeiro podemos utilizar os parênteses:
(2 + 3) * 4
(2 + 3) * 4
5*4
20
Perceba que a ordem de precedência altera o valor do resultado, por isso devemos
ter atenção com a precedência.
Nesta lição aprendemos a fazer operações aritméticas em nossos programas, alem
disso aprendemos sobre precedência de operadores.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 80
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 3
Métodos e Escopo
Lição 13 – Entendento métodos
Método é uma seqüência nomeada de instruções. Cada método tem um nome e um
corpo. O corpo contem as instruções que vão ser executadas quando o método for
chamado. O nome do método deve ajudar a identificar seu propósito, ex:
CalcularImpostoVenda.
A maioria dos métodos recebe dados, processa-os e retorna a informação ou o
resultado do processamento. Método é um mecanismo fundamental e poderoso.
Especificando a sintaxe de declaração de um método:
tipoDeRetorno nomeDoMetodo ( listaDeParamentros
opcional
)
{
// corpo do método
}
•
tipoDeRetorno – é o tipo de dado que vai ser retornado pelo método após sua
execução. Pode ser o nome de qualquer tipo como int ou string. Se o seu
método não for retornar valor algum, você precisa usar a palavra reservada
void aqui, especificando que o método não retorna nada.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 81
Curso Programando com C# e o Visual Studio .NET 2005
•
nomeDoMetodo – é o nome que vai ser usado para chamar o método. Este
nome deve seguir as mesmas recomendações usadas nos nomes das variáveis.
Procure usar notação camelCasing para nomear os métodos e também procure
utilizar um verbo na primeira palavra do nome, para ajudar a identificar o que o
método faz.
•
ListaDeParametros – descreve o tipo e os nomes das informações opcionais que
o método recebe. Você escreve os parâmetros dentro dos parênteses como se
fosse declarar variáveis: nome do tipo seguido pelo nome do parâmetro. Se o
seu método tiver mais que um parâmetro, separe-os com vírgula.
•
Corpo do método – linhas de código que vão ser executadas quando o método é
chamado.
O C# não suporta os métodos globais, utilizados por programadores Visual Basic, C
e C++.
Abaixo um exemplo de um método chamado AdicionarValores que retorna um
numero inteiro (int) e recebe dois números inteiros como paramentos.
int adicionarValores (int numeroPequeno, int numeroGrande)
{
//...
// corpo do método deve ser feito aqui
//...
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 82
Curso Programando com C# e o Visual Studio .NET 2005
Abaixo um segundo exemplo, de um método chamado mostrarResultado que não
retorna nenhum valor, e recebe um simples parâmetro chamado pergunta do tipo
int.
void mostrarResultado (int pergunta)
{
// ...
}
Lembre-se de usar a palavra reservada void quando o método não for retornar
nada.
Escrevendo declarações que retornam valores:
Se você quer que seu método retorne uma informação (em outras palavras que
retorne um tipo e não um void), você precisa escrever um código de retorno dentro
do método.
Para isso você usa a palavra reservada return, seguida da expressão que calcula o
valor a ser retornado. Atenção, porque o resultado da expressão deve ser do
mesmo tipo que o especificado como tipoDeRetorno do método, senão o programa
não vai compilar.
Por exemplo:
int adicionarValores (int numeroPequeno, int numeroGrande)
{
//...
return numeroPequeno + numeroGrande;
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 83
Curso Programando com C# e o Visual Studio .NET 2005
Lembre-se do ponto-e-vírgula ao final de cada instrução.
O retorno do método deve estar no final do método porque ele causa a finalização
do método. Qualquer código depois da linha que faz o retorno não vai ser
executado.
Se você não quer que seu método retorne informação alguma (do tipo void), você
pode uma variação da palavra reservada return para causar o encerramento
imediato do método, para isso digite return seguido de ponto-e-vírgula.
Por exemplo:
void mostrarResultado (int pergunta)
{
...
if (...)
return;
...
}
Se o seu método não precisar retornar nada você pode simplesmente omitir o
return, porque o método vai ser finalizado automaticamente quando a ultima linha
de código do corpo for executada.
Chamando métodos:
Métodos existem para serem chamados. Você chama um método pelo seu nome
para ele executar uma tarefa. Se esse método precisa de informações para realizar
sua tarefa (parâmetros), você precisa enviar essas informações pra ele. Se o
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 84
Curso Programando com C# e o Visual Studio .NET 2005
método retornar uma informação, você precisa ter uma forma de receber essa
informação, como uma variável, por exemplo.
Especificando a sintaxe para se chamar um método:
nomeDoMetodo (listaDeArgumentos
•
opcional)
nomeDoMetodo – precisa ser exatamente igual ao nome do método que você
esta chamando, lembre-se que o C# é case-sensitive ou seja, diferencia
maiúsculas de minúsculas.
•
listaDeArgumentos – informações adicionais que o método aceita, você precisa
passar um valor para cada parâmetro e este valor precisa ser compatível o tipo
correspondente ao parâmetro. Se o método que você esta chamando tiver dois
ou mais parâmetros, você precisa separar os valores com vírgula.
Importante: Você precisa escrever os parênteses ao final de cada método, mesmo
que lê não tiver parâmetro algum.
Por exemplo, lembre-se do método adicionarValores:
int adicionarValores (int numeroPequeno, int numeroGrande)
{
//...
return numeroPequeno + numeroGrande;
}
Este método tem dois parâmetros entre os parênteses, para chamá-lo, faça assim:
adicionarValores(39,3)
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 85
Curso Programando com C# e o Visual Studio .NET 2005
Esta é a maneira correta de chamar o método, se você tentar das seguintes formas
não vai conseguir:
adicionarValores
// Falta parênteses
adicionarValores()
// Falta argumentos
adicionarValores(39)
// Falta um argumento
adicionarValores(“39”, “3”)
// Tipos errados
O método adicionarValores retorna um numero inteiro. Este valor inteiro pode ser
usado em qualquer lugar que uma variavel int puder ser usada.
Por exemplo:
resultado = adicionarValores(39,3);
mostrarResultado(adicionarValores(39,3));
No primeiro exemplo atribuímos o retorno a uma variável chamada resultado.
No segundo atribuímos o resultado a outro método, que vai utilizar este resultado
como parâmetro para sua execução.
Lição 14 – Entendento Escopo
Você viu que pode criar uma variável dentro de um método. A variável é criada na
código que a define, e outros código no mesmo método que vêm depois podem
usar a variável. Em outras palavras, uma variável pode ser usada só em certos
lugares depois de que ter sido criada. Uma vez que o método terminou, a variável
desaparece completamente.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 86
Curso Programando com C# e o Visual Studio .NET 2005
Se uma variável pode ser usada em um local particular em um programa, ela
parece estar no escopo daquele local. O escopo de uma variável é simplesmente a
região do programa em que ela é utilizável. O escopo se aplica a métodos como
também a variáveis. O escopo de uma variável é ligado ao local da sua declaração
que introduz a mesma no programa, como você aprenderá agora.
Criando escopo local com um método.
As chaves determinam onde começa e onde termina o corpo do método. Elas
também determinam o escopo do método. Qualquer variável criada dentro do corpo
do método faz parte do escopo do método. Estas variáveis são chamadas de
variáveis locais porque são locais ao método onde são declaradas. Elas não
podem ser usadas no escopo nenhum outro método, por isso você não pode usar
variáveis locais para armazenar informações entre métodos. Quando um método
acaba sua execução ele finaliza as variáveis que ele criou.
Por exemplo:
class Exemplo
{
void método()
{
int variavel;
...
}
void outroMetodo()
{
variavel = 42;
// isso gera um erro de compilação
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 87
Curso Programando com C# e o Visual Studio .NET 2005
}
}
O erro mostrado acima é porque a variável foi criada dentro de um método
diferente da qual esta sendo usada.
Criando escopo de classe com uma classe:
As chaves determinam onde começa e onde termina o corpo da classe e
determinam seu escopo. Assim sendo, qualquer variável que você criar dentro do
corpo da classe (mas que não estejam dentro do método), fazem parte do seu
escopo. Em C# o nome correto desse tipo de variável é campo. Em contraste as
variáveis locais você pode usar os campos para armazenar informações entre os
métodos.
Por exemplo:
class Exemplo
{
int campo;
void método()
{
campo = 42;
...
}
void outroMetodo()
{
campo = 44;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 88
Curso Programando com C# e o Visual Studio .NET 2005
}
}
Perceba que criamos a variável dentro da classe.
Em um método você precisa declarar uma variável antes de usá-la. Campos são
diferentes, um método pode usar um campo antes de ser definido algum valor para
ele.
Lição 15 – Criando e Chamando Métodos
1 – Crie uma aplicação no Visual Studio .NET do tipo Console Application
chamada Metodo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 89
Curso Programando com C# e o Visual Studio .NET 2005
2 – No painel de código crie digite o seguinte código que cria o método lerDouble
dentro da classe Program.
public double lerDouble(string inicie)
{
Console.Write(inicie);
string linha = Console.ReadLine();
return double.Parse(linha);
}
Vai ficar assim nosso método:
Esse método escreve no console o texto que é enviado para ele como parâmetro.
Depois armazena na variável linha o numero digitado pelo usuário e o retorna.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 90
Curso Programando com C# e o Visual Studio .NET 2005
3 – No menu Build clique em Build Metodo ou pressione Ctrl+Shift+B.
Verifique se compila sem nenhum erro.
4 - Vamos criar agora um outro método com as seguintes características:
Digite o seguinte código, você pode digitá-lo em qualquer local desde que esteja
dentro da Classe no nosso caso a Program.
public int lerInteiro(string inicio)
{
Console.Write(inicio);
string linha = Console.ReadLine();
return int.Parse(linha);
}
Esse método faz a mesma coisa que o método lerDouble, só que retorna uma
integer (inteiro).
Esta ficando assim nosso código:
using System;
using System.Collections.Generic;
using System.Text;
namespace Metodo
{
class Program
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 91
Curso Programando com C# e o Visual Studio .NET 2005
{
public double lerDouble(string inicie)
{
Console.Write(inicie);
string linha = Console.ReadLine();
return double.Parse(linha);
}
public int lerInteiro(string inicio)
{
Console.Write(inicio);
string linha = Console.ReadLine();
return int.Parse(linha);
}
static void Main(string[] args)
{
}
}
}
Verifique se os dois métodos estão dentro do escopo da classe Program.
5 – Novamente menu Build clique em Build Metodo ou pressione Ctrl+Shift+B.
E verifique se ocorre erros, se ocorrer verifique seu código comparando-o ao acima.
Lembre-se novamente que o C# é case-sensitive, ou seja, diferencia maiúsculas de
minúsculas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 92
Curso Programando com C# e o Visual Studio .NET 2005
6 – Vamos criar mais um método, este método possui mais de um parâmetro:
Segue as características do nosso método:
public double calcular(double taxaDiaria, int dias)
{
return taxaDiaria * dias;
}
Esse método retorna a multiplicação dos dois parâmetros que são enviados para
ele.
7 – Nosso ultimo método tem as seguintes especificações:
public void escrever(double taxa)
{
Console.WriteLine("A taxa é: {0}", taxa * 1.1);
}
Lembre que os métodos do tipo void não retornam nada.
Esse método escreve no console a multiplicação do parâmetro que é enviado para
ele com 1.1
Esta ficando assim nosso código:
using System;
using System.Collections.Generic;
using System.Text;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 93
Curso Programando com C# e o Visual Studio .NET 2005
namespace Metodo
{
class Program
{
public double lerDouble(string inicie)
{
Console.Write(inicie);
string linha = Console.ReadLine();
return double.Parse(linha);
}
public int lerInteiro(string inicio)
{
Console.Write(inicio);
string linha = Console.ReadLine();
return int.Parse(linha);
}
public double calcular(double taxaDiaria, int dias)
{
return taxaDiaria * dias;
}
public void escrever(double taxa)
{
Console.WriteLine("A taxa é: {0}", taxa * 1.1);
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 94
Curso Programando com C# e o Visual Studio .NET 2005
static void Main(string[] args)
{
}
}
}
8 – Clique em Build Metodo no menu Build para verificar se compila
corretamente. Tudo certo? Vamos usar os métodos que criamos.
Chamando Métodos
Podemos chamar métodos dentro de métodos, como faremos a seguir.
9 – Crie um novo método que não retorna nada, ou seja, do tipo void. De o nome
dele de Executar
O código do nosso novo método deve ficar assim:
public void executar()
{
double taxadiaria = lerDouble("Digite a taxa diaria: ");
int dias = lerInteiro("Digite o numero de dias: ");
escrever(calcular(taxadiaria,dias));
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 95
Curso Programando com C# e o Visual Studio .NET 2005
Na primeira linha de código criamos uma variável do tipo double e atribuímos a ela
o método lerDouble.
Na segunda linha criamos uma variável do tipo int e atribuímos a ela o método
lerInteiro.
Na terceira linha de código chamamos o método escrever e passamos para ele
como parâmetro o método calcular.
10 – No método Main (primeiro método executado pelo programa) digite o
seguinte código:
(new Class1()).executar();
Isso vai executar o método executar assim que o programa for iniciado
O método Main vai ficar assim:
static void Main(string[] args)
{
(new Program()).executar();
}
11 – Pressione Ctrl+F5 para executar o programa.
O Visual Studio compila o programa e o executa. Uma janela console aparece.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 96
Curso Programando com C# e o Visual Studio .NET 2005
12 – Para taxa diária digite 315 e pressione Enter.
13 – Para numero de dias digite 15 e pressione Enter.
O programa vai escrever a seguinte mensagem no console:
A taxa é: 5197,5
14 – Pressione qualquer tecla para retornar ao Visual Studio.
Vou digitar o código fonte todo utilizado para você poder verificar caso haja algum
problema e vamos depurar nosso programa para entender melhor como ele
funciona.
using System;
using System.Collections.Generic;
using System.Text;
namespace Metodo
{
class Program
{
public double lerDouble(string inicie)
{
Console.Write(inicie);
string linha = Console.ReadLine();
return double.Parse(linha);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 97
Curso Programando com C# e o Visual Studio .NET 2005
}
public int lerInteiro(string inicio)
{
Console.Write(inicio);
string linha = Console.ReadLine();
return int.Parse(linha);
}
public double calcular(double taxaDiaria, int dias)
{
return taxaDiaria * dias;
}
public void escrever(double taxa)
{
Console.WriteLine("A taxa é: {0}", taxa * 1.1);
}
public void executar()
{
double taxadiaria = lerDouble("Digite a taxa diaria: ");
int dias = lerInteiro("Digite o numero de dias: ");
escrever(calcular(taxadiaria, dias));
}
static void Main(string[] args)
{
(new Program()).executar();
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 98
Curso Programando com C# e o Visual Studio .NET 2005
}
}
}
Visual Studio .NET depurador
O depurador ou debug é um programa desenvolvido para ajudar o programador na
verificação e correção de erros. Ele vem embutido no Visual Studio e vamos utilizálo para compreender melhor como funciona nosso programa, ele permite a
execução do programa passo-a-passo.
15 – Localize no código o método executar.
16 – Mova o mouse a primeira linha de código do método executar. É a seguinte
linha:
double taxadiaria = lerDouble("Digite a taxa diaria: ");
17 – Clique com o botão direito do mouse sobre ela, no menu que se abre clique
em Run To Cursor.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 99
Curso Programando com C# e o Visual Studio .NET 2005
O programa é executado até chegar nessa linha de código. Neste momento a
execução é pausada e uma seta amarela indica que chegou à linha selecionada.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 100
Curso Programando com C# e o Visual Studio .NET 2005
18 – Na barra de ferramentas clique em Step Into.
A linha de execução pula para a primeira linha de código do método lerDouble.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 101
Curso Programando com C# e o Visual Studio .NET 2005
Como vimos no método executar nossa primeira linha de código cria uma variável
do tipo Double e atribui a ela o resultado do método lerDouble. Quando essa
linha de código é executada o método lerDouble é chamado e o resultado do seu
código vai ser atribuído a variável taxaDiaria, se a variavel for de um tipo
diferente do tipo que o método vai retornar então temos um erro.
19 – Na barra de ferramentas debug clique em Step Out.
O programa vai exibir no console a mensagem “Digite a taxa diária: ”
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 102
Curso Programando com C# e o Visual Studio .NET 2005
20 – Digite 315 e pressione Enter.
O controle retorna ao Visual Studio e a seta amarela fica sobre a linha que chama o
método lerDouble no método executar. Ou seja, ele executou o método
lerDouble e voltou para o método executar.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 103
Curso Programando com C# e o Visual Studio .NET 2005
21 – Clique novamente em Step Into.
A seta se move para a segunda linha de código do método executar.
22 – Clique novamente em Step Into.
A seta se move agora para a primeira linha de código do método lerInteiro.
23 – Clique em Step Out.
24 – Digite 15 e pressione Enter.
A seta volta agora para a segunda linha de código do método executar.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 104
Curso Programando com C# e o Visual Studio .NET 2005
25 – Clique em Step Into.
A seta se move para a terceira linha de código do método executar.
26 – Clique em Step Into.
A seta se move para a primeira linha de código do método calcular.
27 – Clique em Step Out.
A seta volta para a terceira linha de código do método executar.
28 – Clique em Step Into.
Perceba que agora a seta se move para a primeira linha de código do método
escrever. Isso aconteceu porque na seguinte linha de código chamamos um
método e passamos como parâmetro para ele um outro método.
escrever(calcular(taxadiaria,dias));
Aqui o método escrever recebe como parâmetro o método calcular, antes de ser
executado o método escrever é executado o método calcular, seu resultado então
é enviado ao método escrever para ser processado.
29 – Clique agora em Step Out.
O cursor se move para o fim do método executar. O resultado do programa é
exibido na tela conforme a figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 105
Curso Programando com C# e o Visual Studio .NET 2005
Parabéns, você escreveu métodos e os chamou com sucesso, alem disso usou o
depurador do Visual Studio .NET.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 106
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 4
Estruturas de Decisão
Lição 16 – Entendendo as Estruturas de Decisão
A ESTRUTURA DE DECISÃO sem dúvida, é a mais utilizada na programação. O
objetivo é identificar o conteúdo de uma condição e direcionar o fluxo do programa
para um determinado cálculo, rotina, desvio, função, etc.
Primeiramente vamos entender o que é uma EXPRESSÃO CONDICIONAL. Esta é
uma expressão que sempre retorna um valor boleano, ou seja, VERDADEIRO ou
FALSO.
Exemplo:
Preço é menor que 100.
Se preço for menor que 100 então o resultado da expressão acima é VERDADEIRO.
Caso contrario o resultado é FALSO.
Você pode usar os seguintes operadores para fazer comparações em C#:
(SUPONHA QUE A VARIAVEL SALARIO TENHA O VALOR 1200)
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 107
Curso Programando com C# e o Visual Studio .NET 2005
OPERADOR
QUER DIZER
EXEMPLO
RESULTADO
==
Igual a
Salario == 100
FALSO
!=
Diferente de
Salario != 100
VERDADEIRO
>
Maior que
Salario > 100
VERDADEIRO
<
Menor que
Salario < 100
FALSO
>=
Maior ou igual a
Salario >= 100
VERDADEIRO
<=
Menor ou igual a
Salario <= 100
FALSO
Então a expressão que usamos no exemplo acima ficaria assim:
Preço < 100
Agora que você já sabe o que é uma expressão condicional vamos estudar o que é
uma ESTRUTURA DE DECISÃO.
Uma ESTRUTURA DE DECISÃO nada mais é que do que um bloco de código que
utiliza as expressões condicionais para tomar decisões que orientam qual código
deve ser executado.
Lição 17 – Usando o if
A primeira estrutura de decisão que iremos estudar é o IF, veja a sintaxe a seguir:
if ( expressãocondicional )
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 108
Curso Programando com C# e o Visual Studio .NET 2005
{
bloco-de-codigo1
}
else
{
bloco-de-codigo2
}
Se o resultado da expressão condicional for VERDADEIRO então o bloco-de-codigo1
será executado, se a expressão for FALSO, então o bloco-de-codigo2 será
executado.
Se o bloco-de-codigo1 e bloco-de-codigo2 for apenas uma linha de código não é
necessário usar os colchetes, como nos exemplos abaixo.
Veja o seguinte exemplo:
double Salario = 1200;
if (Salario > 1000)
Salario *= 1.1;
Existe uma variável chamada Salario que está definida e contém o valor 1200.
Como toda condição retorna apenas verdadeiro ou falso, É verificado se o
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 109
Curso Programando com C# e o Visual Studio .NET 2005
valor é maior que 1000, e caso seja verdadeiro será somado 10% ao Salario. Se
Salario for menor que 1000 nada será executado.
Vamos a mais alguns exemplos para facilitar o entendimento.
double Salario = 1200;
if (Salario < 500)
Salario += 50;
else
Salario += 100;
Aqui é verificado se o valor é menor que 500 e dependendo da condição é somado
50 ou 100, pois há o Else. Então se a variável for menor que 500 adicionamos nela
o valor 50, senão adicionamos 100.
double Salario = 1200;
if (Salario < 500)
Salario += 50;
else if ((Salario >= 500) && (Salario < 2000))
Salario += 100;
else
Salario += 250;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 110
Curso Programando com C# e o Visual Studio .NET 2005
Já no exemplo acima existem 3 condições, onde o primeiro IF soma 50, o segundo
100 e o ELSE 250. O Else sempre é executado quando nenhuma expressão é
verdadeira.
É possível avaliar diversos else ifs com uma determinada expressão. Como no
exemplo abaixo:
double Salario = 1200;
if (Salario < 500)
Salario += 50;
else if ((Salario >= 500) && (Salario < 600))
Salario += 100;
else if ((Salario >= 500) && (Salario < 700))
Salario += 110;
else if ((Salario >= 500) && (Salario < 800))
Salario += 120;
else
Salario += 250;
Perceba que no bloco de código acima usamos o &&.
O && é usado quando precisamos testar mais de uma expressão condicional.
Exemplo:
else if ((Salario >= 500) && (Salario < 600))
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 111
Curso Programando com C# e o Visual Studio .NET 2005
Nesta linha testamos se o Salario é maior ou igual a 500 e o Salario é menor que
600.
Então se o Salario for 553 a expressão acima é VERDADEIRA, caso contrario é
FALSA.
O && é conhecido como um OPERADOR LÓGICO, temos quatro deles como mostra
a tabela a seguir:
OPERADOR LÓGICO
QUER DIZER
&& (And)
Se duas expressões condicionais forem
verdadeiras o resultado é verdadeiro.
|| (Or)
Se qualquer expressão condicional é
verdadeira então o resultado é
verdadeiro.
! (Not)
Se a expressão condicional for falsa o
resultado é verdadeiro. Se a expressão
condicional for verdadeira o resultado é
falso.
Algumas expressões complexas podem exigir mais de um operador lógico. A
seqüência de execução neste tipo de expressão é primeiro, os operadores
matemáticos, depois os operadores de comparação e só então os operadores
lógicos.
Vamos a alguns exemplos de como utilizar os operadores lógicos:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 112
Curso Programando com C# e o Visual Studio .NET 2005
EXPRESSÃO LÓGICA
RESULTADO
Veiculo = “Bicicleta” && Preço < 300
Verdadeiro (Se as duas condições forem
verdadeiras)
Veiculo = “Carro” || Preço < 500
Verdadeiro (Se uma das condições
forem verdadeiras)
! Preço < 100
Verdadeiro (Se a condição for falsa)
Vamos fazer um programinha que valida o usuário, verificando se é ele mesmo
através do seu nome e senha.
1 – Entre no Visual Studio e crie uma aplicação chamada EstruturaDeDecisao do
tipo Windows Application.
2 – Arraste para o Form os seguintes controles:
2 - Label
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 113
Curso Programando com C# e o Visual Studio .NET 2005
2 – TextBox
1 – Button
3 – Mude as propriedades dos controles como a tabela abaixo:
Controle
Propriedade
Valor
Label1
Text
Nome
Label2
Text
Senha
Textbox1
Text
Textbox2
Text
Button1
Text
Validar
4 – Organize-os para ficarem assim:
5 – De um clique duplo no button1 e digite o seguinte código:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 114
Curso Programando com C# e o Visual Studio .NET 2005
string Nome = textBox1.Text;
string Senha = textBox2.Text;
if ((Nome == "Moroni") && (Senha == "123"))
MessageBox.Show("Bem Vindo Moroni");
else
{
MessageBox.Show("Usuario Invalido");
Close();
}
Você pode substituir o valor do nome para o seu nome e sua senha.
Perceba que tivemos que abrir e fechar colchetes ( {} ) depois do else,
sempre temos que fazer isso quando tivermos mais que uma linha de
código, isso se aplica ao else, e também depois do if, se tivéssemos mais
de uma linha de código no bloco de código acima teríamos que fazer o
mesmo.
6 – Execute o programa.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 115
Curso Programando com C# e o Visual Studio .NET 2005
7 – Digite Moroni em nome (ou seu nome) e a senha 123.
8 – Clique em validar.
É executado o seguinte código:
MessageBox.Show("Bem Vindo Moroni");
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 116
Curso Programando com C# e o Visual Studio .NET 2005
Fazendo com que a seguinte mensagem apareça.
9 – Clique em Ok.
10 – Digite outro valor qualquer na caixa de texto e clique em OK.
E executado o seguinte código:
MessageBox.Show("Usuario Invalido");
Close();
Fazendo com que a seguinte mensagem apareça.
E que o programa seja encerrado.
Em resumo:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 117
Curso Programando com C# e o Visual Studio .NET 2005
Declaramos duas variáveis e demos as elas os valores dos controles de texto.
Depois testamos se o valor do nome era Moroni e a Senha 123, você pode
substituir o valor para o seu nome e sua senha. Se o resultado da expressão for
verdadeira então ele da a mensagem de bem vindo, caso contrario ele da a
mensagem de usuário invalido e sai do programa.
Lição 18 – Usando o switch
A segunda estrutura de decisão que iremos estudar é conhecida como switch.
Essa estrutura de decisão seleciona o código a ser executado baseado no valor de
uma expressão.
A sintaxe é a seguinte:
switch (testexpression)
{
case constant-expression:
statements
break:
default:
statements
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 118
Curso Programando com C# e o Visual Studio .NET 2005
O funcionamento ocorre da seguinte maneira: a expressão é obtida no switch e
para cada Case existe uma condição a ser validada. Caso o Case seja verdadeiro,
então a linha ou o bloco de código é executado. Se nenhum dos Cases for válido,
então default é executado. O default é opcional e você pode ter quantos Cases for
necessário. A cada Case é preciso declarar o break, senão o programa
continua avaliando todos os Cases.
Veja o exemplo:
int diaDaSemana = 3;
switch (diaDaSemana)
{
case 1:
MessageBox.Show("Domingo");
break;
case 2:
MessageBox.Show("Segunda-Feira");
break;
case 3:
MessageBox.Show("Terça-Feira");
break;
case 4:
MessageBox.Show("Quarta-Feira");
break;
case 5:
MessageBox.Show("Quinta-Feira");
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 119
Curso Programando com C# e o Visual Studio .NET 2005
break;
case 6:
MessageBox.Show("Sexta-Feira");
break;
case 7:
MessageBox.Show("Sabado");
break;
}
Primeiro criamos uma variável do tipo int e atribuímos a mesma o valor 3.
A seguir iniciamos a estrutura colocando como expressão de teste o valor da
variável.
O primeiro Case verifica se o valor da variável ou expressão de teste é 1. Se for o
código que escreve na tela o texto Domingo é executado e a estrutura é finalizada
não verificando os outros Cases. Caso contrario ele vai pro próximo case e segue
como o primeiro até o fim da estrutura. Se nenhum dos cases se enquadrar no
valor da expressão de teste nenhum código será executado, para isso que serve o
default. No próximo exemplo vamos apenas programar o uso do default:
int diaDaSemana = 3;
switch (diaDaSemana)
{
case 1:
MessageBox.Show("Domingo");
break;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 120
Curso Programando com C# e o Visual Studio .NET 2005
case 2:
MessageBox.Show("Segunda-Feira");
break;
case 3:
MessageBox.Show("Terça-Feira");
break;
case 4:
MessageBox.Show("Quarta-Feira");
break;
case 5:
MessageBox.Show("Quinta-Feira");
break;
case 6:
MessageBox.Show("Sexta-Feira");
break;
case 7:
MessageBox.Show("Sabado");
break;
default:
MessageBox.Show("Dia Inválido");
break;
}
Aqui se o resultado da expressão de teste não for verdadeiro em nenhum Case,
então será executado o default, escrevendo na tela que o valor informado é
invalido, o que não é o caso para o nosso exemplo, já que o valor da expressão se
enquadra no Case 3 escrevendo Terça-Feira.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 121
Curso Programando com C# e o Visual Studio .NET 2005
Para entender ainda melhor vamos fazer um exemplo no Visual Studio. Esse
exemplo lista todos os meses do ano e quando selecionado um mês ele exibe uma
mensagem na tela com o numero de dias que o mês selecionado possui.
1 - Crie um novo projeto chamado EstruturaDeDecisao2, do tipo Windows
Application.
2 – Arraste um listBox para o Form1. Na propriedade Items na janela
Properties digite todos os meses do ano como abaixo:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 122
Curso Programando com C# e o Visual Studio .NET 2005
O Form1 vai ficar assim:
3 – De um clique duplo sobre o listBox1 e digite o seguinte código:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 123
Curso Programando com C# e o Visual Studio .NET 2005
switch (Convert.ToString(listBox1.SelectedItem))
{
case "Fevereiro" :
MessageBox.Show ("Este mes tem 28 dias");
break;
case "Abril":
case "Junho":
case "Setembro":
case "Novembro":
MessageBox.Show ("Este mes tem 30 dias");
break;
default:
MessageBox.Show ("Este mes tem 31 dias");
break;
}
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 124
Curso Programando com C# e o Visual Studio .NET 2005
4 – Execute a aplicação (pressione F5).
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 125
Curso Programando com C# e o Visual Studio .NET 2005
5 – Clique sobre um mês, por exemplo, Fevereiro, note a janela que exibe o
numero de dias que tem esse mês.
Nosso exemplo é simples, criamos uma estrutura switch e demos a ela como
expressão de teste o valor do item selecionado na listBox1. Usamos o método
Convert para converter para string o valor obtido da listBox1.
O primeiro Case verifica se o item selecionado ou valor da expressão é Fevereiro.
Se sim então mostra a caixa de dialogo com a mensagem dizendo que o mês possui
28 dias, senão vai para o próximo Case que verifica se o item selecionado é Abril, e
assim sucessivamente até Novembro. Note que só implementamos código em
Novembro, agrupamos assim quando os cases forem executar o mesmo bloco de
código. Se o valor da expressão não se enquadrar em nenhum item da lista então
ele vai para o default que executa o código com a mensagem de que o mês possui
31 dias.
6 – Vamos fazer uma mudança no nosso switch agora, siga o exemplo abaixo:
switch (listBox1.SelectedIndex + 1)
{
case 2 :
MessageBox.Show ("Este mes tem 28 dias");
break;
case 4:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 126
Curso Programando com C# e o Visual Studio .NET 2005
case 6:
case 9:
case 11:
MessageBox.Show ("Este mes tem 30 dias");
break;
default:
MessageBox.Show ("Este mes tem 31 dias");
break;
}
Neste exemplo, ao invés de pegarmos o texto selecionado no listBox agora
estamos pegando o índice.
O índice é um numero que é atribuído a cada valor na lista começando por zero,
então Janeiro tem índice 0, Fevereiro 1 e assim por diante.
Como sabemos que Janeiro é o primeiro mês do ano e fevereiro o segundo e assim
por diante adicionamos 1 ao valor do índice. Isso apenas para não confundirmos.
Lembre-se do seguinte a respeito do switch:
•
O switch deixa o código mais estruturado em relação ao uso de vários else
if seguidos;
•
Você só pode usar o switch com tipos de dados primitivos, como: (int,
long, float, double, decimal, string, char, bool). Para usar outros tipos
de dados use o if;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 127
Curso Programando com C# e o Visual Studio .NET 2005
•
A expressão do case precisa ser uma expressão única, em outras palavras,
não é permitido escrever duas expressões em um mesmo case.
•
Você precisa repetir a sintaxe do case para cada valor individual que você
quer avaliar, mesmo que ele execute o mesmo bloco de código, veja o
ultimo exemplo.
•
Você deve usar o break após cada bloco de código senão ele vai continuar
avaliando os outros cases.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 128
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 5
Estruturas de Repetição
As estruturas de repetição – também conhecidas como estruturas de looping –
permitem que você executa uma linha ou bloco de código repetidamente até que
uma condição seja verdadeira.
O uso de loopings nos programas é uma prática comum, pois em muitos casos é
preciso percorrer uma determinada coleção de dados, um conjunto de registros,
valores de matrizes, etc.
Lição 19 – Usando o while
O looping While é executado sempre associado a uma condição, ou seja, a cada
passagem pelo looping a condição é avaliada. Veja a sintaxe a seguir:
while ( booleanExpression )
statement
Vamos fazer um exemplo para você compreender melhor o funcionamento do
while.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 129
Curso Programando com C# e o Visual Studio .NET 2005
1 - Crie um novo projeto no Visual Studio, novamente do tipo Windows
Application, chame o projeto de while.
2 - Adicione no Form1 os seguintes controles:
•
1 Button
•
1 ListBox
3 - Mude a propriedade Text do Button1 para “Loop”.
4 - Organize os controles como a figura abaixo:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 130
Curso Programando com C# e o Visual Studio .NET 2005
5 - De um clique duplo sobre o Button1 e digite o seguinte código:
int contador = 0;
while (contador < 20)
{
contador++;
listBox1.Items.Add(contador);
}
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 131
Curso Programando com C# e o Visual Studio .NET 2005
Esse é nosso código, vamos estudá-lo um pouco:
int contador = 0;
while (contador < 20)
{
contador++;
listBox1.Items.Add(contador);
}
Na primeira linha declaramos uma variável chamada contador do tipo integer e
atribuimos a essa variavel o valor 0.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 132
Curso Programando com C# e o Visual Studio .NET 2005
A segunda linha começa o While com a condição. Essa linhar quer dizer enquanto
contador for menor que 20, ou seja ele vai executar o loop ou o código que esta
entre os colchetes até que o conteudo da variável contador seja igual ou maior
que 20.
A linha quatro soma 1 ao conteudo da variável contador, a linha a seguir tem o
mesmo significado:
contador = contador + 1
Entretanto da forma que fizemos no nosso exemplo é mais elegante porque não
precisamos repetir o nome da variável, se apenas fizéssemos assim:
contador = 1
Ele atribuiria 1 ao conteúdo da variável e o nosso looping se tornaria um loop
infinito ou seja nunca ia parar de rodar porque nunca entraria na condição que o
faz parar. Cuidado com esse tipo de loop, seus loops nunca devem ser infinitos.
A linha 5 atribui ao ListBox o valor da variável.
Fique atento para o seguinte quando estiver utilizando o WHILE:
•
A expressão condicional deve retornar sempre um valor Boolean ou seja,
verdadeiro o falso.
•
A expressão condicional também deve estar sempre entre parênteses.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 133
Curso Programando com C# e o Visual Studio .NET 2005
•
Se na primeira passagem o resultado da empressão condicional for falso, o
código do While não será executado.
•
Se você for usar mais de uma linha de código dentro do while precisa
colocá-lo entre colchetes, senão não.
Lição 20 – Usando o do
O Do é semelhante ao while, ou seja, é executado sempre associado a uma
condição, novamente a cada passagem pelo looping a condição é avaliada. Só que
no Do a condição é colocada no final, fazendo com que mesmo que o resultado seja
falso da expressão booleana o código seja executado pelo menos uma vez. Caso
precise abandonar o looping, use o break, que é opcional. Veja a sintaxe (não
esqueça do ponto-e-virgula no final):
do
statement
while (booleanExpression);
Vamos fazer uma modificação no exercicio do item anterior para compreender
como funciona o break.
1 - Se o exemplo anterior não estiver aberto no Visual Studio, abra-o.
2 - Vá para o código do button1, ele deve ser o seguinte:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 134
Curso Programando com C# e o Visual Studio .NET 2005
int contador = 0;
while (contador < 20)
{
contador++;
listBox1.Items.Add(contador);
}
3 - Mude para o seguinte:
int contador = 0;
while (contador < 20)
{
contador++;
if (contador == 10)
{
break;
}
listBox1.Items.Add(contador);
}
Perceba que as modificações foram minimas, apenas inserimos um If que verifica
se o conteudo da variavel contador é 10, se for ele executa o break que finaliza
imediatamente o loop.
4 - Execute a aplicação:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 135
Curso Programando com C# e o Visual Studio .NET 2005
5 - Clique em Loop.
Perceba que ele nem chega a escrever o número 10 por que a linha de código que é
responsável por isso esta depois do If que finalizou o loop.
6 – Agora mude o valor inicial da variável 0 para 20.
7 – Execute a aplicação e clique em Loop.
Perceba que não aparece nada, porque o resultado da expressão condicional
começa como false, já que o valor não é menor que 20, e sim é igual a 20.
8 – Vamos usar o Do agora, mude o código para o seguinte:
int contador = 20;
do
{
contador++;
listBox1.Items.Add(contador);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 136
Curso Programando com C# e o Visual Studio .NET 2005
if (contador == 10)
{
break;
}
}
while (contador < 20);
9 - Execute a aplicação e clique em Loop.
Se a expressão estivesse encima nada apareceria, mas agora aparece o 21, isso
porque ele executou uma vez o loop antes de avaliar a expressão, algumas vezes
esse tipo de loop pode ser necessário. Fique atento.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 137
Curso Programando com C# e o Visual Studio .NET 2005
Lição 21 – Usando o for
O For é usado quando sabemos o número de vezes que iremos executar o Loop. O
For precisa de um contador que normalmente é uma variável que controla o
número de vezes que o loop será executado..
A variável contador pode ser inicializada antes do For ou na própria declaração.
Se durante o processamento você quiser abandonar o looping, terá que usar o
break. A sintaxe do For é a seguinte:
for (initialization; booleanExpression; updateControlVariable)
statement
1 - Crie uma nova aplicação do tipo Windows Application com nome For.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 138
Curso Programando com C# e o Visual Studio .NET 2005
2 - Arraste para o Form1 um Button.
3 - Mude a propriedade Text do Button1 para “Beep”.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 139
Curso Programando com C# e o Visual Studio .NET 2005
4 - De um clique duplo sobre o botão e no digite o seguinte código para o evento
do botão:
for (int i = 1; i <= 4; i++)
{
MessageBox.Show(i.ToString());
}
Vai ficar assim:
5 - Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 140
Curso Programando com C# e o Visual Studio .NET 2005
6 - Clique no botão Beep.
Vamos dar uma avaliada no código:
for (int i = 1; i <= 4; i++)
{
MessageBox.Show(i.ToString());
}
Quando inicializamos o for, primeiro iniciamos uam variável do tipo integer e damos
o valor 1 para ela, demos o nome de i para essa variavel. Depois colocamos uma
expressão booleana que será responsável por avaliar o numero de vezes que o for
será executado, nossa expressão diz que o for deve ser executado enquanto o
conteúdo de da varial i for menor ou igual a 4. Para finalizar a inicialização do For
dizemos que a cada passada o conteúdo da variável i deve ser acrescentado em 1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 141
Curso Programando com C# e o Visual Studio .NET 2005
7 - Mude o código do botão para o seguinte:
for (int i = 1; i <= 25; i+=5)
{
MessageBox.Show(i.ToString());
}
8 - Execute a aplicação e clique em Beep.
Perceba que o i+= 5 fez com que o número adicionado a variavel a cada passada
do loop é 5 ao invés de 1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 142
Curso Programando com C# e o Visual Studio .NET 2005
Lição 22 – Conhecendo o foreach
O Foreach é usado em casos onde você precisa percorrer uma coleção de dados.
No Foreach você não precisa verificar o limite do looping, pois isto já está implícito
na própria coleção, ou seja, você se preocupa apenas em manipular o objeto atual.
Caso tenha dúvida no uso, pense da seguinte forma: Para cada elemento contido
na coleção, faça algo. Vamos estudá-lo em detalhe quanto falarmos sobre Arrays e
Coleções.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 143
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 6
Gerenciando Erros e Exceções
O ambiente de desenvolvimento do Visual Studio .Net contém muitas ferramentas
que nos ajudam a resolver os erros em nossos programas.
Lição 23 – Conhecendo os três tipos de erros
Três tipos de erros podem ser encontrados em seus programas, são eles: erros de
sintaxe, erros de Runtime e erros lógicos, vamos entender cada um deles.
Erros de sintaxe ou erro de compilação:
Acontece quando você digita de forma errada uma palavra reservada ou comando
do C#. Você não consegue executar seu programa quando tem esse tipo de erro no
seu código.
Erros de Runtime:
Acontecem quando o programa para de executar derrepente durante sua execução,
chamamos essa parada de exceção.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 144
Curso Programando com C# e o Visual Studio .NET 2005
Erros de runtime acontecem quando alguma coisa interfere na correta execução do
seu código, por exemplo, quando seu código precisa ler um disquete que não esta
no drive, ao não encontrar o disquete ele gera uma exceção e para bruscamente a
execução, esse tipo de erro pode e deve ser tratado.
Erros lógicos:
Esse é o tipo de erro mais dificil de ser tratado. É um erro humano. O código
funciona perfeitamente, mas o resultado é errado. Exemplo, uma função que deve
retornar um valor, só que o valor retornado esta errado, o erro neste caso se
encontra na lógica da função que esta processando o cálculo. A grosso modo é
como se o seu programa precise fazer um calculo de 2 + 2 em que o resultado
certo é 4 mas ele retorna 3. Quando é uma conta simples é fácil de identificar mas
e se o calculo for complexo?
Lição 24 – Encontrando erros com o Visual
Studio.NET 2005
1 - Entre no Visual Studio.NET e crie uma nova aplicação, novamente do tipo
Windows Application chamada Debug.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 145
Curso Programando com C# e o Visual Studio .NET 2005
2 - Arraste para o Form1 os seguintes controles e organize-os como a figura
abaixo:
•
1 Button
•
2 TexBox
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 146
Curso Programando com C# e o Visual Studio .NET 2005
Até agora sempre usamos a janela Properties para setar as propriedades dos
controles, desta vez vamos fazer de uma outra forma.
De um clique duplo sobre o Form1 em qualquer lugar, desde que não seja encima
de nenhum controle. Vai aparecer o cursor dentro do seguinte código:
private void Form1_Load(object sender, EventArgs e)
{
}
Tudo que estiver dentro deste procedimento, chamado Form1_Load será executado
assim que o programa for executado.
3 - Digite o seguinte código dentro do procedimento:
button1.Text = "Testar";
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 147
Curso Programando com C# e o Visual Studio .NET 2005
4 - Execute a aplicação.
Note que a propriedade text do button1 foi modificada como se a tivéssemos feito
na janela properties.
Para usar o Debug não é necessário setar as propriedades assim, pode ser pela
janela Properties apenas entenda que as propriedades podem ser modificadas em
tempo de execução, você pode inclusive setar propriedades em um evento de
clique de botão.
5 - De um clique duplo sobre o Button1 e digite o seguinte código:
int idade;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 148
Curso Programando com C# e o Visual Studio .NET 2005
idade = int.Parse(textBox1.Text);
if (idade > 13 && idade < 20)
{
textox2.Text = "Você é adolescente";
}
else
{
textBox2.Text = "Você não é adolescente";
}
Nosso programa vai ler o conteudo no TextBox1, se o valor for um numero entre
13 e 20 ele vai escrever no TextBox2 a mensagem que você é um adolescente,
senão vai escrever que você não é um adolescente.
6 -Execute sua aplicação. A seguinte mensagem deve aparecer:
A caixa de dálogo esta dizendo que sua aplicação tem erros, se você clicar em sim
ele tenta executar a aplicação mesmo com os erros, clicando em não ele para a
tentativa de execução do programa.
7 – Clique em No.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 149
Curso Programando com C# e o Visual Studio .NET 2005
Agora no painel de código perceba que depois da linha de inicio do If o código que
seta a propriedade Text do TextBox2 tem o nome do controle sublinhado. Esse é
um erro de sintaxe, o nome do controle esta digitado errado, esta faltando um B.
Veja a próxima figura:
Repare na janela Error List.
Repare que o Visual Studio ajuda na detecção do erro.
8 - De um clique duplo sobre a mensagem “The name ‘textox2’ does not exist in
the context”
Ele vai direto para a linha de código com problema.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 150
Curso Programando com C# e o Visual Studio .NET 2005
9 - Vamos resolver o erro. Acrescente o b que esta faltando na palavra TextBox2.
10 - Execute a aplicação. Agora tudo ocorre certo não é mesmo?
11 - Digite 21 na primeira caixa de texto e clique em Testar.
Ele escreve a mensagem “Você não é adolescente”, porque ele entra no else do IF,
já que 21 não esta entre 13 e 20.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 151
Curso Programando com C# e o Visual Studio .NET 2005
12 - Digite agora o numero 17 e clique em Testar.
Agora como o número entra na condição a mensagem muda para “Você é
adolescente”.
13 - Feche a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 152
Curso Programando com C# e o Visual Studio .NET 2005
14 - Vá ao painel de código novamente.
15 - Localize a seguinte linha de código.
idade = int.Parse(textBox1.Text);
16 - Clique sobre esta linha com o botão direito do mouse e selecione a opção
Insert BreakPoint, como na figura abaixo:
Essa linha de código vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 153
Curso Programando com C# e o Visual Studio .NET 2005
O BreakPoint é um ponto de parada. Você pode colocar vários destes no seu
código.
17 - Execute o programa agora.
18 - Digite 21 na primeira caixa de texto e clique em Testar.
O programa a execução exatamente na linha do BreakPoint.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 154
Curso Programando com C# e o Visual Studio .NET 2005
Apareçe também uma nova barra de ferramentas:
Essa é a barra de ferramentas do depurador ou debug, como o nome diz ela
permite que depuremos nosso código linha-a-linha, permitindo uma analise
detalhada.
19 - Na barra de ferramentas debug, clique no botão Step Into.
Ele executa a linha marcada e vai para a próxima linha.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 155
Curso Programando com C# e o Visual Studio .NET 2005
Neste momento a variável idade já tem o conteúdo do TextBox1. Passe o mouse
sobre o texto idade em qualquer lugar do código para ver o conteúdo da variável.
A seta amarela representa a próxima linha de código que será executada. Neste
momento a linha amarela ainda não foi executada.
20 - Clique em Locals. A janela Locals também mostra informações do programa,
como o valor da variável idade.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 156
Curso Programando com C# e o Visual Studio .NET 2005
21 - Clique em Step Into até que todo o código seja executado.
Note que depois que ele avalia o IF como não entra na condição ele já pula para o
Else.
O botão Step Out, pula para o próximo BreakPoint ou termina a execução.
O botão Stop Debugging, para o debug e encerra a execução do programa.
22 - Pare a execução.
Vá novamente a linha de código marcada com o BreakPoint.
23 - Clique com o botão direito do mouse e selecione a opção Delete BreakPoint.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 157
Curso Programando com C# e o Visual Studio .NET 2005
Isso remove a marcação.
O debug é muito útil para encontrar erros lógicos, supondo que os adolecentes são
pessoas de faixa etária que vai de 13 a 19 anos procure localizar o erro lógico no
programa que acabamos de criar.
Lição 25 – Usando a janela Watch
1 - No programa que criamos no item anterior, marque um BreakPoint novamente
na linha:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 158
Curso Programando com C# e o Visual Studio .NET 2005
idade = int.Parse(textBox1.Text);
2 - Execute o programa.
3 - Digite 25 na primeira caixa de texto e clique em Testar.
O programa para no BreakPoint. E o Visual Studio entra no que chamamos de
Break Mode.
Para usar a janela Watch você precisa estar em Break Mode.
4 - Clique na guia Watch 1, não tem nada na janela Watch ainda.
5 - Clique com o botão direito sobre o nome da variável idade, e selecione Add
Watch, como na figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 159
Curso Programando com C# e o Visual Studio .NET 2005
É adicionado uma linha com o nome da variável e seu valor na janela Watch.
O valor é 0 e o tipo da variável é tido como integer.
6 - Adicione também TextBox2.Text a janela Watch.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 160
Curso Programando com C# e o Visual Studio .NET 2005
7 - Selecione a expressão idade < 20 e adicione a janela Watch.
Sua janela Watch deve estar assim:
Agora a cada passo do programa você vai poder acompanhar o valor de cada um
destes itens.
8 - Clique no botão Step Into na barra de ferramentas Debug. Ao invés de clicar
no botão você pode apertar F11 no teclado.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 161
Curso Programando com C# e o Visual Studio .NET 2005
O valor da variável idade é mudado para 25 e a expressão idade < 20 é avaliada
como False. Os valores são modificados na janela Watch em vermelho porque
acabaram de ser atualizados.
9 - Clique em Step Into mais algumas vezes até a completa execução do código.
10 - Pare a execução do programa.
Para remover um item da janela Watch, clique sobre o mesmo, exemplo, idade <
20 e pressione a tecla Delete no teclado.
Para ver o conteúdo das varáveis e propriedades durante a execução do programa
você precisa usar a janela Watch, porque a janela Locals não mantem os valores
durante a execução de todo o programa.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 162
Curso Programando com C# e o Visual Studio .NET 2005
Lição 26 – Usando a janela Command
Para esse item suponho que você tenha finalizado o anterior e o que o exemplo
esta com o BreakPoint marcado.
1 - Execute o programa.
2- Na primeira caixa de texto digite 25 e clique em Testar.
Ele deve parar na linha marcada:
3 - Na barra de ferramentas Debug clique em Step Into ou pressione F11.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 163
Curso Programando com C# e o Visual Studio .NET 2005
4 - No menu Debug, selecione Windows e clique em Immediate.
O cursor vai para a janela Command, no modo Immediate.
5 - Digite idade = 14 e pressione enter.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 164
Curso Programando com C# e o Visual Studio .NET 2005
Agora você modificou o conteúdo da variável idade com a janela Command, o
valor da váriavel idade é exibido na janela Locals em vermelho, imediatamente
após a modificação, mostrando que acabou de ser modificada.
6 - Clique duas vezes sobre o botão Step Into na barra de ferrametas Debug.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 165
Curso Programando com C# e o Visual Studio .NET 2005
7 - Digite o seguinte código na janela Command e pressione Enter:
TextBox2.Text = “Você tem uma boa idade”
A propriedade Text do objeto TextBox2 é imediatamente modificado.
Verifique na janela Locals.
8 - Clique no botão Step Into da barra de ferramentas Debug mais duas vezes.
O número 25 permanece na TextBox1, isso porque mudamos apenas o valor da
variável e não o valor do TextBox1, já a TextBox2 mostra a mensagem nova que
colocamos através da janela Command.
Em companhia com as janelas Locals e Watch a janela Command pode ser muito
útil para encontrar e resolver dificeis erros de lógica em seus programas.
Lição 27 – try..catch
Até agora você aprendeu como utilizar o Visual Studio .NET para resolver erros de
sintaxe e lógicos. À partir deste item você aprenderá a tratar erros de runtime
através do try...catch, que é conhecido como uma estrutura de tratamento de erros
ou estrutura de tratamento de exceções. Você pode usá-lo para reconhecer qual o
erro de runtime esta ocorrendo no seu programa e através disso emitir uma
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 166
Curso Programando com C# e o Visual Studio .NET 2005
mensagem de erro adequada e ajustar seu programa com as condições necessárias
para que ele continue executando.
Um exemplo bem comum, mas que permite que ilustremos bem como os erros de
runtime ocorrem e como tratá-los é o exemplo da leitura do drive de disquete.
Para esse exemplo será necessário um disquete com um arquivo nele. Vamos
colocar um arquivo de imagem, assim você já aprende como abrir um arquivo de
imagem no seu programa.
1 - Pegue um disquete - o ideal é que não tenha nenhum arquivo nele ou pelo
menos o espaço necessário para a imagem - coloque o no drive A.
2 - Copie para o disquete uma imagem, no nosso exercício estou colocando a
imagem inverno.jpg, porque ela já vem com o windows XP e fica armazenada na
pasta amostra de imagens dentro de Meus Documentos > Minhas Imagens >
Amostra de imagens. Fique a vontade para colocar outra imagem.
3 - Agora no Visual Studio crie um novo programa chamado TryCatch do tipo
Windows Application.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 167
Curso Programando com C# e o Visual Studio .NET 2005
4 - Arraste para o Form1 os seguites controles:
•
1 Button
•
1 PictureBox
5 - Mude a propriedade Text do Button1 para “Testar Drive”.
6 - Organize os controles como a figura abaixo:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 168
Curso Programando com C# e o Visual Studio .NET 2005
Eu redimencionei tanto o tamanho do Form1 como o tamanho do PictureBox1,
você pode fazer o mesmo utilizando as guias.
7 - De um clique duplo sobre o Button1 e digite o seguinte código:
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
Quando for passar um caminho como string utilize o @ antes como fizemos no
código acima.
8 - Execute sua aplicação.
9 - Clique no botão Testar Drive, a imagem deve abrir no Form como a seguir:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 169
Curso Programando com C# e o Visual Studio .NET 2005
10 - Pare a execução do programa.
11 - Tire o disquete do drive.
12 - Execute novamente o programa e clique no botão Testar Drive.
O programa não consegue encontrar o arquivo, acontece então um erro de runtime,
que para bruscamente a execução do programa.
A linha com o erro também fica amarela no painel de código.
13 - Clique no botão Continue para fechar o programa ou pressione F5.
Vamos agora implementar o código que faz o tratamento do erro.
14 - Modifique o código do Evento do Button1 para o seguinte:
try
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 170
Curso Programando com C# e o Visual Studio .NET 2005
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Insira o disquete no drive A");
}
Você não precisa digitar denovo a linha que executa a leitura da imagem do
disquete. Apenas acrescente o try..catch e o código responsavel por emitir a
mensagem de erro.
15 - Execute a aplicação.
16 - Sem o disquete no drive clique no botão Testar Drive.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 171
Curso Programando com C# e o Visual Studio .NET 2005
Perceba que agora ele mostra a caixa de dialógo com a mensagem que
especificamos. Isso é muito mais elegante do que o erro gerando anteriormente.
17 - Clique no botão OK.
18 - Insira o disquete com a imagem no drive e clique em OK.
19 - Feche a aplicação.
Vamos analizar agora o bloco de código responsável pelo tratamento do erro.
Primeiramente segue a sintaxe do try...catch:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 172
Curso Programando com C# e o Visual Studio .NET 2005
try
{
Código executado se nenhum erro acontecer
}
catch
{
Código executado se houver erro
}
Finally
{
Opcional, sempre é executado
}
O código fica sempre após a palavra reservada try, se algum erro aconteçer no
processamento deste código o programa vai imediatamente para o bloco catch que
é responsavel pelo tratamento do erro. O finally é opcional, ele é sempre
executado, com erro ou não. No nosso exemplo colocamos o código que lê a
imagem dentro do try, e no catch o código que abre a caixa de dialógo pedindo
para inserir o disquete no drive A.
Se nenhum erro ocorrer é executado apenas o código dentro do try, senão ele vai
para o catch. Pedindo para inserir o disquete no drive A.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 173
Curso Programando com C# e o Visual Studio .NET 2005
try
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Insira o disquete no drive A");
}
Vamos agora implementar o Finally no nosso código.
20 - Altere o código do evento do Button1 para o seguinte:
try
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Insira o disquete no drive A");
}
finally
{
MessageBox.Show("Código executado no finally");
}
Você não precisa mudar o código anterior, apenas acrescentar o finally, como
exemplo de uso do finally apenas vamos exibir mais uma caixa de diálogo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 174
Curso Programando com C# e o Visual Studio .NET 2005
21 - Execute a aplicação.
22 - Teste com e sem disque do drive. Vai ver que a mensagem do Finally apareçe
nas duas alternativas, ou seja, com e sem erro.
A tabela a seguir mostra o que ocasiona a maior parte dos erros de runtime:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 175
Curso Programando com C# e o Visual Studio .NET 2005
Lição 28 – Usando try...catch aninhados
Podemos aninhar - colocar blocos de try...catch um dentro de outro - para criar
estruturas de tratamento mais avançadas, como o exemplo:
try
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Insira o disquete no drive A");
try
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 176
Curso Programando com C# e o Visual Studio .NET 2005
{
pictureBox1.Image = pictureBox1.Image =
System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Falha ao abrir o arquivo");
button1.Enabled = false;
}
}
A primeira mensagem de erro pede para o usuario inserir o disque e clicar em OK,
se ele o fizer o programa tenta ler o arquivo, se não for possivel emite a mensagem
de Falha e desabilita o Button1.
Vamos fazer esse exemplo para você ver a diferença do que tinhamos feito até
aqui.
1 – No programa que criamos na lição anterior, modifique o código do evento do
Button1 para o seguinte.
try
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Insira o disquete no drive A");
try
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 177
Curso Programando com C# e o Visual Studio .NET 2005
{
pictureBox1.Image = pictureBox1.Image =
System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
catch
{
MessageBox.Show("Falha ao abrir o arquivo");
button1.Enabled = false;
}
}
Vai ficar assim:
2 - Execute aplicação e sem o disco no drive clique no botão Testar Drive.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 178
Curso Programando com C# e o Visual Studio .NET 2005
A seguinte mensagem aparece:
3 - Insira o disco no drive e clique em OK.
Ele carrega a imagem e a exibe.
4 - Agora tire novamente o disco do drive e clique no botão.
5 - Sem colocar o disco no drive clique em OK.
A seguinte mensagem aparece.
6 - Clique em OK.
Agora o Form1 é mostrado com o Button1 desabilitado.
O código responsável por desabilitar o Button1 é o seguinte:
button1.Enabled = false;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 179
Curso Programando com C# e o Visual Studio .NET 2005
Lição 29 – Programação defensiva
Conhecemos por programação defensiva a iniciativa do programador de escrever
seu código protegendo-o de erros de runtime. Exemplo:
if (System.IO.File.Exists(@"a:\inverno.jpg"))
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
else
{
MessageBox.Show("Não é possivel abrir o arquivo no drive A");
}
O código acima usa a o método File.Exists para verificar se o arquivo existe antes
de tentar abri-lo.
O IF não é uma estrutura de tratamento de erros, porque não previne os erros de
runtime, no entanto ele permite técnicas de validação.
A pergunta aqui é a seguinte: Quando utilizo programação defensiva preciso usar
os blocos de tratamento de erros?
A resposta depende de com que freqüência você acha que o problema vai ocorrer
no programa que você esta criando. Se o erro de runtime for ocorrer menos de
25% das vezes que o código for executado o tratamento de erros é a forma mais
eficiente de tratar o erro. Os try...catch é essencial se você tem mais do que uma
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 180
Curso Programando com C# e o Visual Studio .NET 2005
condição para testar também, e se você quer privar os usuários de várias questões
a serem respondidas para prevenir os erros.
No entanto se a estimativa do erro ocorrer for mais de 25% da vezes, a
programação defensiva é bem eficaz para diminuir a quantidade de exceções.
Mas o ideal é o uso das duas, tanto da programação defensiva como dos blocos
Try...Catch.
Lição 30 – Exit try
Para finalizar suponha que o usuário esta sem o disco e tente abrir o arquivo, não
sendo possivem a exceção aconteçe e consequentemente o erro de runtime, um
bloco try...catch trata o erro, mas novamente o usuario clica no botão e o erro
aconteçe denovo, é tratado, e assim sucessivamente.
Para evitar esse problema podemos criar uma variavel que armazena o numero de
vezes que o Catch foi executado, chegando a um número estipulado podemos por
exemplo desabilitar o botão, como no exemplo abaixo:
int retorno = 0;
try
{
pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg");
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 181
Curso Programando com C# e o Visual Studio .NET 2005
catch
{
retorno += 1;
if (retorno <= 2)
{
MessageBox.Show("Insira o disquete no drive A");
}
else
{
MessageBox.Show("Recurso não disponivel");
button1.Enabled = false;
}
}
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 182
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 7
Arrays e Coleções
Lição 31 – Usando Arrays
Imagine que você tem que armazenar as faltas cometidas por cada jogador de um
time em uma partida de futebol. Você precisaria armazenar o nome e o número de
faltas que cada jogador cometeu. Como faria para armazenar isso em variáveis?
Provavelmente você teria que declarar duas variáveis para cada jogador, uma para
armazenar o nome e outra o número de faltas, chagando facilmente a 22 variáveis,
isso, se não houver nenhuma substituição.
Arrays são usados para gerenciar grande quantidade de informação. Como
variáveis, você precisa declarar seus arrays antes de usá-los. Os arrays também
respeitam as mesmas regras de escopo que as variáveis, ou seja se declaradas
dentro de procedimentos, ficam disponiveis apenas para o procedimento em
questão.
Vamos fazer um exemplo, nele vamos criar o programa que armazenará os dados
nos nomes dos jogadores e as faltas cometidas por eles.
1 - Entre no Visual Studio e crie um novo projeto do tipo Windows Application
chamado Arrays.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 183
Curso Programando com C# e o Visual Studio .NET 2005
2 - Arraste para o Form1 os seguintes controles:
•
3 Button
•
1 ListBox
•
2 Labels
•
2 TextBoxes
3 - Altere a propriedade Text do Button1 para “Inserir Jogador”.
4 – Altere a propriedade Text do Button2 para “Inserir Falta”
5 – Altere a propriedade Text do Button3 para “Visualizar Array”
6 - Altere a propriedade Text do Form1 para “Array”.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 184
Curso Programando com C# e o Visual Studio .NET 2005
7 – Altere a propriedade Text do Label1 para “Jogador”.
8 – Altere a propriedade Text do Label2 para “Num. Faltas”
9 - Organize-os como a próxima figura:
10 - Na janela Solution Explorer clique no botão View Code para ir para o Painel
de código.
11 - Digite dentro da classe do Form1 o seguinte código:
string[] jogadores = new string[11];
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 185
Curso Programando com C# e o Visual Studio .NET 2005
Nesta linha declaramos um Array de tamanho fixo. O array que criamos é como
uma tabela com 11 linhas, o suficiente para armazenar o nome do time inteiro, 11
jogadores.
12 - Na janela Solution Explorer clique em View Designer para voltar para o
Form1 no modo Design, você pode também clicar na aba Form1.vb[Design] ao
lado da aba Start Page, à essa altura do curso você ja deve estar familiarizado
com o Visual Studio.
13 - De um clique duplo sobre o Button1 e digite o seguinte código:
jogadores[0] = textBox1.Text;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 186
Curso Programando com C# e o Visual Studio .NET 2005
Isso insere “Marcos” na primeira linha do Array, se colocassemos 6 ao invés de 0,
por exemplo, seria na linha 7. O primeiro registro no array é sempre o 0, isso
porque os índices sempre começam com 0.
14 - De um clique duplo sobre o Button3 (Visualizar Array) e digite o seguinte
código:
listBox1.Items.Add(jogadores[0]);
Isso insere na ListBox1 o conteúdo da primeira linha do array Jogadores, se
colocassemos 6, exibiria o conteúdo da linha 7, lembre-se que de o primeiro
registro do array tem sempre o índice 0 e assim sucessivamente.
Não se assuste com o código para inserir no ListBox1, se fosse em uma TextBox
ou Label você poderia usar a seguinte linha de código:
textBox1.Text = jogadores[0];
Só que para inserir um item no ListBox precisamos usar seu método Add.
15 – Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 187
Curso Programando com C# e o Visual Studio .NET 2005
16 – Digite Marcos no textBox1 e clique em inserir Jogador.
17 – Clique em Visualizar Array.
Agora que você já compreende como inserir e ler dados do array vamos avançar
no exemplo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 188
Curso Programando com C# e o Visual Studio .NET 2005
18 – Pare a execução.
19 - Digite dentro da classe do Form1 o seguinte código:
int contador = 0;
Isto cria uma variável que estará disponível para todos os procedimentos dentro da
classe, ou seja, seu escopo é a classe. Também já atribuímos o valor 0 nela. Essa
variável será usada para controlar o índice ou local do array onde vamos inserir
cada jogador.
20 - Volte para o código do procedimento do Button1.
21 - Substitua o código pelo seguinte:
if (contador <= 10 && textBox1.Text != "")
{
jogadores[contador] = textBox1.Text;
contador += 1;
textBox1.Text = null;
}
else
{
button1.Enabled = false;
}
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 189
Curso Programando com C# e o Visual Studio .NET 2005
Não podemos adicionar jogadores no array se ele estiver cheio e se o conteúdo do
textBox não tiver nada. Para isso usamos o if.
Depois adicionamos o conteúdo do textBox1 no array. A posição é informada pela
variável contador.
Adicionamos 1 a variável contador, senão o array nunca vai para a próxima
posição.
Para finalizar limpamos o textBox1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 190
Curso Programando com C# e o Visual Studio .NET 2005
No else apenas desabilitamos o Button1 caso o array esteja vazio ou não tenha
nada nele digitado, ou seja, caso a expressão lógica do if retorne false.
22 - Mude o código do Button3 pelo seguinte:
for (int i = 0; i <= jogadores.Length - 1; i++)
{
listBox1.Items.Add(jogadores[i]);
}
Vai ficar assim:
Aqui usamos o loop tor para passar por cada item do Array e adiciona-lo no
ListBox1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 191
Curso Programando com C# e o Visual Studio .NET 2005
A propriedade Length retorna o numero de registros do array, que é 11,
poderíamos simplesmente ter feito assim:
for (int i = 0; i <= 10; i++)
Colocamos o -1 depois do Length porque o Lenght retorna 11, lembre-se que o
índice do primeiro elemento do array é 0, então o ultimo é 10.
A cada passada pelo For o i assume o valor de uma linha do array até chegar ao
final.
23 - Execute a aplicação.
24 – Digite o nome de um Jogador e clique no botão Inserir Jogador.
Faça isso sucessivamente até que o botão seja desabilitado, ou seja, que o array
seja totalmente preenchido.
25 - Clique no botão Visualizar Array.
O nome dos 11 jogadores é listado.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 192
Curso Programando com C# e o Visual Studio .NET 2005
Como você pode ver, trabalhamos facilmente com os nomes dos 11 jogadores em
nosso array, podemos modificar os dados do nosso array facilmente, bastando para
isso indicar qual linha deve ser alterada e o novo dado, como no exemplo:
jogadores[10] = “Robinho”;
Um array pode conter mais de um coluna. Vamos entender como isso funciona
implementando o código que vai armazenar o número de faltas de cada jogador.
Como um Array só pode conter um tipo de dado e nosso Array já é do tipo String,
no nosso exemplo vamos adicionar o número de faltas como string mesmo, mas, a
maneira correta seria criar um outro Array do tipo integer para armazenar as faltas.
Vamos optar pela primeira opção para você aprender a trabalhar com duas colunas.
26 - Altere o código que declara o Array para o seguinte:
string[,] jogadores = new string[11,2];
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 193
Curso Programando com C# e o Visual Studio .NET 2005
Isso cria um Array com 11 linhas e 2 colunas.
27 - Localize no procedimento do evento do Button1, as seguintes código:
jogadores[contador] = textBox1.Text;
28 - Mude-o para o seguinte:
jogadores[contador,0] = textBox1.Text;
Isso apenas indica que vamos adicionar o nome na linha que o loop indicar, na
coluna 1, de índice 0.
29 - Digite dentro da classe do Form1 o seguinte código:
int contadorFaltas = 0;
Esta variável fará o mesmo que a contador, só que para as faltas.
30 - Dê um clique duplo sobre o Button2 e digite o seguinte código:
if (contadorFaltas <= 10 && textBox2.Text != "")
{
jogadores[contadorFaltas, 1] = textBox2.Text;
contadorFaltas += 1;
textBox2.Text = null;
}
else
{
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 194
Curso Programando com C# e o Visual Studio .NET 2005
button2.Enabled = false;
}
Vai ficar assim:
Isso é semelhante ao código do Button1. Só que usamos a variável contadorFaltas,
o textBox2 e o button2.
Note também que agora atribuimos os valores à segunda coluna, como mostra o
código:
jogadores[contadorFaltas, 1] = textBox2.Text;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 195
Curso Programando com C# e o Visual Studio .NET 2005
O índice 1 se refere a segunda coluna.
Agora precisamos mudar o código do button3, que exibe os dados, para listar as
faltas também.
31 - Mude o código do Button3 para o seguinte:
for (int i = 0; i <= 10; i++)
{
listBox1.Items.Add(jogadores[i,0] + " - Total de faltas: " +
jogadores[i,1]);
}
O que fizemos foi concatenar os dados da coluna 1 com os da 2, e fazer um loop
por cada linha do array de 0 a 10 ou seja pelas 11 linhas.
32 - Execute sua aplicação:
33 – Digite o nome de um Jogador e clique no botão Inserir Jogador.
Faça isso sucessivamente até que o botão seja desabilitado, ou seja, que o array
seja totalmente preenchido.
34 – Digite uma quantidade de faltas para cada jogador como fez com o nome dos
jogadores até o botão ser desabilitado.
35 – Clique no botão Visualizar array
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 196
Curso Programando com C# e o Visual Studio .NET 2005
Lição 32 – Coleções
Uma coleção é um grupo de objetos relacionados. Todo controle que você arrasta
para o Form é um objeto. E cada objeto adicionado ao Form é adicionado a uma
coleção. Essa coleção é conhecida como coleção de controles ou Control
Collection.
1 - Entre no Visual Studio e crie um novo projeto do tipo Windows Application
chamado Coleções.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 197
Curso Programando com C# e o Visual Studio .NET 2005
2 - Arraste 3 Buttons para o Form1.
Sempre que adicionamos controles como o Button por exemplo ao nosso Form,
automaticamente os controles são adicionados a coleção de controle do Form,
vamos chamar essa coleção de Control Collection daqui pra frente.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 198
Curso Programando com C# e o Visual Studio .NET 2005
3 - De um clique duplo sobro o button1 e digite o seguinte código:
foreach (Control controles in Controls)
{
controles.Text = "OK";
}
Vai ficar assim:
4 - Execute sua aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 199
Curso Programando com C# e o Visual Studio .NET 2005
5 - Clique no Button1.
Nosso loop modificou a propriedade Text de todos os botões para OK.
Criamos um loop que passou por cada controle modificando sua propriedade Text.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 200
Curso Programando com C# e o Visual Studio .NET 2005
6 - Você pode filtrar os controles que quer modificar também, vamos fazer isso
modificando o Loop do Button1 para o seguinte:
foreach (Control controles in Controls)
{
if (controles.Name != "button1")
controles.Left = controles.Left + 20;
}
Vai ficar assim no painel de código:
7 - Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 201
Curso Programando com C# e o Visual Studio .NET 2005
8 - Clique no Button1.
Agora apenas o Button2 e Button3 foram alterados pelo Loop. Já que
adicionamos o If para testar se o controle não era o Button1. Mudamos uma
propriedade diferente desta vez, movimentando assim os Buttons para a direita.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 202
Curso Programando com C# e o Visual Studio .NET 2005
Você pode referenciar um controle na coleção individualmente, para isso você
utiliza o indice para localizar um objeto da coleção. Como nos arrays o indice
começa sempre em 0. Outro ponto importante é que o primeiro controle do indice,
ou seja, o indice 0 é o último controle adicionado no Form1, o penultimo tem
indice 1 e assim sucessivamente. Se você adicionar um controle novo , ele fica com
indice 0 e os outros pulam um pra frente sucessivamente.
Assim para alterar o Button3 poderiamos usar a seguinte linha de código:
Controls[0].Left += 35;
Lembrando que Controls representa todos os controles do Form1, ou seja, a
Control Collection.
9 - No Form1 de um clique duplo sobre o Button2 e digite o seguinte código:
Controls[0].Left += 35;
10 - Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 203
Curso Programando com C# e o Visual Studio .NET 2005
11 - Clique no Button2.
Conforme citado o indice 0 representa o último controle adicionado no Form1,
então nosso código moveu apenas o Button3 - que foi o último controle adicionado
- para a esquerda.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 204
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 8
Aprofundando em Windows Forms
A partir deste capitulo vamos nos aprofundar mais no desenvolvimento de
aplicações para Windows. Um programa realmente não é desenvolvido com apenas
um formulário (Form). Sempre temos vários deles nos nossos programas, vamos
estudar neste capitulo como trabalhar com varios formulários. Alem disso, vamos
estudar as propriedades mais importantes dos formulários.
Lição 33 – Trabalhando com múltiplos formulários
Sempre que você cria uma Windows Application um formulário já é criado por
padrão, ele é conhecido como formulário Base.
Para adicionar um novo formulário no seu programa você:
1 – Na janela Solution Explorer, clique com o botão direito no nome do
projeto, selecione Add e clique em Windows Form. Como a imagem
seguinte.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 205
Curso Programando com C# e o Visual Studio .NET 2005
2 – Digite um nome para o novo formulário e clique em Add.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 206
Curso Programando com C# e o Visual Studio .NET 2005
Vamos fazer um exemplo que ilustra como podemos trabalhar com múltiplos
formulário.
1 – Crie uma Windows Application chamada Formularios.
2 – Arraste 2 buttons para o Form1.
3 – Mude as propriedades Text dos Buttons 1 e 2 para Vermelho e Verde
respectivamente.
4 – Adicione mais dois formulários no projeto.
5 – Mude o nome do Form2 para frmVermelho e do Form3 para frmVerde. Para
isso clique sobre o nome do Form no Solution Explorer e clique em Rename
como a imagem seguinte:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 207
Curso Programando com C# e o Visual Studio .NET 2005
Se a seguinte mensagem aparecer clique em Sim. Isso vai atualizar todas as
referencias ao form do projeto para o novo nome.
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 208
Curso Programando com C# e o Visual Studio .NET 2005
6 – Mude a propriedade BackColor do frmVermelho para a cor Vermelha.
7 – Mude a propriedade BackColor do frmVerde para Verde.
8 – No Form1 de um clique duplo sobre o botão Vermelho e digite o seguinte
código dentro do procedimento do evento click:
frmVermelho Vermelho = new frmVermelho();
Vermelho.Show();
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 209
Curso Programando com C# e o Visual Studio .NET 2005
9 – Faça o mesmo para o botão Verde mas digite o seguinte código:
frmVerde Verde = new frmVerde();
Verde.ShowDialog();
10 – Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 210
Curso Programando com C# e o Visual Studio .NET 2005
11 – Clique sobre o botão Vermelho.
O formulário Vermelho é aberto, perceba que você pode clicar novamente no Form1
e depois voltar para o Vermelho e assim por diante.
12 – Feche a janela Vermelha e clique agora no botão Verde.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 211
Curso Programando com C# e o Visual Studio .NET 2005
Perceba agora que você não consegue voltar para o Form1 sem antes fechar o
formulário Verde, isso porque usamos o método ShowDialog ao invés do método
Show, geralmente eu procuro usar sempre o método ShowDialog em minhas
aplicações.
Para a próxima lição continuaremos usando este exemplo.
Lição 34 – Passando valores entre Forms
Para esta lição continuaremos usando o exemplo que criamos na lição anterior.
1 – Adicione 1 button e 1 label no formulário frmVermelho conforme a imagem:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 212
Curso Programando com C# e o Visual Studio .NET 2005
2 – Vá para o painel de código do frmVermelho e dentro da classe frmVermelho
digite o seguinte código:
public string mensagem;
Isso cria uma variável publica do tipo string chamada Mensagem.
Usamos a palavra public antes do tipo do dado na declaração de variáveis sempre
que queremos fazê-la publica.
Uma variável publica pode ser acessada por outro formulário.
Vai ficar assim no painel de código:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 213
Curso Programando com C# e o Visual Studio .NET 2005
3 – Vá para o Form1 e de um clique duplo sobre o botão Vermelho.
4 – Adicione o seguinte código:
Vermelho.mensagem = "Formulario Form1";
Vai ficar assim:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 214
Curso Programando com C# e o Visual Studio .NET 2005
5 – Volte para o frmVermelho, de um clique duplo sobre o button1 e digite o
seguinte código no procedimento:
label1.Text = mensagem;
Isso adiciona o conteúdo da variável mensagem no Label1.
6 - Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 215
Curso Programando com C# e o Visual Studio .NET 2005
7 – Clique sobre o botão Vermelho.
8 – No frmVermelho, clique no button1.
O conteúdo da variável foi exibida no label1. O mais importante desta lição é que
você agora é capaz de passar valores entre formulários.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 216
Curso Programando com C# e o Visual Studio .NET 2005
Lição 35 – Posicionando os formulários na tela
1
-
Crie
uma
nova
aplicação
do
tipo
Windows
Application
chamada
Posicionando.
2 - Modifique a propriedade StartPosition do Form1 para CenterScreen.
3 - Execute a aplicação.
Essa propriedade faz com que o formulário em questão seja exibido no centro da
tela.
4 - Pare a execução da aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 217
Curso Programando com C# e o Visual Studio .NET 2005
5 - Modifique agora a propriedade StartPosition do Form1 para Manual.
Agora você deve especificar manualmente como os valores que serão usados para
posicionar o formulário na tela.
6 - Modifique a propriedade Location para 100;50.
7 - Execute a aplicação.
O formulário é exibido agora a 100 pixels da lateral esquerda e 50 pixels do topo da
tela.
Lição 36 – Controlando os eventos dos formulários
1 - Crie um novo projeto no Visual Studio chamado Eventos do tipo Windows
Application.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 218
Curso Programando com C# e o Visual Studio .NET 2005
O clique do botão é um exemplo de evento que pode ocorrer nos seus programas.
Existem dezenas de eventos que podem ocorrer em seus programas, e sempre que
um evento ocorre um bloco de código pode ser processado, esse bloco de código é
conhecido como Manipulador de Evento. O evento que você mais usou até aqui
foi o do clique do botão, também usou o Load do formulário.
O .NET Framework usa uma nomeação padrão para os Manipuladores de
Eventos. Essa nomeação combina o nome do objeto com o evento correspondente
ligando-os por um underline, exemplo: button1_Click; form1_Load.
Nosso exemplo vai nos mostrar como adicionar manipuladores de eventos em
nossos programas usando o painel de código ou Code Pane.
2 – Selecione o Form1 e na janela Properties clique sobre o botão Events.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 219
Curso Programando com C# e o Visual Studio .NET 2005
É exibida uma lista de todos os eventos disponíveis para o Formulário.
Cada objeto possui uma lista de eventos.
3 - Arraste para o Form1 os seguintes controles:
•
1 Label
•
1 TextBox
•
1 Button
4 – Clique sobre cada um dos controles acima e visualize sua lista de eventos.
Para criar o procedimento do evento desejado de um clique duplo sobre o nome do
mesmo na janela Properties.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 220
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 9
Usando controles do Windows Forms
Lição 37 – Usando o controle dateTimePicket
Esse controle permite que o usuário escolha a data ou hora através de um
calendário. Muito util para evitar erros de digitação de data ou hora incorretos.
1 - Crie um nova aplicação chamada DateTimePicket do tipo Windows Forms.
2 - Localize o controle DateTimePicket na ToolBox e adicione-o ao Form1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 221
Curso Programando com C# e o Visual Studio .NET 2005
O objeto DateTimePicket por padrão exibe a data atual, mas você pode ajustar
esse valor na propriedade Value.
3 - Execute sua aplicação.
4 - No controle DataTimePicket, clique na seta para baixo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 222
Curso Programando com C# e o Visual Studio .NET 2005
Você pode escolher a data no calendário. Isso é muito prático e evita erros.
5 – Pare a execução da aplicação.
6 - Arraste um Button para o formulário.
7 - Altere a propriedade Text do Button1 para Aniversário, como a imagem:
8 – De um clique duplo sobre o botão e no seu procedimento de evento clique
digite o seguinte código:
MessageBox.Show("Sua data de aniversário é " + dateTimePicker1.Text);
MessageBox.Show("O dia é " +
dateTimePicker1.Value.DayOfYear.ToString());
MessageBox.Show("Hoje é " + DateTime.Now.ToString());
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 223
Curso Programando com C# e o Visual Studio .NET 2005
A primeira linha usa a propriedade Text para exibir a data que esta selecionada no
controle.
A segunda usa o método DayOfYear para recuperar apenas o dia do ano da data
que esta selecionada no controle.
A terceira linha exibe a data e hora atual usando o método Now da estrutura
DateTime.
9 - Execute a aplicação.
10 - Selecione a data do seu aniverário no controle.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 224
Curso Programando com C# e o Visual Studio .NET 2005
Para encontrar mais facil a data você pode digitar o ano no controle antes de abrir
o calendário para que ele já localize o ano.
11 - Clique no botão aniversário.
A primeira mensagem exibe a data do seu aniversário ou nascimento se você
selecionou o ano em que nasceu.
12 - Clique em OK.
A segunda mensagem exibe o número do dia do seu aniversário ou nascimento em
relação ao ano selecionado.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 225
Curso Programando com C# e o Visual Studio .NET 2005
13 - Clique novamente em OK para exibir a data atual.
14 - Clique em Ok e feche sua aplicação.
Lição 38 – Usando os controles radioButton,
checkBox, listBox e comboBox
Vamos compreender agora como utilizar os controles RadioButton, CheckBox,
ListBox e ComboBox para receber informações dos usuários. Para isso vamos
criar uma simples aplicação que usa os quatro tipos de controles para você
compreender quais as diferenças entre eles, quando e como aplicá-los.
1 - Crie um novo projeto chamado Controles do tipo Windows Application.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 226
Curso Programando com C# e o Visual Studio .NET 2005
2 - Arraste para o Form1 os seguintes controles:
•
2 GroupBox
•
3 RadioButton
•
3 CheckBox
•
1 ListBox
•
1 ComboBox
•
8 Label
3 - Organize-os como a figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 227
Curso Programando com C# e o Visual Studio .NET 2005
4 - Mude a propriedade Text do GroupBox1 para Computadores (apenas um).
5 - Mude a propriedade Text do GroupBox2 para Escritório (0-3).
6 - Mude a propriedade Text do RadioButton1 para PC.
7 - Mude a propriedade Text do RadioButton2 para MAC.
8 - Mude a propriedade Text do RadioButton3 para Notebook.
9 - Mude a propriedade Text do CheckBox1 para FAX.
10 - Mude a propriedade Text do CheckBox2 para Calculadora.
11 - Mude a propriedade Text do CheckBox3 para Copiadora.
12 - Mude a propriedade Text do Label1 para Periféricos (apenas um).
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 228
Curso Programando com C# e o Visual Studio .NET 2005
13 - Mude a propriedade Text do Label2 para Produtos escolhidos.
14 - Mude a propriedade Text dos Labels 3 a 8 para “vazio”.
Deve ficar como a seguinte imagem:
Os 3 RadioButton devem ficar dentro do GroupBox1, assim como os 3
CheckBox devem ficar dentro do GroupBox2, o GroupBox agrupa os controles.
Vamos agora inserir valores na ListBox1.
15 - Clique na ListBox1 e na janela Properties, localize a propriedade Items.
Clique no botão com as reticências nesta propriedade, deve abrir a seguite caixa:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 229
Curso Programando com C# e o Visual Studio .NET 2005
16 - Na janela String Collection Editor digite os items conforme a figura abaixo:
17 - Clique em OK.
Isso deve adicionar os items que digitamos na ListBox1.
18 - Faça o mesmo para o ComboBox1, adicione os seguintes items:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 230
Curso Programando com C# e o Visual Studio .NET 2005
19 - Mude a propriedade Text do ComboBox1 para Forma de Pagamento.
Seu Form1 deve estar semelhante a seguinte imagem:
20 - Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 231
Curso Programando com C# e o Visual Studio .NET 2005
A primeira funcionade que iremos implementar agora é a dos RadioButton. Eles
são usados sempre que o usuário precisa fazer uma escolha única, já que não
permite que mais de um item seja marcado. Podemos também colocar uma escolha
que já aparece marcada como padrão, para isso você deve mudar a propriedade
Checked do RadioButton em questão para True.
21 - Pare a execução do programa.
22 - Mude a propriedade Checked do RadioButton1 para True.
23 - Execute novamente a aplicação. Agora o item PC já apareçe marcado.
24 - Pare novamente a execução do programa. Vamos agora programar o código
para os RadioButtons.
25 - No modo Design, de um clique duplo sobre o RadioButton1 e digite o
seguinte código no procedimento de evento criado:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 232
Curso Programando com C# e o Visual Studio .NET 2005
label3.Text = "PC";
26 - Faça o mesmo para o RadioButton2 e RadioButton3, digitando as seguintes
linhas de código respectivamente:
label3.Text = "MAC";
label3.Text = "Notebook";
Deve ficar assim:
O evento padrão para o RadioButton é o CheckedChanged, que ocorre sempre
que há uma mudança na propriedade Checked. Quando você clica nele o Checked
fica como True, então o evento é disparado e muda a propriedade Text do Label3.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 233
Curso Programando com C# e o Visual Studio .NET 2005
27 - Execute a aplicação e clique sobre as escolhas do RadioButtons para verificar
a funcionalidade que acabamos de colocar.
28 - Pare a execução do programa.
Vamos agora programar o código para os CheckBoxes. Eles são semelhantes ao
RadioButton, no entando permitem mais de uma escolha. Novamente você pode
mudar a propriedade Checked de alguns deles para já iniciarem marcados. São
usados sempre para perguntas que requerem nenhum ou várias respostas como no
nosso exemplo. O usuário pode não querer nenhum item para o escritório, pode
querer um, dois ou todos os items.
29 - De um clique duplo sobre o CheckBox1 e digite o seguinte código:
if (checkBox1.Checked == true)
label6.Text = "Fax";
else
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 234
Curso Programando com C# e o Visual Studio .NET 2005
label6.Text = "";
30 - Faça o mesmo para o CheckBox2 e digite o seguinte código:
if (checkBox2.Checked == true)
label7.Text = "Calculadora";
else
label7.Text = "";
31 - Faça o mesmo para o CheckBox3 e digite o seguinte código:
if (checkBox3.Checked == true)
label8.Text = "Copiadora";
else
label8.Text = "";
32 - Execute sua aplicação. Marque as opções FAX e Copiadora, por exemplo, como
disse podemos marcar mais de um item.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 235
Curso Programando com C# e o Visual Studio .NET 2005
33 - Pare a execução do programa.
34 - De um clique duplo sobre o ListBox1 e digite o seguinte código:
label4.Text = listBox1.SelectedItem.ToString();
Isso escreve o conteúdo do item seleciona na Label4.
35 - Vamos já programar o código para a ComboBox também, de um clique duplo
sobre a mesma no modo Design para abrir o procedimento de evento padrão e
digite o seguinte código:
label5.Text = comboBox1.SelectedItem.ToString();
36 - Execute sua aplicação.
37 - Teste todas as escolhas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 236
Curso Programando com C# e o Visual Studio .NET 2005
Agora você já é capaz de pegar informações dos usuários de várias maneiras.
Procure utilizar sempre os controles aprendidos neste capitulo, eles impedem
muitos erros nos programas por impedirem entradas de dados inválidas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 237
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 10
Bancos de dados com ADO.NET
Lição 39 – Conceitos básicos de banco de dados
Tudo o que aprendemos até aqui é relacionado à interface com o usuário ou Front
End, esse acessa os dados nos bancos de dados. Um banco de dados é uma
coleção organizada de informações armazenadas. Você pode criar poderosos banco
de dados usando ferramentas da própria Microsoft como SQL Server e Access e
outros de terceiros como Paradox, Oracle, etc, ou seja, você não usa o Visual
Basic.NET para criar bancos de dados, mas para exibir, analisar, e manipular as
suas informações.
Para manipular os dados você precisa entender os conceitos básicos.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 238
Curso Programando com C# e o Visual Studio .NET 2005
A imagem acima representa uma tabela em um banco de dados. Esta tabela
armazena as informações dos clientes. Cada linha representa um registro. Cada
registro na nossa tabela clientes representa um cliente especifico. Cada coluna
representa um campo, sendo cada campo uma informação do cliente, como nome
e telefone. Podemos ter mais informações como endereço, cep, etc. Um banco de
dados pode e geralmente contem varias tabelas. Outras tabelas no nosso banco de
dados de clientes poderiam ser produtos, vendedores, etc.
Para criar o banco de dados que vamos utilizar nos exemplos deste capitulo vamos
usar o Access. O Access é instalado junto com o Microsoft Office, se sua versão for
a 2003, ele deve estar em Iniciar > Programas > Microsoft Office > Microsoft
Office Access 2003. Você pode usar qualquer versão do Access para os exemplos
deste capítulo.
1 - Entre no Access.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 239
Curso Programando com C# e o Visual Studio .NET 2005
2 - No menu Arquivo clique em Novo.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 240
Curso Programando com C# e o Visual Studio .NET 2005
3 - Crie uma pasta chamada ADONET no local que você esta criando seus
exemplos, navegue até essa pasta e crie o banco com o nome dados.mdb.
4 - Na janela dados:Banco de dados, de um clique duplo em Criar tabela no
modo Design.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 241
Curso Programando com C# e o Visual Studio .NET 2005
5 - Digite em Nome do campo e Tipo de dados os itens como na figura abaixo.
Note que o campo id contêm uma chave, para adiciona-lá com o campo id
selecionado clique em Chave Primaria na barra de ferramentas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 242
Curso Programando com C# e o Visual Studio .NET 2005
6 - Na janela Tabela1:Tabela clique em fechar, você vai receber a seguinte
mensagem:
7 - Clique em Sim.
8 - Em Nome da tabela digite Clientes e clique em OK.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 243
Curso Programando com C# e o Visual Studio .NET 2005
A tabela clientes é criada.
9 - De um clique duplo sobre ela e digite o nome e telefone de 10 pessoas, como a
figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 244
Curso Programando com C# e o Visual Studio .NET 2005
Note que não é necessário digitar o Id porque ele é adicionado automaticamente,
isso porque selecionamos numeração automatica quando criamos o campo. O id é o
campo que identifica individualmente cada registro no banco de dados. Por isso
marcamos ele com a chave primaria, podem ter dois clientes com o mesmo nome,
mas não com o mesmo id em nossa tabela.
10 - Feche o Access.
Lição 40– Usando o Visual Studio 2005 para
manipular dados de um banco de dados.
1 - Crie uma nova aplicação chamado ADONET do tipo Windows Application.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 245
Curso Programando com C# e o Visual Studio .NET 2005
2 – No menu Data, clique em Add New Data Source.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 246
Curso Programando com C# e o Visual Studio .NET 2005
Nesta janela podemos escolher qual a origem dos dados.
3 – Selecione Database na janela Data Source Configuration Wizard e clique em
Next.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 247
Curso Programando com C# e o Visual Studio .NET 2005
Escolhemos que nossa origem de dados será um banco de dados, agora criaremos
uma nova conexão com o banco de dados.
4 – Clique no botão New Connection.
5 – Na janela Choose Data Source, selecione Microsoft Access Database File, já que
criamos nosso banco de dados no Access.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 248
Curso Programando com C# e o Visual Studio .NET 2005
6 – Ainda na janela Choose Data Source, clique em Continue.
7 – Aparece a janela Add Connection. Nela selecionaremos o nosso banco de dados
clicando em Browse. Se configuramos uma senha no nosso banco de dados
especificamos as mesmas nesta janela também.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 249
Curso Programando com C# e o Visual Studio .NET 2005
8 – Clique em Browse e selecione o arquivo de banco de dados dados.mdb que
criamos, conforme a imagem seguinte.
9 – Clique em Test connection para testar a conexão, após clique em OK.
Voltando a janela Data Source Configuration Wizard podemos ver a string de
conexão criada, basta clicar em + Connection string.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 250
Curso Programando com C# e o Visual Studio .NET 2005
10 – Clique em Next. A seguinte mensagem é exibida:
Se você clicar em sim o Visual Studio criará automaticamente uma copia do banco
de dados para dentro do projeto e corrigira a string de conexão para o uso do
mesmo.
11 –Clique em Sim.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 251
Curso Programando com C# e o Visual Studio .NET 2005
12 - A tela acima permite que salvemos a string de conexão em um arquivo de
configuração XML, certifique-se que Yes, save the connection as estaja marcado e
clique em Next.
13 - A tela seguinte permite que escolhamos as tabelas e consultas que desejamos
usar em nosso programa, marque todas as opções em clique em Finish.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 252
Curso Programando com C# e o Visual Studio .NET 2005
14 – No menu Data, clique em Show Data Sources, a seguinte janela é aberta:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 253
Curso Programando com C# e o Visual Studio .NET 2005
Nesta janela configuramos como os controles de tela devem ser criados baseados
nos campos das tabelas do banco de dados.
15 – Clique em + Clientes para espandir os campos.
16 – Arraste Clientes para o formulário, ele deve ficar como a seguinte figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 254
Curso Programando com C# e o Visual Studio .NET 2005
Perceba que ele já cria automaticamente os controles necessários para o acesso e
atualização dos dados, assim como um controle DataGridView para manipular os
mesmos.
17 – Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 255
Curso Programando com C# e o Visual Studio .NET 2005
Você já pode navegar, incluir, excluir e alterar os registro da tabela.
18 – Pare a execução do programa.
19 – Apague todos os controles do Form1.
20 – Na janela Data Sources, clique na seta para baixo de Clientes e selecione
Detais.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 256
Curso Programando com C# e o Visual Studio .NET 2005
21 – Arraste novamente Clientes para o formulário.
Novamente são criados todos os controles necessários para a manipulação dos
dados, só que desta vez não é usado o DataGridView.
22 – Execute a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 257
Curso Programando com C# e o Visual Studio .NET 2005
Novamente você pode navegar, incluir, excluir e alterar os registro da tabela.
23 – Pare a execução do programa.
Você também pode configurar individualmente como será exibido cada campo da
tabela através da janela Data Sources. Basta clicar na seta para baixo do campo
conforme a próxima imagem:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 258
Curso Programando com C# e o Visual Studio .NET 2005
Agora você já é capaz de manipular dados em seus programas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 259
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 11
Imprimindo
Lição 41 – Imprimindo a partir de uma textBox
1 - Crie um nova aplicação chamada Impressão, do tipo Windows Application.
2 - Adicione os seguintes controles no Form1:
•
3 Button
•
1 TextBox
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 260
Curso Programando com C# e o Visual Studio .NET 2005
•
1 PrintDocument
•
1 PrintDialog
•
1 PageSetupDialog
•
1 PrintPreviewDialog
3 - Mude as seguintes propriedades do TextBox1:
Multiline = True
ScrollBars = Vertical
4 - Mude a propriedade Text do Button1 para Imprimir.
5 - Mude a propriedade Text do Button2 para Configurar Impressão.
6 - Mude a propriedade Text do Button3 para Visualizar Impressão.
7 - Organize os 3 botões e o TextBox como a figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 261
Curso Programando com C# e o Visual Studio .NET 2005
8 - Na janela Solution Explorer clique no botão View Code.
9 - No topo do código do formulário digite o seguinte código:
using System.Drawing.Printing;
Isso permite que usemos a classe PrintDocument, ela fica localizada dentro do
namespace System.Drawing.Printing. A linha acima permite que usemos o
namespace em questão dentro código do Form1.
Namespaces organizam as classes com o objetivo de facilitar sua implementação.
10 - Dentro da classe digite:
PageSettings configuracaoDepagina = new PageSettings();
string stringParaImprimir;
Font fontParaImprimir = new Font("Arial", 10);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 262
Curso Programando com C# e o Visual Studio .NET 2005
Como pode perceber no código acima criamos 3 variáveis que vão armazenar
informações importantes que ficarão disponiveis para todos os procedimentos da
classe Form1.
O código digitado até aqui deve estar assim no painel de código:
11 - De um clique duplo sobre o Button1 (Imprimir) no modo design e digite o
seguinte código no procedimento do botão:
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
printDocument1.Print();
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 263
Curso Programando com C# e o Visual Studio .NET 2005
12 - Vá para o modo design novamente e de um clique duplo sobre o controle
PrintDocument1.
O Visual Studio cria para o PrintDocument1 um procedimento de evento que será
executado sempre que for solicitada a impressão de uma página.
13 - Digite o seguinte código para o procedimento printDocument1_PrintPage:
int numeroLinhas;
int numeroCaracteres = 0;
string stringParaPagina;
StringFormat formataString = new StringFormat();
RectangleF areaPagina = new
RectangleF(e.MarginBounds.Left, e.MarginBounds.Top,
e.MarginBounds.Width, e.MarginBounds.Height);
SizeF areaLinha = new SizeF(e.MarginBounds.Width,
e.MarginBounds.Height - fontParaImprimir.GetHeight(e.Graphics));
formataString.Trimming = StringTrimming.Word;
e.Graphics.MeasureString(stringParaImprimir,
fontParaImprimir, areaLinha, formataString, out numeroCaracteres, out
numeroLinhas);
stringParaPagina = stringParaImprimir.Substring(0,
numeroCaracteres);
e.Graphics.DrawString(stringParaPagina, fontParaImprimir,
Brushes.Black, areaPagina, formataString);
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 264
Curso Programando com C# e o Visual Studio .NET 2005
if (numeroCaracteres < stringParaImprimir.Length)
{
stringParaImprimir =
stringParaImprimir.Substring(numeroCaracteres);
e.HasMorePages = true;
}
else
{
e.HasMorePages = false;
stringParaImprimir = textBox1.Text;
}
Esse procedimento de eventos define a área da página que vai ser impressa, se for
preciso dividir o texto em linhas e páginas esse procedimento também se
responsabilizará por isso.
A área de impressão é definida usando a variável areaPagina, que é baseada na
classe RectangleF.
RectangleF areaPagina = new RectangleF(e.MarginBounds.Left,
e.MarginBounds.Top, e.MarginBounds.Width, e.MarginBounds.Height);
A variável formataString usa o método Trimming para determinar quanto texto
pode ajustar em uma página.
formataString.Trimming = StringTrimming.Word;
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 265
Curso Programando com C# e o Visual Studio .NET 2005
O código abaixo assegura que o texto não seja cortado na página:
e.Graphics.MeasureString(stringParaImprimir, fontParaImprimir,
areaLinha, formataString, out numeroCaracteres, out numeroLinhas);
Depois o texto é impresso na página através do método DrawString.
e.Graphics.DrawString(stringParaPagina, fontParaImprimir,
Brushes.Black, areaPagina, formataString);
O If é usado para verificar se é necessário mais de uma página para imprimir o
texto em questão, para tanto ele usa a propriedade HasMorePages.
if (numeroCaracteres < stringParaImprimir.Length)
{
stringParaImprimir = stringParaImprimir.Substring(numeroCaracteres);
e.HasMorePages = true;
}
else
{
e.HasMorePages = false;
stringParaImprimir = textBox1.Text;
}
Talvez o procedimento do evento PrintDocument1_PrintPage tenha sido um
pouco complicado comparado com os demais vistos neste curso, não se preocupe,
com pouco tempo de experiência você será capaz de compreende-lo com facilidade.
14 - Execute sua aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 266
Curso Programando com C# e o Visual Studio .NET 2005
15 - Digite algum texto na caixa de texto, e clique no botão imprimir.
O texto deve ser impresso. A seguinte caixa de diálogo é exibida.
16 - Pare a execução do programa.
Vamos implementar agora o código que permite que o usuário escolha a impressora
e o número de páginas que deseja imprimir.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 267
Curso Programando com C# e o Visual Studio .NET 2005
17 - Volte novamente para o procedimento do evento do botão Imprimir e altere o
código para o seguinte:
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
DialogResult resultado = new DialogResult();
resultado = printDialog1.ShowDialog();
if (resultado == DialogResult.OK)
printDocument1.Print();
18 - Execute a aplicação.
19 - Digite algum texto na caixa de texto, e clique no botão imprimir.
Agora antes da impressão é exibida a janela Imprimir que permite que o usúario
escolha a impressora e o número de cópias.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 268
Curso Programando com C# e o Visual Studio .NET 2005
20 - Clique em OK para imprimir ou Cancelar para fechar a janela Imprimir e
voltar ao Form1 sem realizar a impressão.
21 - Pare a execução do programa.
Vamos implementar o código agora que permite a configuração da impressão.
22 - De um clique duplo sobre o Button2 (Configurar Impressão) e digite o
seguinte código pra o procedimento do evento:
pageSetupDialog1.PageSettings = configuracaoDepagina;
pageSetupDialog1.ShowDialog();
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 269
Curso Programando com C# e o Visual Studio .NET 2005
Esse é o código que exibe a janela de configuração da impressão e armazena os
valores selecionados na variável ConfiguracaoDePagina.
23 - Adicione a seguinte linha de código no procedimento do evento click do
Button1.
printDocument1.DefaultPageSettings = configuracaoDepagina;
O procedimento vai ficar assim:
printDocument1.DefaultPageSettings = configuracaoDepagina;
stringParaImprimir = textBox1.Text;
printDialog1.Document = printDocument1;
DialogResult resultado = new DialogResult();
resultado = printDialog1.ShowDialog();
if (resultado == DialogResult.OK)
printDocument1.Print();
24 - Execute a aplicação.
25 - Clique no botão Configurar Impressão.
A janela Configurar página é exibida com as opções de configuração.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 270
Curso Programando com C# e o Visual Studio .NET 2005
26 - Clique em OK.
27 - Pare a execução do programa.
Vamos agora implementar o código para Visualizar a Impressão.
28 - No modo design de um clique duplo sobre o Button3 e digite o seguinte
código:
pageSetupDialog1.PageSettings = configuracaoDepagina;
stringParaImprimir = textBox1.Text;
printPreviewDialog1.Document = printDocument1;
printPreviewDialog1.ShowDialog();
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 271
Curso Programando com C# e o Visual Studio .NET 2005
As duas primeiras linhas de código são as mesmas usadas no Button1, a terceira
indica que o documento a ser visualizado é o PrintDocument1, a última linha
exibe a visualização.
29 - Execute a aplicação.
30 - Digite algum texto e clique no botão Visualizar Impressão.
Se você quizer imprimir diretamente da janela Visualizar Impressão é só clicar na
Impressora. Você também tem opções de Zoom, seleção de páginas e possibilidade
de visualizar várias páginas de uma só vez na tela.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 272
Curso Programando com C# e o Visual Studio .NET 2005
31 - Clique em Close para fechar o Visualizar Impressão.
32 - Para a aplicação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 273
Curso Programando com C# e o Visual Studio .NET 2005
Módulo 12
Distribuindo sua aplicação
Depois de pronta sua aplicação precisa ser distribuida para todos que querem ou
precisam usá-la. Para usar a sua aplicação, o único requisito para o computador do
cliente é que tenha instalado o .NET Framework. Este pode ser instalado
diretamente do site da Microsoft, ou ser disponibilizado com sua aplicação no
pacote de instalação. Ele também é disponível através do Windows Update e
futuramente deve vir junto com todos os sistemas operacionais da Microsoft. Então,
tendo o .NET Framework instalado na máquina, para sua aplicação funcionar
basta você copiar o arquivo executável para a máquina em questão e executá-lo.
No entanto essa prática não é muito recomendada, é mais elegante criar um pacote
de instalação para instalar o programa, permitindo assim também sua possivel
desinstalação através do Painel de Controle, Adicionar/Remover programas.
O .NET Framework não funciona no Windows 95, então não será possivel rodar sua
aplicação neste sistema operacional.
As versões Windows 98, ME, NT 4.0, 2000 e XP permitem a instalação do .NET
Framework sem problemas.
Programas que usam o Access como banco de dados também precisam que o
arquivo do Access seja copiado junto com a instalação. Não é necessário ter
instalado na máquina que vai o rodar o programa o Microsoft Access, o .NET
Framework já contém as classes necessárias para usar o arquivo. Tenha atenção
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 274
Curso Programando com C# e o Visual Studio .NET 2005
com o caminho do banco de dados durante a execução em outros computadores, se
o caminho estiver errado a aplicação não vai funcionar corretamente.
Durante este capitulo você vai aprender a criar o pacote de instalação para os seus
programas.
Lição 42 – Criando um projeto de instalação
Neste capitulo usaremos o projeto criado na lição 33 – Trabalhando com múltiplos
formularios.
1 - Abra no Visual Studio o programa Formularios para Windows Form.
2 - No menu File clique aponte em New e clique em New Project.
3 - Na janela New Project, em Project Type, selecione Setup and Deployment
Projects.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 275
Curso Programando com C# e o Visual Studio .NET 2005
Repare em Templates nas seguites opções:
Setup Project - cria programa de instalação que usa o Windows Installer.
Web Setup Project - usa o Windows Installer e um
Servidor Web para
disponibilidar a aplicação.
Merge Module Project - cria um arquivo de instalação do tipo msm que pode ser
usado por outras aplicações.
Cab Project - usado quando você precisa de arquivos de instalação com tamanho
especifico. Se por exemplo sua aplicação tem 30MB e você quer disponibiliza-la na
internet, pode criar 3 arquivos de 10MB para facilitar o download.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 276
Curso Programando com C# e o Visual Studio .NET 2005
Smart Device CAB Project – usado para criação de projeto instalação para
dispositivos móveis.
Setup Wizard - é um assistente, através dele você pode criar os tipos citados
acima só que de maneira simplificada.
4 – Selecione Setup Wizard.
5 – Em Solution, selecione Add to Solution como a imagem:
Isso adiciona o projeto a solução que esta aberta no Visual Studio, se estiver
marcado Create new Solution, o projeto aberto é fechado e é criado um novo
projeto.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 277
Curso Programando com C# e o Visual Studio .NET 2005
6 - Em Name você pode dar uma nome para seu projeto de instalação, neste
exemplo deixarei o padrão.
7 - Clique em OK.
O Assistente é iniciado.
8 - Clique em Next.
9 - O segundo passo é informar o assistente para que tipo de aplicação estamos
criando a instalação. Deixe marcado a opção Create a setup for a Windows
Application e clique em Next.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 278
Curso Programando com C# e o Visual Studio .NET 2005
Isto informa que nossa aplicação é do tipo Windows Application e para tal
estamos criando o projeto de instalação.
Na próxima caixa de diálogo você escolhe os arquivos adicionais que podem ser
incluidos na instalação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 279
Curso Programando com C# e o Visual Studio .NET 2005
10 - Marque a opção Primary output from Formularios e clique em Next.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 280
Curso Programando com C# e o Visual Studio .NET 2005
Isso inclui na instalação arquivos EXE e DLL do projeto.
Se tiver arquivos adicionais para serem adicionados ao projeto como o arquivo do
banco de dados do Access ou algum TXT com informações sobre o projeto clique
em Add para adicionar o arquivo no passo 4 do assistente.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 281
Curso Programando com C# e o Visual Studio .NET 2005
11 - Clique em Next.
O passo 5 do assistente apenas exibe um resumo das opções escolhidas.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 282
Curso Programando com C# e o Visual Studio .NET 2005
12 - Clique em Finish.
O Visual Studio adiciona um novo projeto na solução chamado Setup1, como você
pode ver no Solution Explorer.
O File System Editor também apareçe como mostra a figura.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 283
Curso Programando com C# e o Visual Studio .NET 2005
Você usa o File System Editor para adicionar arquivos no seu projeto de
instalação e criar os atalhos do menu Iniciar e Desktop para sua aplicação.
13 - No File System Editor com a pasta Application Folder aberta, de um clique
com o botão direito do mouse em Primary Output from Formularios. No menu
que se abre clique em Create Shortcut to Primary output from Formularios.
Isso cria um atalho para a aplicação como mostra a figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 284
Curso Programando com C# e o Visual Studio .NET 2005
14 - Mude o nome do atalho para Formularios.
15 - Arraste o atalho para a pasta User’s Programs Menu.
Isso adiciona um atalho para a aplicação no menu Iniciar.
16 - Clique na pasta User’s Program Menu.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 285
Curso Programando com C# e o Visual Studio .NET 2005
Quando a aplicação for instalada, um atalho para a mesma será criado no menu
Iniciar > Programas. Você pode adicionar também o atalho no Desktop para
isso arraste uma cópia do mesmo para a pasta User’s Desktop.
17 - Clique em Setup1 na janela Solution Explorer e veja as propriedades
disponíveis na janela Properties.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 286
Curso Programando com C# e o Visual Studio .NET 2005
A propriedade Author e Manufacturer são geralmente preenchidas com o nome
da companhia que desenvolve o software, seus valores também são usados para
construir o caminho padrão onde será instalado o programa. Uma vez instalado o
programa a propriedade Author é exibida nas informações de suporte em
Adicionar/Remover Programas no Painel de Controle.
A propriedade Title é o nome do programa de instalação e a propriedade Version
permite especificar informações sobre a versão do seu programa de instalação. As
propriedades Product Code contém informações geradas pelo Visual Studio que
permitem identificar individualmente distribuições do seu programa.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 287
Curso Programando com C# e o Visual Studio .NET 2005
Atenção, estas propriedades dizem respeito ao programa de instalação e não a
aplicação Formularios.
18 - Na janela Solution Explorer, clique com o botão direito do mouse sobre
Setup1 e clique e em Properties.
É exibida a caixa de diálogo Setup1 Property Pages. Esta caixa de diálogo
permite que você altere algumas das opções escolhidas no assistênte (Setup
Wizard) caso necessário e customize algumas configurações adicionais que não
estavam disponíveis no assistente.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 288
Curso Programando com C# e o Visual Studio .NET 2005
A caixa Output File Name especifica o nome do arquivo da instalação. Geralmente
ele contém a extensão .msi por ser usado pelo Windows Installer.
A caixa de seleção Package Files contém 3 opções:
As Loose Uncompressed Files - cria arquivos descompactados dentro da pasta
de instalação.
In Setup File - é a que cria o arquivo msi.
Cabinet Files(s) - gera os arquivos cab na pasta de instalação.
A caixa de seleção Compression permite escolher a otimização da compactação
dos arquivos de intalação, a maior parte dos programadores escolhe Optimized
for Size, que prioriza diminuir o tamanho dos arquivos de instalação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 289
Curso Programando com C# e o Visual Studio .NET 2005
19 - Clique em OK.
20 - Um passo importante, simples e que não deve ser esquecido é mudar para
Release na barra de ferramentas a caixa de seleção Solution Configurations.
Quando estamos criando nossa aplicação é importante que esta caixa de seleção
esteja marcada com Debug para que possamos usar as ferramentas de depuração
de erros do Visual Studio. Com o Debug marcado o programa é compilado com
informações extras para permitir a depuração dos erros, essas informações não são
necessárias quando estamos disponibilizando nossa aplicação e também ocasionam
perda de performance na nossa aplicação.
21 - Na janela Solution Explorer, clique com o botão direito do mouse em
Setup1, selecione View, clique em Launch Condition.
É aberta a página Launch Condition como mostra a figura:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 290
Curso Programando com C# e o Visual Studio .NET 2005
22 - Na pasta Lauch Condition, clique em .NET Framework.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 291
Curso Programando com C# e o Visual Studio .NET 2005
Na janela Properties a propriedade InstallUrl é setada com uma página na
Internet que possibilita o download e instalação do .NET Framework, como sabe,
necessário para sua aplicação funcionar. Por padrão sempre que é inicializado a
instalação é verificado se o .NET Framework esta instalado na máquina em questão
ou não. Se não estiver ele usa essa propriedade, a InstallUrl para fazer o
download e instalação do arquivo Dotnetfx.exe, que instala o .NET Framework.
Antes de iniciar o download e instalação da Internet ele emite uma mensagem, o
contéudo desta mensagem está na propriedade Message.
Você pode disponibilizar o .NET Framework junto com sua instalação, para que não
seja necessário baixar o arquivo da internet. Para isso você muda a propriedade
InstallUrl para o caminho da sua instalação e se desejar muda a propriedade
Message para um mensagem mais apropriada. Será necessário copiar então o
arquivo Dotnetfx.exe para a pasta de instalação do seu programa ou para a pasta
que você indicar em InstallUrl.
Vamos deixar como está, para fazer o download se necessário.
23 -Na janela Solution Explorer, clique com o botão direito sobre Setup1, depois
clique em Build.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 292
Curso Programando com C# e o Visual Studio .NET 2005
Isto vai compilar e executar o projeto de instalação Setup1.
24 - No Windows Explorer localize a pasta do projeto Setup1, ela foi especificada
quando você criou o projeto.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 293
Curso Programando com C# e o Visual Studio .NET 2005
25 - Entre na pasta Release.
Eis os arquivos necessários para a instalação do seu projeto, você pode copiados
em um CD para disponibilizar a instalação do seu programa, como citado
anteriormente você pode copiar para esta pasta também o arquivo Dotnetfx.exe
para disponibilizar junto a instalação do .NET Framework.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 294
Curso Programando com C# e o Visual Studio .NET 2005
Lição 43 – Executando o programa de instalação
Vamos agora efetuar a instalação do programa Formularios à partir do projeto da
instalação que criamos na lição anterior comparando o processo com as
configurações que fizemos no projeto Setup1.
1 - Na pasta de instalação de um clique duplo em Setup.exe para iniciar a
instalação.
É iniciado o processo de instalação com a seguinte tela:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 295
Curso Programando com C# e o Visual Studio .NET 2005
2 - Clique em Next.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 296
Curso Programando com C# e o Visual Studio .NET 2005
Você vê e pode alterar a pasta de instalação do programa, note que o caminho é
C:\Arquivos de programas\HM\Setup1\, “HM” é o conteúdo da propriedade
Manufacturer, como comentamos na seção anterior. As opções Everyone e Just
me tem a ver com a segurança do Windows. Se você quer disponibilizar o
programa apenas para o seu usuário na máquina, marque a opção Just me, se
todos os usuários podem executar essa aplicação, marque a opção Everyone.
3 - Clique em Everyone.
4 - Clique em Next.
É exibida a tela de confirmação da instalação.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 297
Curso Programando com C# e o Visual Studio .NET 2005
5 - Clique em Next novamente.
É iniciada a instalação:
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 298
Curso Programando com C# e o Visual Studio .NET 2005
Após concluida a instalação é exibida o tela Installation Complete.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 299
Curso Programando com C# e o Visual Studio .NET 2005
6 - Clique em Close para finalizar o instalador. Sua aplicação já foi instalada.
7 - Para executar sua aplicação no menu Iniciar > Programa, clique em
Formularios.
Uma vantagem de usar o Installer é que o programa é registrado no Windows
possibilitando sua possivel desinstalação através do Painel de Controle. Para
finalizar este capítulo vamos desinstalar nosso programa.
8 - Entre no Painel de Controle > Adicionar/Remover Programas.
9 - Localize o programa Setup1.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 300
Curso Programando com C# e o Visual Studio .NET 2005
Se você tivesse apenas copiado seu programa para a máquina de destino ele não
apareceria nesta lista.
10 - Clique em Clique aqui para obter informações de suporte.
Veja que ele mostra as propriedades conforme comentamos na seção anterior.
11 - Clique em Fechar.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 301
Curso Programando com C# e o Visual Studio .NET 2005
12 - Clique em Remover.
É exibida a seguinte caixa de mensagem:
13 - Clique em Sim.
O programa é desinstalado.
Autor: Herbert Moroni Cavallari da Costa Gois
Site:
www.juliobattisti.com.br e www.linhadecodigo.com.br
Confira também o curso: “Programando com VB.NET”
Página 302