219

Programando com C# e Visual Studio 2005_-_Básico HM

Embed Size (px)

Citation preview

Page 1: Programando com C# e Visual Studio 2005_-_Básico HM
Page 2: Programando com C# e Visual Studio 2005_-_Básico HM

Índice do CursoPRÉ-REQUISITOS PARA O CURSO:.....................................................................................................................4PALAVRAS DO AUTOR:................................................................................................................................................4

INTRODUÇÃO.............................................................................................................................................................5

MÓDULO 1 - BEM VINDO AO C# E AO VISUAL STUDIO.NET 2005..............................................................7

LIÇÃO 1 – BEM VINDO AO C# E AO VISUAL STUDIO .NET 2005..............................................................................7LIÇÃO 2 – USANDO O CSC PARA COMPILAR SEU PROGRAMA.................................................................................17LIÇÃO 3 – CRIANDO SUA PRIMEIRA APLICAÇÃO WINDOWS COM C# E O VISUAL STUDIO .NET............................21LIÇÃO 4 – CRIANDO DOCUMENTAÇÃO USANDO XML E COMETÁRIOS....................................................................30

MÓDULO 2 - VARIÁVEIS.......................................................................................................................................38

LIÇÃO 5 – ENTENDO VARIÁVEIS E TIPOS DE DADOS................................................................................................38LIÇÃO 6 – NOMEANDO UMA VARIÁVEL...................................................................................................................40

Convenção PascalCasing....................................................................................................................................40Convenção camelCasing.....................................................................................................................................40

LIÇÃO 7 – PALAVRAS RESERVADAS DO C#.............................................................................................................41LIÇÃO 8 – DECLARANDO VARIÁVEIS.......................................................................................................................41LIÇÃO 9 – ATRIBUINDO VALOR A VARIÁVEIS..........................................................................................................42LIÇÃO 10 – TIPOS DE DADOS....................................................................................................................................42LIÇÃO 11 – ADICIONANDO VALOR A UMA VARIÁVEL..............................................................................................44LIÇÃO 12 – OPERADORES.........................................................................................................................................45

Operadores Aritméticos:.....................................................................................................................................45Precedência de Operadores:...............................................................................................................................52

MÓDULO 3 - MÉTODOS E ESCOPO....................................................................................................................53

LIÇÃO 13 – ENTENDENTO MÉTODOS........................................................................................................................53Especificando a sintaxe de declaração de um método:......................................................................................53Escrevendo declarações que retornam valores:.................................................................................................54Chamando métodos:............................................................................................................................................55Especificando a sintaxe para se chamar um método:.........................................................................................55

LIÇÃO 14 – ENTENDENTO ESCOPO...........................................................................................................................56Criando escopo local com um método................................................................................................................56Criando escopo de classe com uma classe:........................................................................................................57

LIÇÃO 15 – CRIANDO E CHAMANDO MÉTODOS.......................................................................................................58Chamando Métodos............................................................................................................................................61Visual Studio .NET depurador............................................................................................................................63

MÓDULO 4 - ESTRUTURAS DE DECISÃO.........................................................................................................68

LIÇÃO 16 – ENTENDENDO AS ESTRUTURAS DE DECISÃO........................................................................................68LIÇÃO 17 – USANDO O IF.........................................................................................................................................69LIÇÃO 18 – USANDO O SWITCH................................................................................................................................74

MÓDULO 5 ESTRUTURAS DE REPETIÇÃO.....................................................................................................81

LIÇÃO 19 – USANDO O WHILE..................................................................................................................................81LIÇÃO 20 – USANDO O DO.......................................................................................................................................84LIÇÃO 21 – USANDO O FOR......................................................................................................................................86LIÇÃO 22 – CONHECENDO O FOREACH.....................................................................................................................89

MÓDULO 6 GERENCIANDO ERROS E EXCEÇÕES.......................................................................................90

LIÇÃO 23 – CONHECENDO OS TRÊS TIPOS DE ERROS...............................................................................................90LIÇÃO 24 – ENCONTRANDO ERROS COM O VISUAL STUDIO.NET 2005..................................................................90LIÇÃO 25 – USANDO A JANELA WATCH...................................................................................................................99LIÇÃO 26 – USANDO A JANELA COMMAND...........................................................................................................102LIÇÃO 27 – TRY..CATCH.........................................................................................................................................105LIÇÃO 28 – USANDO TRY...CATCH ANINHADOS.....................................................................................................111LIÇÃO 29 – PROGRAMAÇÃO DEFENSIVA................................................................................................................113LIÇÃO 30 – EXIT TRY.............................................................................................................................................113

MÓDULO 7 ARRAYS E COLEÇÕES.................................................................................................................115

2

Page 3: Programando com C# e Visual Studio 2005_-_Básico HM

LIÇÃO 31 – USANDO ARRAYS................................................................................................................................115LIÇÃO 32 – COLEÇÕES...........................................................................................................................................124

MÓDULO 8 APROFUNDANDO EM WINDOWS FORMS..............................................................................129

LIÇÃO 33 – TRABALHANDO COM MÚLTIPLOS FORMULÁRIOS................................................................................129LIÇÃO 34 – PASSANDO VALORES ENTRE FORMS....................................................................................................134LIÇÃO 35 – POSICIONANDO OS FORMULÁRIOS NA TELA........................................................................................137LIÇÃO 36 – CONTROLANDO OS EVENTOS DOS FORMULÁRIOS...............................................................................138

MÓDULO 9 USANDO CONTROLES DO WINDOWS FORMS......................................................................140

LIÇÃO 37 – USANDO O CONTROLE DATETIMEPICKET............................................................................................140LIÇÃO 38 – USANDO OS CONTROLES RADIOBUTTON, CHECKBOX, LISTBOX E COMBOBOX..................................144

MÓDULO 10 BANCOS DE DADOS COM ADO.NET.......................................................................................153

LIÇÃO 39 – CONCEITOS BÁSICOS DE BANCO DE DADOS.........................................................................................153LIÇÃO 40– USANDO O VISUAL STUDIO 2005 PARA MANIPULAR DADOS DE UM BANCO DE DADOS......................157

MÓDULO 11- IMPRESSÃO...................................................................................................................................167

LIÇÃO 41 – IMPRIMINDO A PARTIR DE UMA TEXTBOX..........................................................................................167

MÓDULO 12 - DISTRIBUINDO SUA APLICAÇÃO..........................................................................................176

