Programando com c# e visual studio net 2005

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



Nota sobre direitos autorais:

Este e-book é de autoria de Herbert Moroni Cavallari da Costa Gois, sendo

comercializado diretamente através do site www.juliobattisti.com.br e

www.linhadecodigo.com.br ou através do site de leilões Mercado Livre:

www.mercadolivre.com.br, mediante contato através do email:

[email protected] ou [email protected], 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

[email protected], 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 e-

mail: [email protected].

Visite periodicamente o site www.juliobattisti.com.br para ficar por dentro das

novidades:

• Cursos de informática.



• 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 gratuitos, em português, para os exames da Microsoft.

• ESTE E-BOOK NÃO PODE SER FORNECIDO EM UM CD

OU DVD DE NENHUMA REVISTA

• SE VOCÊ OBTEVE UMA CÓPIA DESTE E-BOOK

ATRAVÉS DO E-MULE, KAZAA, MORPHEUS OU

OUTRO PROGRAMA DE 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



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.



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 é [email protected] ou

[email protected].

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.



Í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



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



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



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



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.



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:

[email protected].



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.



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.



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.



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:



• 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.



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.



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:



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.



11 – Feche os parênteses ) e digite ponto-e-virgula, vai ficar assim:



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:



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.



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.



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.



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.



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.



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

{



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.



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.



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.



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

{


{

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



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.



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



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.



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.



4 – Arraste da barra de ferramentas o controle Label e posicione-o no canto

superior esquerdo do formulário.



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:



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;



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 ...

{

...

}

}



• 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.



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";



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();

}...



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.



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.



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:


{

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.



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.



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



/// 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.



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.



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.



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>



Abaixo segue uma lista das tags XML mais usadas. Lembre-se que com XML você

pode criar suas próprias tags.

TAG PROPÓSITO

<summary> … </summary> 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



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.



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.



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.



• 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.



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:



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;



• 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:



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



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.



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.



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.



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;



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.



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.



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



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”);



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.



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



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.



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;



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;


}


{

resultado = primeiroValor * segundoValor;


}

else if(radioButton4.Checked)

{

resultado = primeiroValor / segundoValor;


}

else if(radioButton5.Checked)

{

resultado = primeiroValor % segundoValor;


}



Digitamos nosso código dentro do procedimento:


{

}

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);



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


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.


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.


9 – Digite 9 para o valor1 e 2 para o valor2, selecione adição e clique em calcular.



Faça testes com os outros operadores.

Subtração:

Multiplicação:



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.



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



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.



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.



• 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

//...

}



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:


{

//...

return numeroPequeno + numeroGrande;

}



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



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:


{

//...

return numeroPequeno + numeroGrande;

}

Este método tem dois parâmetros entre os parênteses, para chamá-lo, faça assim:

adicionarValores(39,3)



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.



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



}

}

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;



}

}

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.



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.



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);


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.Text;

namespace Metodo

{

class Program



{


{




}


{




}


{

}

}

}

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.



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.Text;



namespace Metodo

{

class Program

{


{




}


{




}


{


}


{


}




{

}

}

}

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));

}



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:


{

(new Program()).executar();

}

11 – Pressione Ctrl+F5 para executar o programa.

O Visual Studio compila o programa e o executa. Uma janela console aparece.



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.Text;

namespace Metodo

{

class Program

{


{






}


{




}


{


}


{


}

public void executar()

{


int dias = lerInteiro("Digite o numero de dias: ");

escrever(calcular(taxadiaria, dias));

}


{

(new Program()).executar();



}

}

}

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:


17 – Clique com o botão direito do mouse sobre ela, no menu que se abre clique

em Run To Cursor.



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.



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.



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: ”



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.



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.



25 – Clique em Step Into.

A seta se move para a terceira linha de código do método executar.


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.


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:



Parabéns, você escreveu métodos e os chamou com sucesso, alem disso usou o

depurador do Visual Studio .NET.



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)



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 )