LIÇÃO 42 – CRIANDO UM PROJETO DE INSTALAÇÃO..............................................................................................176Lição 43 – Executando o programa de instalação..................................................................................................190

3

Page 4: Programando com C# e Visual Studio 2005_-_Básico HM

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.

4

Page 5: Programando com C# e Visual Studio 2005_-_Básico HM

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.

5

Page 6: Programando com C# e Visual Studio 2005_-_Básico HM

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

6

Page 7: Programando com C# e Visual Studio 2005_-_Básico HM

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.

7

Page 8: Programando com C# e Visual Studio 2005_-_Básico HM

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.

8

Page 9: Programando com C# e Visual Studio 2005_-_Básico HM

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.

9

Page 10: Programando com C# e Visual Studio 2005_-_Básico HM

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.

10

Page 11: Programando com C# e Visual Studio 2005_-_Básico HM

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:

11

Page 12: Programando com C# e Visual Studio 2005_-_Básico HM

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

Page 13: Programando com C# e Visual Studio 2005_-_Básico HM

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:

13

Page 14: Programando com C# e Visual Studio 2005_-_Básico HM

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.

14

Page 15: Programando com C# e Visual Studio 2005_-_Básico HM

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.

15

Page 16: Programando com C# e Visual Studio 2005_-_Básico HM

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.

16

Page 17: Programando com C# e Visual Studio 2005_-_Básico HM

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.

17

Page 18: Programando com C# e Visual Studio 2005_-_Básico HM

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.

18

Page 19: Programando com C# e Visual Studio 2005_-_Básico HM

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 {

19

Page 20: Programando com C# e Visual Studio 2005_-_Básico HM

static void Main(string[] args)

{ Console.WriteLine("Hello World"); } } }

15 – Compile e teste a aplicação, novamente fica a sua escolha, use o prompt de comando ou o Visual Studio .NET. Uma recomendação, compile manualmente pelo 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.

20

Page 21: Programando com C# e Visual Studio 2005_-_Básico HM

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.

21

Page 22: Programando com C# e Visual Studio 2005_-_Básico HM

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.

22

Page 23: Programando com C# e Visual Studio 2005_-_Básico HM

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:

23

Page 24: Programando com C# e Visual Studio 2005_-_Básico HM

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.

24

Page 25: Programando com C# e Visual Studio 2005_-_Básico HM

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

25

Page 26: Programando com C# e Visual Studio 2005_-_Básico HM

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

26

Page 27: Programando com C# e Visual Studio 2005_-_Básico HM

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.

27

Page 28: Programando com C# e Visual Studio 2005_-_Básico HM

private void button1_Click(object sender, System.EventArgs e) {

}

Tudo que for digitado dentro deste código será executado assim que o Button1 for clicado quando o programa estiver executando.

15 - Digite o seguinte código:

Tenha atenção com esse código, ele deve ser digitado exatamente como se segue, lembre-se que o C# é case-sensitive. É necessário também o ponto-e-virgula no final da linha.

MessageBox.Show("Hello " + textBox1.Text);

Vai ficar assim:

private void button1_Click(object sender, System.EventArgs e) {

MessageBox.Show("Hello " + textBox1.Text);

}

16 – Execute o programa.

Para executar o programa você pode clicar e F5, ou no menu Debug clicar em Start Debugging.

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.

28

Page 29: Programando com C# e Visual Studio 2005_-_Básico HM

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:

29

Page 30: Programando com C# e Visual Studio 2005_-_Básico HM

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.

30

Page 31: Programando com C# e Visual Studio 2005_-_Básico HM

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.

31

Page 32: Programando com C# e Visual Studio 2005_-_Básico HM

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

32

Page 33: Programando com C# e Visual Studio 2005_-_Básico HM

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.

33

Page 34: Programando com C# e Visual Studio 2005_-_Básico HM

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.

34

Page 35: Programando com C# e Visual Studio 2005_-_Básico HM

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

35

Page 36: Programando com C# e Visual Studio 2005_-_Básico HM

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:

Por valor, chamado de Value-Type.

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.

36

Page 37: Programando com C# e Visual Studio 2005_-_Básico HM

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.

37

Page 38: Programando com C# e Visual Studio 2005_-_Básico HM

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: No painel de código do Visual Studio .NET as palavras reservadas são identificadas pela cor de letra azul.

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

38

Page 39: Programando com C# e Visual Studio 2005_-_Básico HM

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.

39

Page 40: Programando com C# e Visual Studio 2005_-_Básico HM

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;

40

Page 41: Programando com C# e Visual Studio 2005_-_Básico HM

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.

41

Page 42: Programando com C# e Visual Studio 2005_-_Básico HM

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

42

Page 43: Programando com C# e Visual Studio 2005_-_Básico HM

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.

43

Page 44: Programando com C# e Visual Studio 2005_-_Básico HM

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:

44

Page 45: Programando com C# e Visual Studio 2005_-_Básico HM

4 – Configure as propriedades dos controles conforme a tabela abaixo: Vai ficar como a figura 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

45

Page 46: Programando com C# e Visual Studio 2005_-_Básico HM

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

46

Page 47: Programando com C# e Visual Studio 2005_-_Básico HM

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;

textBox3.Text = resultado.ToString(); }

else if (radioButton3.Checked) {

resultado = primeiroValor * segundoValor;

textBox3.Text = resultado.ToString(); }

else if(radioButton4.Checked) {

resultado = primeiroValor / segundoValor;

textBox3.Text = resultado.ToString(); }

else if(radioButton5.Checked) {

resultado = primeiroValor % segundoValor;

textBox3.Text = resultado.ToString(); }

Digitamos nosso código dentro do procedimento:

private void button1_Click(object sender, System.EventArgs e) {

}

Esse procedimento é executado sempre que o Button1 é clicado. Sendo assim quando o botão é clicado, primeiro:

Declaramos as variáveis primeiroValor, segundoValor e resultato do tipo Long. O tipo Long é usado aqui porque armazena uma grande variedade de números. Perceba que declaramos as três variáveis em apenas uma linha de código.r.

long primeiroValor, segundoValor, resultado;

Depois atribuímos os valores das caixas de texto as variáveis primeiroValor e segundoValor.

primeiroValor = int.Parse(textBox1.Text);

segundoValor = int.Parse(textBox2.Text);

47

Page 48: Programando com C# e Visual Studio 2005_-_Básico HM

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

else if (radioButton2.Checked)

Se o valor da propriedade Checked do RadioButton for True quer dizer que ele esta selecionado, então executamos o calculo correspondente ao RadioButton selecionado e atribuímos o resultado a variável resultado.

Agora atribuímos o valor da variável resultado à propriedade Text do textbox3 para que seja exibida na tela.

textBox3.Text = resultado.ToString();

Perceba que precisamos converter o valor da variável resultado para String. Fizemos isto utilizando o método ToString. Você pode usar o método ToString sempre que precisar converter um tipo de dados para string.

8 – Execute o programa.

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

Faça testes com os outros operadores.

Subtração:

48

Page 49: Programando com C# e Visual Studio 2005_-_Básico HM

Multiplicação:

Divisão, perceba que ele retorna um resultado em inteiro, o numero inteiro mais próximo do resultado:

49

Page 50: Programando com C# e Visual Studio 2005_-_Básico HM

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

Para efetuar a soma primeiro podemos utilizar os parênteses:

(2 + 3) * 4

(2 + 3) * 4

5 * 4

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.

50

Page 51: Programando com C# e Visual Studio 2005_-_Básico HM

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)

51

Page 52: Programando com C# e Visual Studio 2005_-_Básico HM

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

int adicionarValores (int numeroPequeno, int numeroGrande)

{

//...

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)

{

52

Page 53: Programando com C# e Visual Studio 2005_-_Básico HM

...

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:

int adicionarValores (int numeroPequeno, int numeroGrande)

{

//...

return numeroPequeno + numeroGrande;

}

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

adicionarValores(39,3)

53

Page 54: Programando com C# e Visual Studio 2005_-_Básico HM

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

54

Page 55: Programando com C# e Visual Studio 2005_-_Básico HM

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;

55

Page 56: Programando com C# e Visual Studio 2005_-_Básico HM

} }

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:

56

Page 57: Programando com C# e Visual Studio 2005_-_Básico HM

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

string linha = Console.ReadLine();

return int.Parse(linha);

}

Esse método faz a mesma coisa que o método lerDouble, só que retorna uma integer (inteiro).

Esta ficando assim nosso código:

using System;

using System.Collections.Generic;

using System.Text;

57

Page 58: Programando com C# e Visual Studio 2005_-_Básico HM

namespace Metodo {

class Program

{ public double lerDouble(string inicie) {

Console.Write(inicie); string linha = Console.ReadLine(); return double.Parse(linha);

}

public int lerInteiro(string inicio)

{ Console.Write(inicio); string linha = Console.ReadLine(); return int.Parse(linha);

}

static void Main(string[] args) {

}

} }

Verifique se os dois métodos estão dentro do escopo da classe Program.

5 – Novamente menu Build clique em Build Metodo ou pressione Ctrl+Shift+B. E verifique se ocorre erros, se ocorrer verifique seu código comparando-o ao acima. Lembre-se novamente que o C# é case-sensitive, ou seja, diferencia maiúsculas de minúsculas.

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.

58

Page 59: Programando com C# e Visual Studio 2005_-_Básico HM

Esse método escreve no console a multiplicação do parâmetro que é enviado para ele com 1.1

Esta ficando assim nosso código:

using System;

using System.Collections.Generic;

using System.Text;

namespace Metodo {

class Program

{ public double lerDouble(string inicie) {

Console.Write(inicie);

string linha = Console.ReadLine();

return double.Parse(linha);

}

public int lerInteiro(string inicio)

{ Console.Write(inicio); string linha = Console.ReadLine();

return int.Parse(linha); }

public double calcular(double taxaDiaria, int dias)

{ return taxaDiaria * dias; }

public void escrever(double taxa) { Console.WriteLine("A taxa é: {0}", taxa * 1.1); }

static void Main(string[] args) { }

} }

8 – Clique em Build Metodo no menu Build para verificar se compila corretamente. Tudo certo? Vamos usar os métodos que criamos.

Chamando Métodos

Podemos chamar métodos dentro de métodos, como faremos a seguir.

9 – Crie um novo método que não retorna nada, ou seja, do tipo void. De o nome dele de Executar

O código do nosso novo método deve ficar assim:

public void executar()

{ double taxadiaria = lerDouble("Digite a taxa diaria: ");

59

Page 60: Programando com C# e Visual Studio 2005_-_Básico HM

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:

static void Main(string[] args) { (new Program()).executar(); }

11 – Pressione Ctrl+F5 para executar o programa.

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

12 – Para taxa diária digite 315 e pressione Enter.

13 – Para numero de dias digite 15 e pressione Enter.

O programa vai escrever a seguinte mensagem no console:

A taxa é: 5197,5

14 – Pressione qualquer tecla para retornar ao Visual Studio.

Vou digitar o código fonte todo utilizado para você poder verificar caso haja algum problema e vamos depurar nosso programa para entender melhor como ele funciona.

using System;

using System.Collections.Generic;

using System.Text;

namespace Metodo {

class Program

{ public double lerDouble(string inicie) {

60

Page 61: Programando com C# e Visual Studio 2005_-_Básico HM

Console.Write(inicie); string linha = Console.ReadLine(); return double.Parse(linha);

}

public int lerInteiro(string inicio)

{ Console.Write(inicio); string linha = Console.ReadLine();

return int.Parse(linha); }

public double calcular(double taxaDiaria, int dias)

{ return taxaDiaria * dias; }

public void escrever(double taxa)

{ Console.WriteLine("A taxa é: {0}", taxa * 1.1); }

public void executar()

{ double taxadiaria = lerDouble("Digite a taxa diaria: ");

int dias = lerInteiro("Digite o numero de dias: "); escrever(calcular(taxadiaria, dias));

}

static void Main(string[] args) { (new Program()).executar();

}

}

}

Visual Studio .NET depurador

O depurador ou debug é um programa desenvolvido para ajudar o programador na verificação e correção de erros. Ele vem embutido no Visual Studio e vamos utilizálo para compreender melhor como funciona nosso programa, ele permite a execução do programa passo-a-passo.

15 – Localize no código o método executar.

16 – Mova o mouse a primeira linha de código do método executar. É a seguinte linha:

double taxadiaria = lerDouble("Digite a taxa diaria: ");

17 – Clique com o botão direito do mouse sobre ela, no menu que se abre clique em Run To Cursor.

61

Page 62: Programando com C# e Visual Studio 2005_-_Básico HM

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.

62

Page 63: Programando com C# e Visual Studio 2005_-_Básico HM

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.

63

Page 64: Programando com C# e Visual Studio 2005_-_Básico HM

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.

64

Page 65: Programando com C# e Visual Studio 2005_-_Básico HM

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.

26 – Clique em Step Into.

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

27 – Clique em Step Out.

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

28 – Clique em Step Into.

Perceba que agora a seta se move para a primeira linha de código do método escrever. Isso aconteceu porque na seguinte linha de código chamamos um método e passamos como parâmetro para ele um outro método.

escrever(calcular(taxadiaria,dias));

Aqui o método escrever recebe como parâmetro o método calcular, antes de ser executado o método escrever é executado o método calcular, seu resultado então é enviado ao método escrever para ser processado.

29 – Clique agora em Step Out.

O cursor se move para o fim do método executar. O resultado do programa é exibido na tela conforme a figura:

Parabéns, você escreveu métodos e os chamou com sucesso, alem disso usou o depurador do Visual Studio .NET.

65

Page 66: Programando com C# e Visual Studio 2005_-_Básico HM

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) Então a expressão que usamos no exemplo acima ficaria assim:

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