{

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



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.


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.


if (Salario < 500)

Salario += 50;

else if ((Salario >= 500) && (Salario < 2000))

Salario += 100;

else

Salario += 250;



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:


if (Salario < 500)

Salario += 50;


Salario += 100;


Salario += 110;


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:




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:



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



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:



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.




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");



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:



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

}



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");



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;



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.



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:



O Form1 vai ficar assim:

3 – De um clique duplo sobre o listBox1 e digite o seguinte código:



switch (Convert.ToString(listBox1.SelectedItem))

{

case "Fevereiro" :

MessageBox.Show ("Este mes tem 28 dias");

break;

case "Abril":

case "Junho":

case "Setembro":

case "Novembro":


break;

default:


break;

}

Vai ficar assim:



4 – Execute a aplicação (pressione F5).



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 :


break;

case 4:



case 6:

case 9:

case 11:


break;

default:


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;



• 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.



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.



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:



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:



Esse é nosso código, vamos estudá-lo um pouco:

int contador = 0;


{

contador++;


}

Na primeira linha declaramos uma variável chamada contador do tipo integer e

atribuimos a essa variavel o valor 0.



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.



• 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:



int contador = 0;


{

contador++;


}

3 - Mude para o seguinte:

int contador = 0;


{

contador++;

if (contador == 10)

{

break;

}


}

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:



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++;




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.



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.



2 - Arraste para o Form1 um Button.

3 - Mude a propriedade Text do Button1 para “Beep”.



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.



6 - Clique no botão Beep.

Vamos dar uma avaliada no código:

for (int i = 1; i <= 4; i++)

{


}

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.



7 - Mude o código do botão para o seguinte:

for (int i = 1; i <= 25; i+=5)

{


}

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.



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.



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.



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.



2 - Arraste para o Form1 os seguintes controles e organize-os como a figura

abaixo:

• 1 Button

• 2 TexBox



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:




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.


int idade;



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.



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.



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.



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.



14 - Vá ao painel de código novamente.

15 - Localize a seguinte linha de código.


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:



O BreakPoint é um ponto de parada. Você pode colocar vários destes no seu

código.

17 - Execute o programa agora.


O programa a execução exatamente na linha do BreakPoint.



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.



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.



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.



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:




2 - Execute o programa.


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:



É 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.



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.



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.



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.



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.



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.



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



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.



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:



Eu redimencionei tanto o tamanho do Form1 como o tamanho do PictureBox1,

você pode fazer o mesmo utilizando as guias.


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:




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



{


}

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.


16 - Sem o disquete no drive clique no botão Testar Drive.



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:



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.



try

{


}

catch

{


}

Vamos agora implementar o Finally no nosso código.

20 - Altere o código do evento do Button1 para o seguinte:

try

{


}

catch

{


}

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.




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:



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

{


}

catch

{


try



{

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

{


}

catch

{


try



{

pictureBox1.Image = pictureBox1.Image =

System.Drawing.Image.FromFile(@"a:\inverno.jpg");

}

catch

{

MessageBox.Show("Falha ao abrir o arquivo");


}

}

Vai ficar assim:

2 - Execute aplicação e sem o disco no drive clique no botão Testar Drive.



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:




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"))

{


}

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



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

{


}



catch

{

retorno += 1;

if (retorno <= 2)

{


}

else

{

MessageBox.Show("Recurso não disponivel");


}

}



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.



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”.



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:



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.


jogadores[0] = textBox1.Text;



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.




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.



18 – Pare a execução.


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

{


}

Vai ficar assim:



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.



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.



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.


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.



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];



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.


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

{




}

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;



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



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.



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.



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:




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.



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:





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.



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;





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.



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.



2 – Digite um nome para o novo formulário e clique em Add.



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:



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:



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:



9 – Faça o mesmo para o botão Verde mas digite o seguinte código:

frmVerde Verde = new frmVerde();

Verde.ShowDialog();




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.



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:



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:



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:



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.




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.



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.


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.



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.


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.



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.



É exibida uma lista de todos os eventos disponíveis para o Formulário.

Cada objeto possui uma lista de eventos.


• 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.



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.



O objeto DateTimePicket por padrão exibe a data atual, mas você pode ajustar

esse valor na propriedade Value.


4 - No controle DataTimePicket, clique na seta para baixo.



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


MessageBox.Show("Sua data de aniversário é " + dateTimePicker1.Text);

MessageBox.Show("O dia é " +

dateTimePicker1.Value.DayOfYear.ToString());

MessageBox.Show("Hoje é " + DateTime.Now.ToString());



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.


10 - Selecione a data do seu aniverário no controle.



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.



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.




• 2 GroupBox

• 3 RadioButton

• 3 CheckBox

• 1 ListBox

• 1 ComboBox

• 8 Label

3 - Organize-os como a figura:



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).



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:



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:



19 - Mude a propriedade Text do ComboBox1 para Forma de Pagamento.

Seu Form1 deve estar semelhante a seguinte imagem:




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.


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:



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.



27 - Execute a aplicação e clique sobre as escolhas do RadioButtons para verificar

a funcionalidade que acabamos de colocar.


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



label6.Text = "";

30 - Faça o mesmo para o CheckBox2 e digite o seguinte código:


label7.Text = "Calculadora";

else

label7.Text = "";

31 - Faça o mesmo para o CheckBox3 e digite o seguinte código:


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.




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


label5.Text = comboBox1.SelectedItem.ToString();


37 - Teste todas as escolhas.



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.



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.



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.



2 - No menu Arquivo clique em Novo.



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.



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.



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.



A tabela clientes é criada.

9 - De um clique duplo sobre ela e digite o nome e telefone de 10 pessoas, como a

figura:



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.



2 – No menu Data, clique em Add New Data Source.



Nesta janela podemos escolher qual a origem dos dados.

3 – Selecione Database na janela Data Source Configuration Wizard e clique em

Next.



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.



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.



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.



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.



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.



14 – No menu Data, clique em Show Data Sources, a seguinte janela é aberta:



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:



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.




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.



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.




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:



Agora você já é capaz de manipular dados em seus programas.



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



• 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:



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);



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();



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);



if (numeroCaracteres < stringParaImprimir.Length)

{

stringParaImprimir =

stringParaImprimir.Substring(numeroCaracteres);

e.HasMorePages = true;

}

else

{

e.HasMorePages = false;


}

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;



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;


}

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.




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.


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.



17 - Volte novamente para o procedimento do evento do botão Imprimir e altere o

código para o seguinte:



DialogResult resultado = new DialogResult();

resultado = printDialog1.ShowDialog();

if (resultado == DialogResult.OK)



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.



20 - Clique em OK para imprimir ou Cancelar para fechar a janela Imprimir e

voltar ao Form1 sem realizar a impressão.


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();



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;



DialogResult resultado = new DialogResult();

resultado = printDialog1.ShowDialog();

if (resultado == DialogResult.OK)



25 - Clique no botão Configurar Impressão.

A janela Configurar página é exibida com as opções de configuração.



26 - Clique em OK.


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;


printPreviewDialog1.Document = printDocument1;

printPreviewDialog1.ShowDialog();



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.


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.



31 - Clique em Close para fechar o Visualizar Impressão.

32 - Para a aplicação.



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



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.



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.



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.



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.



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.



10 - Marque a opção Primary output from Formularios e clique em Next.



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.



11 - Clique em Next.

O passo 5 do assistente apenas exibe um resumo das opções escolhidas.



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.



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:



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.



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.



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.



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.



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.



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:



22 - Na pasta Lauch Condition, clique em .NET Framework.



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.



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.



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.



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:



2 - Clique em Next.



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.



5 - Clique em Next novamente.

É iniciada a instalação:



Após concluida a instalação é exibida o tela Installation Complete.



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.



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.



12 - Clique em Remover.

É exibida a seguinte caixa de mensagem:

13 - Clique em Sim.

O programa é desinstalado.

Documents

Programando com c# e visual studio net 2005