Preço < 100

Agora que você já sabe o que é uma expressão condicional vamos estudar o que é uma ESTRUTURA DE DECISÃO.

66

Page 67: Programando com C# e Visual Studio 2005_-_Básico HM

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.

double Salario = 1200;

if (Salario < 500) Salario += 50;

else

Salario += 100;

Aqui é verificado se o valor é menor que 500 e dependendo da condição é somado 50 ou 100, pois há o Else. Então se a variável for menor que 500 adicionamos nela o valor 50, senão adicionamos 100.

double Salario = 1200;

67

Page 68: Programando com C# e Visual Studio 2005_-_Básico HM

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:

double Salario = 1200;

if (Salario < 500) Salario += 50;

else if ((Salario >= 500) && (Salario < 600)) Salario += 100;

else if ((Salario >= 500) && (Salario < 700)) Salario += 110;

else if ((Salario >= 500) && (Salario < 800)) Salario += 120;

else

Salario += 250;

Perceba que no bloco de código acima usamos o &&.

O && é usado quando precisamos testar mais de uma expressão condicional.

Exemplo:

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

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.

68

Page 69: Programando com C# e Visual Studio 2005_-_Básico HM

Vamos a alguns exemplos de como utilizar os operadores lógicos: Vamos fazer um programinha que valida o usuário, verificando se é ele mesmo através do seu nome e senha.

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)

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

69

Page 70: Programando com C# e Visual Studio 2005_-_Básico HM

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.

6 – Execute o programa.

70

Page 71: Programando com C# e Visual Studio 2005_-_Básico HM

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.

71

Page 72: Programando com C# e Visual Studio 2005_-_Básico HM

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:

72

Page 73: Programando com C# e Visual Studio 2005_-_Básico HM

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

73

Page 74: Programando com C# e Visual Studio 2005_-_Básico HM

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:

74

Page 75: Programando com C# e Visual Studio 2005_-_Básico HM

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

75

Page 76: Programando com C# e Visual Studio 2005_-_Básico HM

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

break;

default: MessageBox.Show ("Este mes tem 31 dias");

break;

}

Vai ficar assim:

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

76

Page 77: Programando com C# e Visual Studio 2005_-_Básico HM

5 – Clique sobre um mês, por exemplo, Fevereiro, note a janela que exibe o numero de dias que tem esse mês.

Nosso exemplo é simples, criamos uma estrutura switch e demos a ela como expressão de teste o valor do item selecionado na listBox1. Usamos o método Convert para converter para string o valor obtido da listBox1.

O primeiro Case verifica se o item selecionado ou valor da expressão é Fevereiro. Se sim então mostra a caixa de dialogo com a mensagem dizendo que o mês possui 28 dias, senão vai para o próximo Case que verifica se o item selecionado é Abril, e assim sucessivamente até Novembro. Note que só implementamos código em Novembro, agrupamos assim quando os cases forem executar o mesmo bloco de código. Se o valor da expressão não se enquadrar em nenhum item da lista então ele vai para o default que executa o código com a mensagem de que o mês possui 31 dias.

6 – Vamos fazer uma mudança no nosso switch agora, siga o exemplo abaixo:

switch (listBox1.SelectedIndex + 1)

{

case 2 :

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

break;

case 4:

case 6: case 9: case 11:

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

break;

default: MessageBox.Show ("Este mes tem 31 dias");

break;

}

Neste exemplo, ao invés de pegarmos o texto selecionado no listBox agora estamos pegando o índice.

O índice é um numero que é atribuído a cada valor na lista começando por zero, então Janeiro tem índice 0, Fevereiro 1 e assim por diante.

77

Page 78: Programando com C# e Visual Studio 2005_-_Básico HM

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.

78

Page 79: Programando com C# e Visual Studio 2005_-_Básico HM

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.

79

Page 80: Programando com C# e Visual Studio 2005_-_Básico HM

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:

80

Page 81: Programando com C# e Visual Studio 2005_-_Básico HM

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; while (contador < 20) { contador++; listBox1.Items.Add(contador); }

Na primeira linha declaramos uma variável chamada contador do tipo integer e atribuimos a essa variavel o valor 0.

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:

81

Page 82: Programando com C# e Visual Studio 2005_-_Básico HM

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 coloca-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; while (contador < 20) { contador++; listBox1.Items.Add(contador); }

3 - Mude para o seguinte:

int contador = 0; while (contador < 20) { contador++;

82

Page 83: Programando com C# e Visual Studio 2005_-_Básico HM

if (contador == 10) {

break; } listBox1.Items.Add(contador); }

Perceba que as modificações foram minimas, apenas inserimos um If que verifica se o conteudo da variavel contador é 10, se for ele executa o break que finaliza imediatamente o loop.

4 - Execute a aplicação: 5 -Clique em Loop.

Perceba que ele nem chega a escrever o número 10 por que a linha de código que é

responsável por isso esta depois do If que finalizou o loop.

6 – Agora mude o valor inicial da variável 0 para 20.

7 – Execute a aplicação e clique em Loop. Perceba que não aparece nada, porque o resultado da expressão condicional começa como false, já que o valor não é menor que 20, e sim é igual a 20.

8 – Vamos usar o Do agora, mude o código para o seguinte:

int contador = 20; do

{ contador++; listBox1.Items.Add(contador);

if (contador == 10)

83

Page 84: Programando com C# e Visual Studio 2005_-_Básico HM

{

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.

84

Page 85: Programando com C# e Visual Studio 2005_-_Básico HM

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:

85

Page 86: Programando com C# e Visual Studio 2005_-_Básico HM

5 - Execute a aplicação.

6 - Clique no botão Beep.

Vamos dar uma avaliada no código:

86

Page 87: Programando com C# e Visual Studio 2005_-_Básico HM

for (int i = 1; i <= 4; i++) { MessageBox.Show(i.ToString()); }

Quando inicializamos o for, primeiro iniciamos uam variável do tipo integer e damos

o valor 1 para ela, demos o nome de i para essa variavel. Depois colocamos uma expressão booleana que será responsável por avaliar o numero de vezes que o for será executado, nossa expressão diz que o for deve ser executado enquanto o conteúdo de da varial i for menor ou igual a 4. Para finalizar a inicialização do For dizemos que a cada passada o conteúdo da variável i deve ser acrescentado em 1.

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

for (int i = 1; i <= 25; i+=5) { MessageBox.Show(i.ToString()); }

8 - Execute a aplicação e clique em Beep.

Perceba que o i+= 5 fez com que o número adicionado a variavel a cada passada do loop é 5 ao invés de 1.

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.

87

Page 88: Programando com C# e Visual Studio 2005_-_Básico HM

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?

88

Page 89: Programando com C# e Visual Studio 2005_-_Básico HM

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

89

Page 90: Programando com C# e Visual Studio 2005_-_Básico HM

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: 4 - Execute a aplicação.

90

Page 91: Programando com C# e Visual Studio 2005_-_Básico HM

Note que a propriedade text do button1 foi modificada como se a tivéssemos feito na janela properties.

Para usar o Debug não é necessário setar as propriedades assim, pode ser pela janela Properties apenas entenda que as propriedades podem ser modificadas em tempo de execução, você pode inclusive setar propriedades em um evento de clique de botão.

5 - De um clique duplo sobre o Button1 e digite o seguinte código:

int idade;

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:

91

Page 92: Programando com C# e Visual Studio 2005_-_Básico HM

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?

92

Page 93: Programando com C# e Visual Studio 2005_-_Básico HM

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

93

Page 94: Programando com C# e Visual Studio 2005_-_Básico HM

13 - Feche a aplicação.

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

15 - Localize a seguinte linha de código.

idade = int.Parse(textBox1.Text);

16 - Clique sobre esta linha com o botão direito do mouse e selecione a opção Insert BreakPoint, como na figura abaixo:

Essa linha de código vai ficar assim: O BreakPoint é um ponto de parada. Você pode colocar vários destes no seu código.

94

Page 95: Programando com C# e Visual Studio 2005_-_Básico HM

17 - Execute o programa agora.

18 -Digite 21 na primeira caixa de texto e clique em Testar.

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

95

Page 96: Programando com C# e Visual Studio 2005_-_Básico HM

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.

96

Page 97: Programando com C# e Visual Studio 2005_-_Básico HM

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.

97

Page 98: Programando com C# e Visual Studio 2005_-_Básico HM

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:

idade = int.Parse(textBox1.Text);

2 - Execute o programa.

3 -Digite 25 na primeira caixa de texto e clique em Testar.

O programa para no BreakPoint. E o Visual Studio entra no que chamamos de Break Mode.

Para usar a janela Watch você precisa estar em Break Mode.

4 -Clique na guia Watch 1, não tem nada na janela Watch ainda.

98

Page 99: Programando com C# e Visual Studio 2005_-_Básico HM

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.

99

Page 100: Programando com C# e Visual Studio 2005_-_Básico HM

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.

100

Page 101: Programando com C# e Visual Studio 2005_-_Básico HM

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:

101

Page 102: Programando com C# e Visual Studio 2005_-_Básico HM

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.

102

Page 103: Programando com C# e Visual Studio 2005_-_Básico HM

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.

103

Page 104: Programando com C# e Visual Studio 2005_-_Básico HM

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.

104

Page 105: Programando com C# e Visual Studio 2005_-_Básico HM

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.

7 - De um clique duplo sobre o Button1 e digite o seguinte código:

105

Page 106: Programando com C# e Visual Studio 2005_-_Básico HM

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: 10 - Pare a execução do programa.

11 - Tire o disquete do drive.

12 - Execute novamente o programa e clique no botão Testar Drive.

O programa não consegue encontrar o arquivo, acontece então um erro de runtime, que para bruscamente a execução do programa.

A linha com o erro também fica amarela no painel de código.

13 - Clique no botão Continue para fechar o programa ou pressione F5.

Vamos agora implementar o código que faz o tratamento do erro.

14 - Modifique o código do Evento do Button1 para o seguinte:

try { pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Insira o disquete no drive A"); }

Você não precisa digitar denovo a linha que executa a leitura da imagem do disquete. Apenas acrescente o try..catch e o código responsavel por emitir a mensagem de erro.

15 - Execute a aplicação.

106

Page 107: Programando com C# e Visual Studio 2005_-_Básico HM

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.

107

Page 108: Programando com C# e Visual Studio 2005_-_Básico HM

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

{ pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Insira o disquete no drive A"); }

Vamos agora implementar o Finally no nosso código.

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

try

{ pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Insira o disquete no drive A"); }

finally

{ MessageBox.Show("Código executado no finally"); }

108

Page 109: Programando com C# e Visual Studio 2005_-_Básico HM

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.

21 - Execute a aplicação.

22 - Teste com e sem disque do drive. Vai ver que a mensagem do Finally apareçe nas duas alternativas, ou seja, com e sem erro.

A tabela a seguir mostra o que ocasiona a maior parte dos erros de runtime:

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:

109

Page 110: Programando com C# e Visual Studio 2005_-_Básico HM

try

{ pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Insira o disquete no drive A");

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

{ pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Insira o disquete no drive A");

try

{ pictureBox1.Image = pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); }

catch

{ MessageBox.Show("Falha ao abrir o arquivo"); button1.Enabled = false; }

}

Vai ficar assim:

110

Page 111: Programando com C# e Visual Studio 2005_-_Básico HM

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:

111

Page 112: Programando com C# e Visual Studio 2005_-_Básico HM

button1.Enabled = false;

Lição 29 – Programação defensiva

Conhecemos por programação defensiva a iniciativa do programador de escrever seu código protegendo-o de erros de runtime. Exemplo:

if (System.IO.File.Exists(@"a:\inverno.jpg"))

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

}

else { MessageBox.Show("Não é possivel abrir o arquivo no drive A"); }

O código acima usa a o método File.Exists para verificar se o arquivo existe antes de tentar abri-lo.

O IF não é uma estrutura de tratamento de erros, porque não previne os erros de runtime, no entanto ele permite técnicas de validação.

A pergunta aqui é a seguinte: Quando utilizo programação defensiva preciso usar os blocos de tratamento de erros?

A resposta depende de com que freqüência você acha que o problema vai ocorrer no programa que você esta criando. Se o erro de runtime for ocorrer menos de 25% das vezes que o código for executado o tratamento de erros é a forma mais eficiente de tratar o erro. Os try...catch é essencial se você tem mais do que uma 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:

112

Page 113: Programando com C# e Visual Studio 2005_-_Básico HM

int retorno = 0; try

{ pictureBox1.Image = System.Drawing.Image.FromFile(@"a:\inverno.jpg"); } catch

{ retorno += 1; if (retorno <= 2) {

MessageBox.Show("Insira o disquete no drive A"); }

else

{ MessageBox.Show("Recurso não disponivel"); button1.Enabled = false;

} }

113

Page 114: Programando com C# e Visual Studio 2005_-_Básico HM

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.

114

Page 115: Programando com C# e Visual Studio 2005_-_Básico HM

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.

115

Page 116: Programando com C# e Visual Studio 2005_-_Básico HM

12 - Na janela Solution Explorer clique em View Designer para voltar para o Form1 no modo Design, você pode também clicar na aba Form1.vb[Design] ao lado da aba Start Page, à essa altura do curso você ja deve estar familiarizado com o Visual Studio.

13 - De um clique duplo sobre o Button1 e digite o seguinte código:

jogadores[0] = textBox1.Text;

Isso insere “Marcos” na primeira linha do Array, se colocassemos 6 ao invés de 0, por exemplo, seria na linha 7. O primeiro registro no array é sempre o 0, isso porque os índices sempre começam com 0.

14 - De um clique duplo sobre o Button3 (Visualizar Array) e digite o seguinte código:

listBox1.Items.Add(jogadores[0]);

Isso insere na ListBox1 o conteúdo da primeira linha do array Jogadores, se colocassemos 6, exibiria o conteúdo da linha 7, lembre-se que de o primeiro registro do array tem sempre o índice 0 e assim sucessivamente.

Não se assuste com o código para inserir no ListBox1, se fosse em uma TextBox ou Label você poderia usar a seguinte linha de código:

textBox1.Text = jogadores[0];

Só que para inserir um item no ListBox precisamos usar seu método Add.

15 – Execute a aplicação.

116

Page 117: Programando com C# e Visual Studio 2005_-_Básico HM

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.

19 - Digite dentro da classe do Form1 o seguinte código:

int contador = 0;

Isto cria uma variável que estará disponível para todos os procedimentos dentro da classe, ou seja, seu escopo é a classe. Também já atribuímos o valor 0 nela. Essa variável será usada para controlar o índice ou local do array onde vamos inserir cada jogador.

20 - Volte para o código do procedimento do Button1.

117

Page 118: Programando com C# e Visual Studio 2005_-_Básico HM

21 - Substitua o código pelo seguinte:

if (contador <= 10 && textBox1.Text != "")

{

jogadores[contador] = textBox1.Text;

contador += 1;

textBox1.Text = null;

}

else

{

button1.Enabled = false;

}

Vai ficar assim: 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.

118

Page 119: Programando com C# e Visual Studio 2005_-_Básico HM

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.

23 - Execute a aplicação.

24 – Digite o nome de um Jogador e clique no botão Inserir Jogador.

119

Page 120: Programando com C# e Visual Studio 2005_-_Básico HM

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.

29 - Digite dentro da classe do Form1 o seguinte código:

120

Page 121: Programando com C# e Visual Studio 2005_-_Básico HM

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

{

button2.Enabled = false;

}

Vai ficar assim:

Isso é semelhante ao código do Button1. Só que usamos a variável contadorFaltas, o textBox2 e o button2.

Note também que agora atribuimos os valores à segunda coluna, como mostra o código:

jogadores[contadorFaltas, 1] = textBox2.Text;

O índice 1 se refere a segunda coluna.

121

Page 122: Programando com C# e Visual Studio 2005_-_Básico HM

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.

122

Page 123: Programando com C# e Visual Studio 2005_-_Básico HM

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:

123

Page 124: Programando com C# e Visual Studio 2005_-_Básico HM

4 - Execute sua aplicação.

5 -Clique no Button1.

124

Page 125: Programando com C# e Visual Studio 2005_-_Básico HM

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:

7 - Execute a aplicação.

125

Page 126: Programando com C# e Visual Studio 2005_-_Básico HM

8 -Clique no Button1.

Agora apenas o Button2 e Button3 foram alterados pelo Loop. Já que adicionamos o If para testar se o controle não era o Button1. Mudamos uma propriedade diferente desta vez, movimentando assim os Buttons para a direita.

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.

126

Page 127: Programando com C# e Visual Studio 2005_-_Básico HM

9 - No Form1 de um clique duplo sobre o Button2 e digite o seguinte código:

Controls[0].Left += 35;

10 - Execute a aplicação.

11 - Clique no Button2.

Conforme citado o indice 0 representa o último controle adicionado no Form1, então nosso código moveu apenas o Button3 - que foi o último controle adicionado

-para a esquerda.

127

Page 128: Programando com C# e Visual Studio 2005_-_Básico HM

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.

128

Page 129: Programando com C# e Visual Studio 2005_-_Básico HM

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.

129

Page 130: Programando com C# e Visual Studio 2005_-_Básico HM

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.

130

Page 131: Programando com C# e Visual Studio 2005_-_Básico HM

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

10 – Execute a aplicação.

131

Page 132: Programando com C# e Visual Studio 2005_-_Básico HM

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.

132

Page 133: Programando com C# e Visual Studio 2005_-_Básico HM

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:

133

Page 134: Programando com C# e Visual Studio 2005_-_Básico HM

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:

134

Page 135: Programando com C# e Visual Studio 2005_-_Básico HM

label1.Text = mensagem;

Isso adiciona o conteúdo da variável mensagem no Label1.

6 - Execute a aplicação.

7 – Clique sobre o botão Vermelho.

8 – No frmVermelho, clique no button1.

135

Page 136: Programando com C# e Visual Studio 2005_-_Básico HM

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.

3 - Execute a aplicação.

136

Page 137: Programando com C# e Visual Studio 2005_-_Básico HM

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.

7 - Execute a aplicação.

O formulário é exibido agora a 100 pixels da lateral esquerda e 50 pixels do topo da tela.

Lição 36 – Controlando os eventos dos formulários

1 - Crie um novo projeto no Visual Studio chamado Eventos do tipo Windows Application.

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.

137

Page 138: Programando com C# e Visual Studio 2005_-_Básico HM

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.

3 - Arraste para o Form1 os seguintes controles:

1 Label

1 TextBox

1 Button

4 – Clique sobre cada um dos controles acima e visualize sua lista de eventos.

Para criar o procedimento do evento desejado de um clique duplo sobre o nome do mesmo na janela Properties.

138

Page 139: Programando com C# e Visual Studio 2005_-_Básico HM

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.

3 - Execute sua aplicação.

139

Page 140: Programando com C# e Visual Studio 2005_-_Básico HM

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:

140

Page 141: Programando com C# e Visual Studio 2005_-_Básico HM

8 – De um clique duplo sobre o botão e no seu procedimento de evento clique digite o seguinte código:

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

MessageBox.Show("O dia é " + dateTimePicker1.Value.DayOfYear.ToString());

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

A primeira linha usa a propriedade Text para exibir a data que esta selecionada no controle.

A segunda usa o método DayOfYear para recuperar apenas o dia do ano da data que esta selecionada no controle.

A terceira linha exibe a data e hora atual usando o método Now da estrutura DateTime.

9 - Execute a aplicação.

141

Page 142: Programando com C# e Visual Studio 2005_-_Básico HM

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.

142

Page 143: Programando com C# e Visual Studio 2005_-_Básico HM

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 - Arraste para o Form1 os seguintes controles:

2 GroupBox

3 RadioButton

3 CheckBox

1 ListBox

1 ComboBox

8 Label

3 - Organize-os como a figura:

143

Page 144: Programando com C# e Visual Studio 2005_-_Básico HM

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:

144

Page 145: Programando com C# e Visual Studio 2005_-_Básico HM

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:

145

Page 146: Programando com C# e Visual Studio 2005_-_Básico HM

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:

146

Page 147: Programando com C# e Visual Studio 2005_-_Básico HM

20 - Execute a aplicação.

A primeira funcionade que iremos implementar agora é a dos RadioButton. Eles são usados sempre que o usuário precisa fazer uma escolha única, já que não permite que mais de um item seja marcado. Podemos também colocar uma escolha que já aparece marcada como padrão, para isso você deve mudar a propriedade Checked do RadioButton em questão para True.

21 - Pare a execução do programa.

22 - Mude a propriedade Checked do RadioButton1 para True.

23 - Execute novamente a aplicação. Agora o item PC já apareçe marcado.

24 - Pare novamente a execução do programa. Vamos agora programar o código para os RadioButtons.

25 - No modo Design, de um clique duplo sobre o RadioButton1 e digite o seguinte código no procedimento de evento criado:

147

Page 148: Programando com C# e Visual Studio 2005_-_Básico HM

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.

148

Page 149: Programando com C# e Visual Studio 2005_-_Básico HM

28 - Pare a execução do programa.

Vamos agora programar o código para os CheckBoxes. Eles são semelhantes ao RadioButton, no entando permitem mais de uma escolha. Novamente você pode mudar a propriedade Checked de alguns deles para já iniciarem marcados. São usados sempre para perguntas que requerem nenhum ou várias respostas como no nosso exemplo. O usuário pode não querer nenhum item para o escritório, pode querer um, dois ou todos os items.

29 - De um clique duplo sobre o CheckBox1 e digite o seguinte código:

if (checkBox1.Checked == true)

label6.Text = "Fax";

else

label6.Text = "";

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

if (checkBox2.Checked == true) label7.Text = "Calculadora";

else

label7.Text = "";

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

if (checkBox3.Checked == true) label8.Text = "Copiadora";

else

label8.Text = "";

149

Page 150: Programando com C# e Visual Studio 2005_-_Básico HM

32 - Execute sua aplicação. Marque as opções FAX e Copiadora, por exemplo, como disse podemos marcar mais de um item.

33 - Pare a execução do programa.

34 - De um clique duplo sobre o ListBox1 e digite o seguinte código:

label4.Text = listBox1.SelectedItem.ToString();

Isso escreve o conteúdo do item seleciona na Label4.

35 - Vamos já programar o código para a ComboBox também, de um clique duplo sobre a mesma no modo Design para abrir o procedimento de evento padrão e digite o seguinte código:

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

36 - Execute sua aplicação.

37 - Teste todas as escolhas.

150

Page 151: Programando com C# e Visual Studio 2005_-_Básico HM

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.

151

Page 152: Programando com C# e Visual Studio 2005_-_Básico HM

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

152

Page 153: Programando com C# e Visual Studio 2005_-_Básico HM

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.

153

Page 154: Programando com C# e Visual Studio 2005_-_Básico HM

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.

154

Page 155: Programando com C# e Visual Studio 2005_-_Básico HM

6 - Na janela Tabela1:Tabela clique em fechar, você vai receber a seguinte mensagem:

155

Page 156: Programando com C# e Visual Studio 2005_-_Básico HM

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:

156

Page 157: Programando com C# e Visual Studio 2005_-_Básico HM

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.

157

Page 158: Programando com C# e Visual Studio 2005_-_Básico HM

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.

158

Page 159: Programando com C# e Visual Studio 2005_-_Básico HM

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.

159

Page 160: Programando com C# e Visual Studio 2005_-_Básico HM

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.

160

Page 161: Programando com C# e Visual Studio 2005_-_Básico HM

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.

161

Page 162: Programando com C# e Visual Studio 2005_-_Básico HM

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.

162

Page 163: Programando com C# e Visual Studio 2005_-_Básico HM

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:

163

Page 164: Programando com C# e Visual Studio 2005_-_Básico HM

Perceba que ele já cria automaticamente os controles necessários para o acesso e atualização dos dados, assim como um controle DataGridView para manipular os mesmos.

17 – Execute a aplicação.

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.

164

Page 165: Programando com C# e Visual Studio 2005_-_Básico HM

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.

22 – Execute a aplicação.

165

Page 166: Programando com C# e Visual Studio 2005_-_Básico HM

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.

166

Page 167: Programando com C# e Visual Studio 2005_-_Básico HM

Módulo 11- Impressão

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

167

Page 168: Programando com C# e Visual Studio 2005_-_Básico HM

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:

168

Page 169: Programando com C# e Visual Studio 2005_-_Básico HM

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

169

Page 170: Programando com C# e Visual Studio 2005_-_Básico HM

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;

stringParaImprimir = textBox1.Text;

}

Esse procedimento de eventos define a área da página que vai ser impressa, se for preciso dividir o texto em linhas e páginas esse procedimento também se responsabilizará por isso.

A área de impressão é definida usando a variável areaPagina, que é baseada na classe RectangleF.

RectangleF areaPagina = new RectangleF(e.MarginBounds.Left, e.MarginBounds.Top, e.MarginBounds.Width, e.MarginBounds.Height);

A variável formataString usa o método Trimming para determinar quanto texto pode ajustar em uma página.

formataString.Trimming = StringTrimming.Word;

O código abaixo assegura que o texto não seja cortado na página:

e.Graphics.MeasureString(stringParaImprimir, fontParaImprimir, areaLinha, formataString, out numeroCaracteres, out numeroLinhas);

Depois o texto é impresso na página através do método DrawString.

e.Graphics.DrawString(stringParaPagina, fontParaImprimir, Brushes.Black, areaPagina, formataString);

O If é usado para verificar se é necessário mais de uma página para imprimir o texto em questão, para tanto ele usa a propriedade HasMorePages.

if (numeroCaracteres < stringParaImprimir.Length)

{

stringParaImprimir = stringParaImprimir.Substring(numeroCaracteres);

e.HasMorePages = true; }

else {

e.HasMorePages = false;

stringParaImprimir = textBox1.Text; }

170

Page 171: Programando com C# e Visual Studio 2005_-_Básico HM

Talvez o procedimento do evento PrintDocument1_PrintPage tenha sido um pouco complicado comparado com os demais vistos neste curso, não se preocupe, com pouco tempo de experiência você será capaz de compreende-lo com facilidade.

14 - Execute sua aplicação.

15 -Digite algum texto na caixa de texto, e clique no botão imprimir.

O texto deve ser impresso. A seguinte caixa de diálogo é exibida.

16 - Pare a execução do programa.

Vamos implementar agora o código que permite que o usuário escolha a impressora e o número de páginas que deseja imprimir.

17 - Volte novamente para o procedimento do evento do botão Imprimir e altere o código para o seguinte:

stringParaImprimir = textBox1.Text;

printDialog1.Document = printDocument1;

DialogResult resultado = new DialogResult();

resultado = printDialog1.ShowDialog();

if (resultado == DialogResult.OK)

printDocument1.Print();

171

Page 172: Programando com C# e Visual Studio 2005_-_Básico HM

18 - Execute a aplicação.

19 -Digite algum texto na caixa de texto, e clique no botão imprimir.

Agora antes da impressão é exibida a janela Imprimir que permite que o usúario escolha a impressora e o número de cópias.

20 - Clique em OK para imprimir ou Cancelar para fechar a janela Imprimir e voltar ao Form1 sem realizar a impressão.

21 - Pare a execução do programa.

Vamos implementar o código agora que permite a configuração da impressão.

172

Page 173: Programando com C# e Visual Studio 2005_-_Básico HM

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; stringParaImprimir = textBox1.Text; printDialog1.Document = printDocument1; DialogResult resultado = new DialogResult(); resultado = printDialog1.ShowDialog(); if (resultado == DialogResult.OK)

printDocument1.Print();

24 - Execute a aplicação.

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

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

173

Page 174: Programando com C# e Visual Studio 2005_-_Básico HM

26 - Clique em OK.

27 - Pare a execução do programa.

Vamos agora implementar o código para Visualizar a Impressão.

28 - No modo design de um clique duplo sobre o Button3 e digite o seguinte código:

pageSetupDialog1.PageSettings = configuracaoDepagina; stringParaImprimir = textBox1.Text;

printPreviewDialog1.Document = printDocument1; printPreviewDialog1.ShowDialog();

As duas primeiras linhas de código são as mesmas usadas no Button1, a terceira indica que o documento a ser visualizado é o PrintDocument1, a última linha exibe a visualização.

29 - Execute a aplicação.

30 - Digite algum texto e clique no botão Visualizar Impressão.

Se você quizer imprimir diretamente da janela Visualizar Impressão é só clicar na Impressora. Você também tem opções de Zoom, seleção de páginas e possibilidade de visualizar várias páginas de uma só vez na tela.

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

174

Page 175: Programando com C# e Visual Studio 2005_-_Básico HM

32 - Para a aplicação.

175

Page 176: Programando com C# e Visual Studio 2005_-_Básico HM

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.

176

Page 177: Programando com C# e Visual Studio 2005_-_Básico HM

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:

177

Page 178: Programando com C# e Visual Studio 2005_-_Básico HM

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.

178

Page 179: Programando com C# e Visual Studio 2005_-_Básico HM

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.

179

Page 180: Programando com C# e Visual Studio 2005_-_Básico HM

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

180

Page 181: Programando com C# e Visual Studio 2005_-_Básico HM

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.

181

Page 182: Programando com C# e Visual Studio 2005_-_Básico HM

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.

182

Page 183: Programando com C# e Visual Studio 2005_-_Básico HM

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:

183

Page 184: Programando com C# e Visual Studio 2005_-_Básico HM

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.

184

Page 185: Programando com C# e Visual Studio 2005_-_Básico HM

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.

185

Page 186: Programando com C# e Visual Studio 2005_-_Básico HM

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

186

Page 187: Programando com C# e Visual Studio 2005_-_Básico HM

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:

187

Page 188: Programando com C# e Visual Studio 2005_-_Básico HM

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.

188

Page 189: Programando com C# e Visual Studio 2005_-_Básico HM

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.

189

Page 190: Programando com C# e Visual Studio 2005_-_Básico HM

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.

190

Page 191: Programando com C# e Visual Studio 2005_-_Básico HM

É iniciado o processo de instalação com a seguinte tela: 2 -Clique em Next.

191

Page 192: Programando com C# e Visual Studio 2005_-_Básico HM

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.

192

Page 193: Programando com C# e Visual Studio 2005_-_Básico HM

5 - Clique em Next novamente.

É iniciada a instalação:

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

193

Page 194: Programando com C# e Visual Studio 2005_-_Básico HM

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.

194

Page 195: Programando com C# e Visual Studio 2005_-_Básico HM

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.

195