Apostila C#

Conhea mais da Caelum.

Cursos Onlinewww.caelum.com.br/online

Blog Caelumblog.caelum.com.br

Newsletterwww.caelum.com.br/newsletter

Facebookwww.facebook.com/caelumbr

Twittertwitter.com/caelum

Casa do CdigoLivros para o programador

www.casadocodigo.com.br

Sobre esta apostilaEsta apostila daCaelumvisa ensinar de umamaneira elegante, mostrando apenas o que necessrio e quando necessrio, no momento certo, poupando o leitor de assuntos que no costumam ser de seu interesse emdeterminadas fases do aprendizado.

A Caelum espera que voc aproveite esse material. Todos os comentrios, crticas e sugestes sero muitobem-vindos.

Essa apostila constantemente atualizada e disponibilizada no site da Caelum. Sempre consulte o site paranovas verses e, ao invs de anexar o PDF para enviar a um amigo, indique o site para que ele possa semprebaixar as ltimas verses. Voc pode conferir o cdigo de verso da apostila logo no nal do ndice.

Baixe sempre a verso mais nova em: www.caelum.com.br/apostilas

Esse material parte integrante do treinamento C e Orientao a Objetos e distribudo gratuitamente exclu-sivamente pelo site da Caelum. Todos os direitos so reservados Caelum. A distribuio, cpia, revenda eutilizao para ministrar treinamentos so absolutamente vedadas. Para uso comercial deste material, porfavor, consulte a Caelum previamente.

www.caelum.com.br

1

Sumrio

1 Como aprender C# 11.1 O que realmente importante? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Sobre os exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Tirando dvidas e indo alm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 O que C# e .Net 42.1 Um pouco sobre a histria do C# e .Net . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Mquina virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.3 Execuo do cdigo na CLR e o JIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.4 O ambiente de desenvolvimento do C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.5 Executando aplicaes sem o Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.6 O primeiro programa em C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.7 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.8 O que aconteceu durante a execuo? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3 Variveis e tipos primitivos 143.1 Operaes com variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153.2 Tipos Primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.3 Armazenando texto em variveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.4 Documentando o cdigo atravs de comentrios . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Estruturas de controle 204.1 Tomando decises no cdigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.2 Mais sobre condies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.3 Exerccios opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5 Estruturas de repetio 255.1 Repetindo um bloco de cdigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255.2 Para saber mais do while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.3 Para saber mais incremento e decremento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6 Classes e objetos 296.1 Organizando o cdigo com Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296.2 Extraindo comportamentos atravs de mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . 326.3 Devolvendo valores de dentro do mtodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.4 Valor padro dos atributos da classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.5 Mais um exemplo: Transfere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.6 Conveno de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

i

6.7 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.8 Composio de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.9 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

7 Encapsulamento e Modicadores de Acesso 477.1 Encapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.2 Controlando o acesso com properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.3 Simplicando a declarao de propriedades com Auto-Implemented Properties . . . . . . . . 537.4 Conveno de nome para property . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547.5 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547.6 Para saber mais: Visibilidade Internal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

8 Construtores 578.1 Mltiplos construtores dentro da classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588.2 Para saber mais Initializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598.3 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

9 Introduo ao Visual Studio comWindows Form 629.1 Introduo prtica aos atalhos do Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . 649.2 A classe Convert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689.3 Operaes na conta: saque e depsito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699.4 Controlando o nome da ao de um boto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719.5 Renomeando Variveis, Mtodos e Classes com o Visual Studio . . . . . . . . . . . . . . . . . . 729.6 Para saber mais organizando o formulrio com Label e GroupBox . . . . . . . . . . . . . . . 739.7 Resumo dos atalhos do Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749.8 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759.9 Para saber mais tipos implcitos e a palavra VAR . . . . . . . . . . . . . . . . . . . . . . . . . 759.10 Exerccios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

10 Herana 7910.1 Reaproveitando cdigo com a Herana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8010.2 Reaproveitando a implementao da classe base . . . . . . . . . . . . . . . . . . . . . . . . . . . 8310.3 Polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8410.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8710.5 Para saber mais o que herdado? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

11 Trabalhando com arrays 9111.1 Para saber mais inicializao de Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9211.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9311.3 Organizando as contas com o ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9611.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

12 Cadastro de novas contas 10012.1 Utilizando o AdicionaConta no load do formulrio . . . . . . . . . . . . . . . . . . . . . . . . . 104

ii

12.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

13 Classes abstratas 11013.1 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

14 Interfaces 11414.1 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

15 Mtodos e atributos estticos 12215.1 Exerccios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12415.2 Para saber mais classes estticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

16 Excees 12716.1 Retorno do mtodo para controlar erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12716.2 Controlando erros com excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12816.3 Tratando mltiplas excees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13016.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

17 Namespaces 13617.1 Para saber mais - Declarao de namespace aninhados . . . . . . . . . . . . . . . . . . . . . . . 13917.2 Para saber mais - Alias para namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14017.3 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

18 Classe Object 14418.1 Implementando a comparao de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14518.2 Melhorando a implementao do Equals com o is . . . . . . . . . . . . . . . . . . . . . . . . . . 14718.3 Integrando o Object com o ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14818.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

19 Trabalhando com listas 15319.1 Facilitando o trabalho com colees atravs das listas . . . . . . . . . . . . . . . . . . . . . . . . 15319.2 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

20 Lidando com conjuntos 15720.1 Otimizando a busca atravs de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15720.2 Conjuntos Ordenados com o SortedSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15920.3 A interface de todos os conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16020.4 Comparao entre listas e conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16020.5 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16120.6 Buscas rpidas utilizando Dicionrios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16420.7 Iterando no dicionrio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16520.8 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

21 LINQ e Lambda 170

iii

21.1 Filtros utilizando o LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17121.2 Simplicando a declarao do lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17221.3 Outros mtodos do LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17221.4 Utilizando o LINQ com outros tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17321.5 Melhorando as buscas utilizando a sintaxe de queries . . . . . . . . . . . . . . . . . . . . . . . . 17321.6 Para saber mais projees e objetos annimos . . . . . . . . . . . . . . . . . . . . . . . . . . . 17421.7 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17521.8 Ordenando colees com LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17821.9 Exerccios - Ordenao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

22 System.IO 18022.1 Leitura de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18022.2 Escrevendo em arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18222.3 Gerenciando os arquivos com o using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18422.4 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18522.5 Para saber mais onde colocar os arquivos da aplicao . . . . . . . . . . . . . . . . . . . . . . 188

23 Manipulao de strings 19023.1 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

24 Apndice estendendo comportamentos atravs de mtodos extras 19524.1 Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

ndice Remissivo 200Verso: 17.0.6

iv

Captulo 1

Como aprender C#

1.1 O que realmente importante?

Muitos livros, ao passar dos captulos, mencionam todos os detalhes da linguagem, juntamente com seusprincpios bsicos. Isso acaba criando muita confuso, em especial porque o estudante no consegue dife-renciar exatamente o que essencial aprender no incio, daquilo que pode ser deixado para estudar maistarde.

Se uma classe abstrata deve ou no ter ao menos um mtodo abstrato, se o if somente aceita argumentosbooleanos e todos os detalhes sobre classes internas, realmente no devem ser preocupaes para aquele cujoobjetivo primrio aprender C#. Esse tipo de informao ser adquirida com o tempo e no necessria noincio.

Neste curso, separamos essas informaes em quadros especiais, j que so informaes extra. Ou ento,apenas citamos em algum exerccio e deixamos para o leitor procurar informaes adicionais, se for de seuinteresse.

Por m, falta mencionar algo sobre a prtica, que deve ser tratada seriamente: todos os exerccios so muitoimportantes e os desaos podem ser feitos aps o trmino do curso. De qualquer maneira, recomendamosaos alunos estudarem em casa e praticarem bastante cdigo e variaes.

1.2 Sobre os exerccios

Os exerccios do curso variam, de prticos at pesquisas na internet, ou mesmo consultas sobre assuntosavanados em determinados tpicos, para incitar a curiosidade do aprendiz na tecnologia.

Existe tambm, em determinados captulos, uma srie de desaos. Eles focammais no problema computaci-onal que na linguagem, porm so uma excelente forma de treinar a sintaxe e, principalmente, familiarizar o

Material do Treinamento C e Orientao a Objetos

aluno com as bibliotecas padro do C#, alm de proporcionar um ganho na velocidade de desenvolvimento.

1.3 Tirando dvidas e indo alm

Para tirar dvidas de exerccios, ou de C# em geral, recomendamos o frum do GUJ Respostas:

http://www.guj.com.br

L sua dvida ser respondida prontamente. OGUJ foi fundado por desenvolvedores da Caelum e hoje contacom mais de um milho de mensagens.

O principal recurso ocial para encontrar documentao, tutoriais e at mesmo livros sobre .NET e C# aMicroso Developers Network, ou MSDN:

http://msdn.microso.com

Destacamos a seo de tutoriais de C# (em ingls), no endereo:

http://msdn.microso.com/en-us/library/aa288436.aspx

H tambm fruns ociais em portugus na MSDN:

http://social.msdn.microso.com/Forums/pt-br/home

Fora isso, sinta-se vontade para entrar emcontato com seu instrutor para tirar todas as dvidas que surgiremdurante o curso.

Se o que voc est buscando so livros de apoio, sugerimos conhecer a editora Casa do Cdigo:

http://www.CasaDoCodigo.com.br

Em lngua portuguesa, h alguns livros sobre o assunto:

Andrew Stellman. Use a Cabea! C#. 2 Edio. Alta Books.

http://www.altabooks.com.br/use-a-cabeca-c-2a-edicao.html

Harvey Deitel, Paul Deitel. C# Como Programar. 1 Edio. Pearson.

http://www.pearson.com.br/produtos_detalhes.asp?id_p=0&livro_cod=9788534614597

Em lngua inglesa, h uma edio bem mais atual do ltimo livro:

Harvey Deitel, Paul Deitel. Visual C# 2012 How to Program. 5th Edition. Prentice Hall.

http://www.deitel.com/Books/C/VisualC2012HowtoProgram/tabid/3645/Default.aspx

ACaelum oferece outros cursos de C#/.NET, com destaque para o FN-23, que traz a aplicao do C# naWeb:

http://www.caelum.com.br

Captulo 1 - Como aprender C# - Tirando dvidas e indo alm - Pgina 2


H tambm cursos online que vo ajud-lo a ir alm, com muita interao com os instrutores:

http://www.Alura.com.br

Captulo 1 - Como aprender C# - Tirando dvidas e indo alm - Pgina 3

Captulo 2

O que C# e .Net

2.1 Um pouco sobre a histria do C# e .Net

Entender umpouco da histria doC# e do .Net essencial para enxergar osmotivos que a levaram ao sucesso.

No nal da dcada de 1990 aMicroso tinha diversas tecnologias e linguagens de programao para resolvermuitos problemas diferentes. Toda vez que um programador precisava migrar para uma nova linguagem,era necessrio aprender tanto a nova linguagem quanto suas bibliotecas e conceitos. Para solucionar essesproblemas, a Microso recorreu linguagem Java.

O Java agradou os engenheiros daMicroso pois com ela podamos construir programas que eram indepen-dentes do ambiente de execuo, alm de possuir diversas bibliotecas com solues prontas para diversosproblemas. Para lanar produtos baseados no Java, a Microso assinou um acordo de licenciamento com aSun para utilizar o Java em ambiente Windows.

Porm, a linguagem Java possua um grave problema: ela no se comunicava bem com o as bibliotecas decdigo nativo (cdigo de mquina) que j existiam. Para resolver isso, a Microso decidiu criar a sua pr-pria implementao do Java chamado J++ que possua extenses proprietrias que resolviam o problema decomunicao com o cdigo nativo existente. Para o desenvolvimento dessa nova implementao do Java,a Microso contratou um engenheiro chamado Anders Hejlsberg, um dos principais nomes por trs doDelphi.

O J++ era uma verso da linguagem Java que s podia ser executada no ambiente Microso. Seu cdigo nopodia ser executado em mais nenhum ambiente Java, o que violava o licenciamento feito com a Sun e, porisso, a Microso foi processada. Uma das mais conhecidas batalhas judiciais da poca.

Sem o J++, a Microso foi obrigada a repensar sua estratgia sobre como lidar com as diferentes linguagense tecnologias utilizadas internamente. A empresa comeou a trabalhar em um nova plataforma que seria a


base de todas as suas solues, que posteriormente foi chamada de .Net. Esse novo ambiente de desenvol-vimento da Microso foi desde o incio projetado para trabalhar com diversas linguagens de programao,assim diversas linguagens diferentes compartilhariam o mesmo conjunto de bibliotecas. Com isso, para umprogramador migrar de uma linguagem para outra ele precisaria apenas aprender a linguagem sem se preo-cupar com as bibliotecas e APIs.

Alm de uma plataforma a Microso tambm precisava de uma linguagem de programao. Um novo pro-jeto de linguagem de programao foi iniciado, o projeto COOL (C-like Object Oriented Language). AndersHejlsberg foi escolhido como engenheiro chefe desse novo projeto. COOL teve seu design baseado em di-versas outras linguagens do mercado como Java, C, C++, Smalltalk, Delphi e VB. A ideia era estudar osproblemas existentes e incorporar solues.

Em 2002, o projeto COOL foi lanado como linguagem C# 1.0 junto com o ambiente .Net 1.0. Atualmentea linguagem C# est em sua verso 5.0 e o .Net na verso 4.5.1, tendo evoludo com expressiva velocidade,adotando novidades na sua sintaxe que a diferenciaram bastante do Java e outras concorrentes.

2.2 Mquina virtual

Em uma linguagem de programao como C e Pascal, temos a seguinte situao quando vamos compilar umprograma:

O cdigo fonte compilado para cdigo de mquina especco de uma plataforma e sistema operacional.Muitas vezes o prprio cdigo fonte desenvolvido visando uma nica plataforma!

Esse cdigo executvel (binrio) resultante ser executado pelo sistema operacional e, por esse motivo, eledeve saber conversar com o sistema operacional em questo. Isto , temos um cdigo executvel diferentepara cada sistema operacional diferente.

Precisamos reescrever ummesmo pedao da aplicao para diferentes sistemas operacionais, j que eles noso compatveis.

O C# utiliza o conceito de mquina virtual. Entre o sistema operacional e a aplicao existe uma camadaextra responsvel por traduzirmas no apenas issoo que sua aplicao deseja fazer para as respectivaschamadas do sistema operacional onde ela est rodando no momento.

Repare que umamquina virtual um conceito bemmais amplo que o de um interpretador. Como o prprionome diz, uma mquina virtual como um computador de mentira": tem tudo que um computador tem.Em outras palavras, ela responsvel por gerenciar memria, threads, a pilha de execuo etc.

Sua aplicao roda sem nenhum envolvimento com o sistema operacional! Sempre conversando apenas coma mquina virtual do C#, a Common Language Runtime (CLR). A CLR o ambiente de execuo para todasas linguagens da plataforma .Net, no apenas para o C#. Certamente isso no foi uma revoluo. O Javatrouxe esse conceito para o mercado e j havia muitas linguagens com esses recursos, apesar de que eramencontradas mais no meio acadmico.

Captulo 2 - O que C# e .Net - Mquina virtual - Pgina 5


O CLR isola totalmente a aplicao do sistema operacional. Se uma aplicao rodando no CLR terminaabruptamente, ela no afetar as outras mquinas virtuais e nem o sistema operacional. Essa camada deisolamento tambm interessante quando pensamos em um servidor que no pode se sujeitar a rodar cdigoque possa interferir na boa execuo de outras aplicaes.

Como amquina virtual deve trabalhar com diversas linguagens de programao diferentes, a CLR no podeexecutar diretamente o cdigo do C#, ela precisa executar uma linguagem intermediria comum a todas aslinguagens da plataforma .Net, aCIL (Common Intermediate Language). Para gerar o CIL que ser executadopela CLR, precisamos passar o cdigo C# por um compilador da linguagem, como o programa csc.exe. Ocompilador l o arquivo com o cdigo fonte do programa e o traduz para o cdigo intermedirio que serexecutado pela mquina virtual.

Common Language Infrastructure

A infraestrutura necessria para executar os cdigos escritos para a plataforma .Net chamadade CLI (Common Language Infrastructure). A CLI engloba a mquina virtual do C# (CLR), alinguagem intermediria (CIL) e os tipos base utilizados nos programas.

2.3 Execuo do cdigo na CLR e o JIT

Para executarmos uma aplicao C#, precisamos passar o cdigo CIL do programa para a CLR, a mquinavirtual do .Net. A CLR por sua vez precisa executar o cdigo da aplicao no sistema operacional do usurioe, para isso, precisa emitir o cdigo de mquina correto para o ambiente em que o programa est sendoexecutado. Mas a CLR no interpreta o CIL do programa, isso seria muito lento, ao invs disso, quandoo programa C# carregado na memria, a CLR converte automaticamente o cdigo CIL para cdigo demquina, esse processo feito por um compilador Just in Time (JIT) da CLR.

Esse carregamento utilizando o JIT faz comque o cdigo escrito na linguagemC# execute comodesempenhomximo, o mesmo de um programa escrito em linguagens que compilam diretamente para o cdigo demquina, mas com a vantagem de executar no ambiente integrado do .Net.

2.4 O ambiente de desenvolvimento do C#

Nesse curso escreveremos todo o cdigo utilizando o Visual Studio Express Edition, a verso gratuita daferramenta de desenvolvimento de aplicaes distribuda pela prpria Microso. Apesar das explicaesserem feitas com base na verso express, tudo funcionar da mesma forma dentro das verses pagas daferramenta.

O Visual Studio Express Edition pode ser encontrado no site:

http://bit.ly/1fb6Ay8

Captulo 2 - O que C# e .Net - Execuo do cdigo na CLR e o JIT - Pgina 6


A verso que utilizaremos na apostila a Visual Studio 2013 for Windows Desktop.

Durante a instalao do Visual Studio, o .Net Framework tambm ser automaticamente instalado em suamquina, ento ela estar pronta executar as aplicaes escritas em C#.

2.5 Executando aplicaes sem o Visual Studio

Como vimos anteriormente, para executarmos uma aplicao C# precisamos da mquina virtual da lin-guagem alm das bibliotecas do .Net Framework. Ao instalarmos o Visual Studio, todo esse ambiente deexecuo de programas automaticamente instalado em nossas mquinas, mas e se quisermos executar oprograma em um computador que no tenha o Visual Studio instalado, o computador de um cliente, porexemplo?

Nesse caso precisamos instalar apenas o ambiente de execuo no computador do cliente. Para isso podemosutilizar um pacote de instalao fornecido pela prpria Microso, esses so os .Net Framework Redistribu-table. O pacote de instalao para a ltima verso do .Net Framework (4.5.1 lanada em 2013) pode serencontrada no seguinte site:

http://www.microsoft.com/en-us/download/details.aspx?id=40779

C# em outros ambientes

Podemos tambm executar o cdigo C# dentro de ambientes no windows utilizando imple-mentaes livres do Common Language Infrastructure. Uma implementao do ambiente deexecuo para ambientes no Windows o Mono:

http://www.mono-project.com/Main_Page

2.6 O primeiro programa em C#

Agora que j entendemos o funcionamento da linguagem C#, vamos comear a desenvolver a primeira apli-cao utilizando o Visual Studio. Para criarmos um programa C# utilizando o Visual Studio precisamosinicialmente de um novo projeto.

Dentro do Visual Studio 2013, aperte o atalho Ctrl + Shift + N para abrir o assistente de criao de novoprojeto.

Captulo 2 - O que C# e .Net - Executando aplicaes sem o Visual Studio - Pgina 7


No canto esquerdo da janela do assistente de criao de novo projeto, podemos escolher a linguagem deprogramao que desejamos utilizar, escolha a opo Visual C#. Como tipo de projeto escolha a opoWindows Form Application, com isso estamos criando um novo projeto de interface grca utilizando oC#.

No canto inferior da janela, podemos escolher o nome do projeto alm da pasta em que ele ser armazenado.Utilizaremos ProjetoInicial como nome desse novo projeto.

Captulo 2 - O que C# e .Net - O primeiro programa em C# - Pgina 8


Queremos inicialmente colocar umboto no formulrio que, quando clicado, abrir uma caixa demensagemdoWindows.

Para colocarmos o boto no formulrio, precisamos abrir uma nova janela do Visual Studio chamada Tool-box, que ca no canto esquerdo da janela do formulrio. O Toolbox tambm pode ser aberto utilizando-seo atalho Ctrl + W, X. Dentro da janela do Toolbox, no grupo Common Controls, clique no componentebutton e arraste-o para o formulrio.

Agora d um duplo clique no boto que acabamos de adicionar para programarmos o que deve acontecerquando o boto for clicado. O Visual Studio abrir o cdigo do formulrio. No se preocupe com todo ocdigo complicado que est escrito nesse arquivo, entenderemos o signicado de cada uma dessas linhasmais a frente no curso.



using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;

namespace form{

public partial class Form1 : Form{

public Form1(){

InitializeComponent();}

private void button1_Click(object sender, EventArgs e){

}}

}

O trecho de cdigo que nos interessa no momento :


}

Todo cdigo que for colocado dentro das chaves ser executado quando o boto for clicado.

No clique do boto, queremos executar o comando que mostra uma caixa de mensagens para o usurio.

MessageBox.Show(mensagem)

No C#, todo comando deve ser terminado pelo caractere ;. Portanto, o cdigo para mostrar a caixa demensagem ca da seguinte forma:

MessageBox.Show(mensagem);

Queremos que, ao clicar no boto, amensagem Hello World seja exibida emuma caixa demensagens. Ento,utilizaremos o seguinte cdigo:




MessageBox.Show(Hello World);}

Como a mensagem somente um texto, o compilador do C# nos fora a coloc-la entre aspas duplas. Por-tanto, o cdigo do clique do boto car assim:


MessageBox.Show("Hello World");}

O cdigo completo ca:

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;

namespace form{

public partial class Form1 : Form{

public Form1(){

InitializeComponent();}


MessageBox.Show("Hello World");}

}}

No se preocupe com as linhas de cdigo que no foram explicadas. Entenderemos o que elas fazem duranteo curso.

Aperte F5 para executar o cdigo do formulrio. O resultado deve ser algo parecido com a imagem a seguir:



2.7 Exerccios

1) Qual a mensagem que ser exibida na caixa de texto criada pelo seguinte cdigo?

MessageBox.Show("Curso de C# da Caelum");

Hello World

Curso de C# da Caelum

Ol Mundo

Caelum

Nenhuma das opes

2.8 O que aconteceu durante a execuo?

Vimos que quando apertamos a tecla F5 do teclado dentro do Visual Studio, nosso programa executado.Agora vamos entender o que aconteceu.

Quando pedimos para o Visual Studio executar uma aplicao, ele chama o compilador da linguagem C#passando os arquivos de texto que contm o cdigo da aplicao (cdigo fonte do programa). Caso o c-digo fonte no tenha nenhum erro de sintaxe, o compilador gera o cdigo intermedirio (CIL, CommonIntermediate Language) que entendido pela mquina virtual da linguagemC#, a CLR (Common LanguageRuntime). O cdigo CIL colocado em um arquivo executvel (arquivo com extenso .exe) dentro da pastado projeto. Esse arquivo que resultado da compilao do programa chamado de Assembly dentro dalinguagem C#.

Depois da compilao, o Visual Studio executa o assembly gerado na mquina virtual do C#. A CLR por suavez carrega o cdigo CIL que foi gerado pelo compilador e o executa no sistema operacional, mas se a CLR

Captulo 2 - O que C# e .Net - Exerccios - Pgina 12


interpretasse o cdigo CIL para linguagem de mquina, o desempenho do C# no seria muito bom, e porisso, quando um programa C# carregado pela CLR ele j automaticamente convertido para linguagem demquina por um processo conhecido como JIT (Just-in-time). Ento no C#, o cdigo sempre executadocom o mesmo desempenho do cdigo de mquina.

Captulo 2 - O que C# e .Net - O que aconteceu durante a execuo? - Pgina 13

Captulo 3

Variveis e tipos primitivos

Namaioria dos programas que escrevemos, no estamos interessados em apenas mostrar uma caixa demen-sagens para o usurio. Queremos tambm armazenar e processar informaes.

Em um sistema bancrio, por exemplo, estaramos interessados em armazenar o saldo de uma conta e onome do correntista. Para armazenar esses dados, precisamos pedir para o C# reservar regies de memriaque sero utilizadas para armazenar informaes. Essas regies de memria so conhecidas como variveis.

As variveis guardam informaes de um tipo especco. Podemos, por exemplo, guardar umnmero inteirorepresentando o nmero da conta, um texto para representar o nome do correntista ou um nmero real pararepresentar o saldo atual da conta. Para utilizar uma varivel, devemos primeiramente declar-la no textodo programa.

Na declarao de uma varivel, devemos dizer seu tipo (inteiro, texto ou real, por exemplo) e, alm disso,qual o nome que usaremos para referenci-la no texto do programa. Para declarar uma varivel do tipointeiro que representa o nmero de uma conta, utilizamos o seguinte cdigo:

int numeroDaConta;

Repare no ; no nal da linha. Como a declarao de uma varivel um comando da linguagem C#, precisa-mos do ; para termin-lo.

Alm do tipo int (para representar inteiros), temos tambm os tipos double e float (para nmeros reais),string (para textos), entre outros.

Depois de declarada, uma varivel pode ser utilizada para armazenar valores. Por exemplo, se estivssemosinteressados em guardar o valor 1 na varivel numeroDaConta que declaramos anteriormente, utilizaramoso seguinte cdigo:

numeroDaConta = 1;


L-se numeroDaConta recebe 1. Quando, no momento da declarao da varivel, sabemos qual ser seuvalor, podemos utilizar a seguinte sintaxe para declarar e atribuir o valor para a varivel.

double saldo = 100.0;

3.1 Operaes com variveis

Agora que j sabemos como guardar informaes no programa, estamos interessados em executar operaesnesses valores. Pode ser interessante para um correntista saber qual ser o saldo de sua conta aps um saquede 10 reais. Para realizar essa operao, devemos subtrair 10 reais do saldo da conta:

double saldo = 100.0;saldo = saldo - 10.0;

Nesse cdigo, estamos guardando na varivel saldo o valor da conta 100.0 (saldo antigo) menos 10.0 entoseu valor nal ser de 90.0. Da mesma forma que podemos subtrair valores, podemos tambm fazer somas(com o operador +), multiplicaes (operador *) e divises (operador /).

Podemos ainda guardar o valor do saque em uma varivel:

double saldo = 100.0;double valorDoSaque = 10.0;saldo = saldo - valorDoSaque;

Depois de realizar o saque, queremos mostrar para o usurio qual o saldo atual da conta. Para mostrarmosessa informao, utilizaremos novamente o MessageBox.Show:

MessageBox.Show("O saldo da conta aps o saque : " + saldo);

Veja que, no cdigo do saque, estamos repetindo o nome da varivel saldo dos dois lados da atribuio.Quando temos esse tipo de cdigo, podemos utilizar uma abreviao disponibilizada pelo C#, o operador-=:

double saldo = 100.0;double valorDoSaque = 10.0;saldo -= valorDoSaque;

Quando o compilador do C# encontra o saldo -= valorDoSaque, essa linha traduzida para a forma quevimos anteriormente: saldo = saldo - valorDoSaque. Alm do -=, temos tambm os operadores += (parasomas), *= (para multiplicaes) e /= (para divises).

Captulo 3 - Variveis e tipos primitivos - Operaes com variveis - Pgina 15


3.2 Tipos Primitivos

Vimos que noC# toda varivel possui um tipo, utilizamos o int quando queremos armazenar valores inteirose double para nmeros reais. Agora vamos descobrir quais so os outros tipos de variveis do C#.

Os tipos listados nessa tabela so conhecidos como tipos primitivos ou value types da linguagem C#. Todavez que atribumos umvalor para uma varivel de um tipo primitivo, o C# copia o valor atribudo para dentroda varivel.

Agora que conhecemos os tipos primitivos da linguagem C#, vamos ver como que eles interagem dentrode uma aplicao. Suponha que temos um cdigo que declara uma varivel do tipo inteiro e depois tentacopiar seu contedo para uma varivel long:

int valor = 1;long valorGrande = valor;

Nesse caso, como o tamanho de uma varivel long maior do que o de uma varivel int, o C# sabe quepodemos copiar o seu contedo sem perder informaes e, por isso, esse um cdigo que compila semnenhum erro. Agora vamos tentar copiar o int para uma varivel do tipo short:

int valor = 1;short valorPequeno = valor;

Captulo 3 - Variveis e tipos primitivos - Tipos Primitivos - Pgina 16


Nesse cdigo, tentamos copiar o contedo de uma varivel maior para dentro de uma de tamanho menor.Essa cpia pode ser perigosa pois o valor que est na varivel do tipo int pode no caber na varivel shorte, por isso, o compilador do C# gera um erro de compilao quando tentamos fazer essa converso.

Para forarmos o compilador do C# a fazer uma converso perigosa, precisamos utilizar uma operao doC# chamada casting falando para qual tipo queremos fazer a converso.

int valor = 1;short valorPequeno = (short) valor;

3.3 Armazenando texto em variveis

Alm dos tipos primitivos, o C# tambm possui um tipo especco para armazenar textos. No tipo string,podemos guardar qualquer valor que seja delimitado por aspas duplas, por exemplo:

string mensagem = "Minha Mensagem";MessageBox.Show(mensagem);

Podemos juntar o valor de duas variveis do tipo string utilizando o operador + da linguagem. A soma destrings uma operao conhecida como concatenao.

string mensagem = "Ol ";string nome = "victor";

MessageBox.Show(mensagem + nome);

Esse cdigo imprime o texto Ol victor em uma caixa demensagens. Podemos utilizar a concatenao paraadicionar o contedo de qualquer varivel em uma string:

int idade = 25;string mensagem = "sua idade : " + idade;

MessageBox.Show(mensagem);

Esse segundo cdigo imprime o texto sua idade : 25.

3.4 Documentando o cdigo atravs de comentrios

Quando queremos documentar o signicado de algum cdigo dentro de um programa C#, podemos utilizarcomentrios. Para fazermos um comentrio de uma linha, utilizamos o //. Tudo que estiver depois do // considerado comentrio e, por isso, ignorado pelo compilador da linguagem.

Captulo 3 - Variveis e tipos primitivos - Armazenando texto em variveis - Pgina 17


double saldo = 100.0; // Isso um comentrio e ser ignorado pelo compilador

Muitas vezes precisamos escrever diversas linhas de comentrios para, por exemplo, documentar uma lgicacomplexa da aplicao. Nesses casos podemos utilizar o comentrio de mltiplas linhas que inicializadopor um /* e terminado pelo */. Tudo que estiver entre a abertura e o fechamento do comentrio ignoradopelo compilador da linguagem:

/*Isso um comentriode mltiplas linhas

*/

3.5 Exerccios

Faa o cdigo dos exerccios do captulo dentro de botes no formulrio do projeto inicial, cada exercciodeve car na ao de um boto diferente.

1) Crie 3 variveis com as idades dos seus melhores amigos e/ou familiares. Algo como:

int idadeJoao = 10;int idadeMaria = 25;

Em seguida, pegue essas 3 idades e calcule a mdia delas. Exiba o resultado em umMessageBox.

2) O que acontece com o cdigo abaixo?

int pi = 3.14;

O cdigo compila, e pi guarda o nmero 3

O cdigo compila, e pi guarda 3.14 (inteiros podem guardar casas decimais)

O cdigo no compila, pois 3.14 no cabe dentro de um inteiro

3) Execute o trecho de cdigo a seguir. O que acontece com ele?

double pi = 3.14;int piQuebrado = (int)pi;MessageBox.Show("piQuebrado = " + piQuebrado);

Repare o (int). Estamos forando a converso do double para um inteiro.

Qual o valor de piQuebrado nesse caso?

3.14

0

3

Captulo 3 - Variveis e tipos primitivos - Exerccios - Pgina 18


4) (Opcional) No colegial, aprendemos a resolver equaes de segundo grau usando a frmula de Bhaskara.A frmula assim:

delta = b*b - 4*a*c;a1 = (-b + raiz(delta)) / (2 * a);a2 = (-b - raiz(delta)) / (2 * a);

Crie um programa com trs variveis inteiras, a, b, c, com quaisquer valores. Depois crie 3 variveisdouble, delta, a1, a2, com a frmula anterior.

Imprima a1 e a2 em umMessageBox.

Dica: Para calcular raiz quadrada, use Math.Sqrt(variavel). No se esquea que no podemos calculara raiz quadrada de nmeros negativos.

Captulo 3 - Variveis e tipos primitivos - Exerccios - Pgina 19

Captulo 4

Estruturas de controle

4.1 Tomando decises no cdigo

Voltando para nosso exemplo de aplicao bancria, queremos permitir um saque somente se o valor a serretirado for menor ou igual ao saldo da conta, ou seja, se o saldo da conta for maior ou igual ao valor dosaque, devemos permitir a operao, do contrrio no podemos permitir o saque. Precisamos fazer execuocondicional de cdigo.

No C#, podemos executar cdigo condicional utilizando a construo if:

if (condicao){

// Esse cdigo ser executado somente se a condio for verdadeira}

No nosso exemplo, queremos executar a lgica de saque apenas se o saldo for maior ou igual ao valor dosaque:

double saldo = 100.0;double valorSaque = 10.0;if (saldo >= valorSaque){

// cdigo do saque.}

O cdigo do saque deve diminuir o saldo da conta e mostrar uma mensagem para o usurio indicando queo saque ocorreu com sucesso:



saldo = saldo - valorSaque;MessageBox.Show("Saque realizado com sucesso");

}

Repare que, se a conta no tiver saldo suciente para o saque, o usurio no avisado. Ento estamos naseguinte situao: Se a conta tiver saldo suciente, quero fazer o saque, seno, quero mostrar a mensagemSaldo Insuciente para o usurio. Para fazer isso, podemos usar o else do C#:

if (saldo >= valorSaque){

// cdigo do saque}else{

MessageBox.Show("Saldo Insuficiente");}

4.2 Mais sobre condies

Repare na expresso que passamos para o if: saldo >= valorSaque. Nele, utilizamos o operador maior ouigual. Alm dele, existem outros operadores de comparao que podemos utilizar: maior (>), menor (= valorSaque);

Tambm podemos realizar algumas operaes com valores do tipo bool. Podemos, por exemplo, vericar seduas condies so verdadeiras ao mesmo tempo usando o operador && (AND) para fazer um e lgico:

bool realmentePodeSacar = (saldo >= valorSaque) && (valorSaque > 0);

Quando precisamos de um OU lgico, utilizamos o operador ||:

Captulo 4 - Estruturas de controle - Mais sobre condies - Pgina 21


// essa condio verdadeira se (saldo >= valorSaque) for true// ou se (valorSaque > 0) for verdadeiro.bool realmentePodeSacar = (saldo >= valorSaque) || (valorSaque > 0);

Assim, podemos construir condies mais complexas para um if. Por exemplo, podemos usar a varivelrealmentePodeSacar declarada no if que verica se o cliente pode sacar ou no:

if (realmentePodeSacar){

// cdigo do saque}else{


4.3 Exerccios opcionais

1) Qual a mensagem e o valor da varivel saldo aps a execuo do seguinte cdigo?


saldo -= valorSaque;MessageBox.Show("Saque realizado com sucesso");

}else{


mensagem: Saque realizado com sucesso; saldo: 90.0

mensagem: Saldo Insuciente; saldo 90.0




2) Qual a mensagem e o valor da varivel saldo aps a execuo do seguinte cdigo?

double saldo = 5.0;double valorSaque = 10.0;

Captulo 4 - Estruturas de controle - Exerccios opcionais - Pgina 22


if (saldo >= valorSaque){

saldo -= valorSaque;MessageBox.Show("Saque realizado com sucesso");

}else{


mensagem: Saque realizado com sucesso; saldo: -5.0

mensagem: Saldo Insuciente; saldo -5.0




3) Em alguns casos, podemos ter mais de duas decises possveis. O banco pode, por exemplo, decidir quecontas com saldo menor que R$ 1000 pagam 1% de taxa de manuteno, contas com saldo entre R$ 1000e R$ 5000 pagam 5% e contas com saldo maior que R$ 5000 pagam 10%.

Para representar esse tipo de situao, podemos usar o else if do C#, que funciona em conjunto com oif que j conhecemos. Veja como caria a situao descrita anteriormente:

double taxa;if (saldo < 1000){

taxa = 0.01;}else if (saldo


double saldo = 500.0;if (saldo < 0.0){

MessageBox.Show("Voc est no negativo!");}else if (saldo < 1000000.0){

MessageBox.Show("Voc um bom cliente");}else{

MessageBox.Show("Voc milionrio!");}

Voc est no negativo!

Voc um bom cliente

Nenhuma mensagem

Voc milionrio!

Voc um bom cliente, seguida de Voc milionrio!

4) Uma pessoa s pode votar em eleies brasileiras se ela for maior que 16 anos e for cidad brasileira. Crieum programa com duas variveis, int idade, bool brasileira, e faa com que o programa diga se apessoa est apta a votar ou no, de acordo com os dados nas variveis.

5) Crie um programa que tenha uma varivel double valorDaNotaFiscal e, de acordo com esse valor, oimposto deve ser calculado. As regras de clculo so:

Se o valor for menor que 999, o imposto deve ser de 2%

Se o valor estiver entre 1000 e 2999, o imposto deve ser de 2.5%

Se o valor estiver entre 3000 e 6999, o imposto deve ser de 2.8%

Se for maior ou igual a 7000, o imposto deve ser de 3%

Imprima o imposto em umMessageBox.

Captulo 4 - Estruturas de controle - Exerccios opcionais - Pgina 24

Captulo 5

Estruturas de repetio

5.1 Repetindo um bloco de cdigo

De volta ao exemplo da aula anterior, suponha agora que o cliente desse mesmo banco queira saber quantoele ganhar, ao nal de 1 ano, caso ele invista um valor. O investimento paga 1% do valor investido ao ms.

Por exemplo, se o cliente investir R$ 1000,00, ao nal de 12 meses, ter por volta de R$ 1126,82: no primeiroms, R$ 1000,00 + R$1000,00 * 1% = R$ 1010,00; no segundoms, R$ 1010,00 + R$1010,00 * 1% = R$ 1020,10;e assim por diante. Ou seja, para calcular o quanto ele ter ao nal de um ano, podemos multiplicar o valorinvestido 12 vezes por 1%.

Para resolvermos esse problema, precisamos fazer uso de uma estrutura de controle que repete um determi-nado bloco de cdigo at que uma condio seja satisfeita. Essa estrutura recebe o nome de loop.

Para fazer um loop no C#, utilizaremos, inicialmente, a instruo for. O for uma instruo que possui trspartes:

A primeira parte a inicializao, na qual podemos declarar e inicializar uma varivel que ser utilizadano for;

A segunda parte a condio do loop. Enquanto a condio do loop for verdadeira, o loop continuarexecutando;

A terceira parte a atualizao, na qual podemos atualizar as variveis que so utilizadas pelo for.

Cada uma das partes do for separada por um ;.

for (inicializao; condio; atualizao){

// Esse cdigo ser executado enquanto a condio for verdadeira}


Veja o cdigo a seguir, por exemplo, em que usamos um for que repetir o clculo 12 vezes:

double valorInvestido = 1000.0;for (int i = 1; i


int valor = 1;

valor = valor + 1;// ouvalor += 1;

Porm, como incrementar o valor de uma varivel uma atividade comumna programao, o C# nos ofereceo operador ++ para realizar esse trabalho:

int valor = 1;valor++;

Temos ainda o operador -- que realiza o decremento de uma varivel.

5.4 Exerccios

1) Qual o valor exibido no seguinte cdigo:

int total = 2;for (int i = 0; i < 5; i += 1){

total = total * 2;}MessageBox.Show("O total : " + total);

256

64

128

512

2) Faa um programa em C# que imprima a soma dos nmeros de 1 at 1000.

3) Faa um programa em C# que imprima todos os mltiplos de 3, entre 1 e 100.

Para saber se um nmero mltiplo de 3, voc pode fazer if(numero % 3 == 0).

4) (Opcional) Escreva um programa em C# que some todos os nmeros de 1 a 100, pulando os mltiplos de3. O programa deve imprimir o resultado nal em umMessageBox.

Qual o resultado?

5) (Opcional) Escreva um programa em C# que imprime todos os nmeros que so divisveis por 3 ou por4 entre 0 e 30.

Captulo 5 - Estruturas de repetio - Exerccios - Pgina 27


6) (Opcional) Faa um programa em C# que imprima os fatoriais de 1 a 10.

O fatorial de um nmero n n * n-1 * n-2 ... at n = 1.

O fatorial de 0 1

O fatorial de 1 (0!) * 1 = 1

O fatorial de 2 (1!) * 2 = 2

O fatorial de 3 (2!) * 3 = 6

O fatorial de 4 (3!) * 4 = 24

Faa um for que inicie uma varivel n (nmero) como 1 e fatorial (resultado) como 1 e varia n de 1 at 10:

int fatorial = 1;for (int n = 1; n

Captulo 6

Classes e objetos

Neste momento, queremos representar diversas contas em nosso banco. Uma conta bancria geralmentecomposta por um nmero, nome do titular e saldo. Podemos guardar essas informaes em variveis:

int numeroDaConta1 = 1;string titularDaConta1 = "Joaquim Jos";double saldoDaConta1 = 1500.0;

Para representar outros correntistas, precisamos de novas variveis:

int numeroDaConta2 = 2;string titularDaConta2 = "Silva Xavier";double saldoDaConta2 = 2500.0;

Veja que, como as informaes das contas esto espalhadas em diversas variveis diferentes, muito fcilmisturarmos essas informaes dentro do cdigo. Alm disso, imagine que antes de adicionarmos a contana aplicao precisamos fazer uma validao doCPFdo titular. Nesse caso precisaramos chamar uma funoque executa essa validao, mas como podemos garantir que essa validao sempre executada?

Esses pontos listados so alguns dos problemas do estilo de programao procedural. Quando trabalha-mos com programao procedural, os dados da aplicao cam separados da implementao das lgicas denegcio e, alm disso, muito difcil garantir as validaes dos dados da aplicao.

6.1 Organizando o cdigo comObjetos

Para comearmos com a orientao a objetos, vamos inicialmente pensar quais so as informaes que des-crevem uma determinada Conta. Toda conta bancria possui um nmero, titular e saldo. Para representar-mos a conta com essas informaes dentro do projeto, no C#, precisamos criar uma classe. Dentro do C# a


declarao da classe feita utilizando-se a palavra class seguida do nome da classe que queremos implemen-tar:

class Conta{

}

O cdigo da classe Conta, por conveno, deve car dentro de um arquivo com o mesmo nome da classe,ento a classe Conta ser colocado em arquivo chamado Conta.cs.

Dentro dessa classe queremos armazenar as informaes que descrevem as contas, fazemos isso declarandovariveis dentro da classe, essas variveis so os atributos:

class Conta{

int numero;string titular;double saldo;

}

Porm, para que o cdigo da aplicao possa ler e escrever nesses atributos, precisamos declar-los utilizandoa palavra public:

class Conta{

// numero, titular e saldo so atributos do objetopublic int numero;public string titular;public double saldo;

}

Para utilizarmos a classe que criamos dentro de uma aplicao windows form, precisamos criar uma novaconta no cdigo do formulrio, fazemos isso utilizando a instruo new do C#:

// cdigo do formulrioprivate void button1_Click(object sender, EventArgs e){

new Conta();}

Quando utilizamos o new dentro do cdigo de uma classe estamos pedindo para o C# criar uma nova ins-tncia de Conta na memria, ou seja, o C# alocar memria suciente para guardar todas as informaes daConta dentro da memria da aplicao.

Captulo 6 - Classes e objetos - Organizando o cdigo com Objetos - Pgina 30


Alm disso, o new possui mais uma funo, devolver a referncia, uma seta que aponta para o objeto emmemria, que ser utilizada para manipularmos a Conta criada. Podemos guardar essa referncia dentro deuma varivel do tipo Conta:


Conta c = new Conta();}

Na memria da aplicao teremos uma situao parecida com a ilustrada na imagem a seguir:

Veja que a classe funciona como uma receita que ensina qual o formato de uma Conta dentro da aplicao.A Conta que foi criada na memria pelo operador new chamada de instncia ou objeto.

E agora para denirmos os valores dos atributos que sero armazenados na Conta, precisamos acessar oobjeto que vive na memria. Fazemos isso utilizando o operador . do C#, informando qual o atributo quequeremos acessar. Para, por exemplo, guardarmos o valor 1 como nmero da conta que criamos, utilizamoso cdigo a seguir:


Conta c = new Conta();c.numero = 1;

}

Captulo 6 - Classes e objetos - Organizando o cdigo com Objetos - Pgina 31


Com esse cdigo, estamos navegando na referncia armazenada na varivel c, e acessando o campo nmerodo objeto Conta que vive na memria. Dentro desse campo colocamos o valor 1. Podemos fazer o mesmopara os outros campos da Conta:


Conta c = new Conta();c.numero = 1;c.titular = "victor";c.saldo = 100;

}

Depois da execuo desse cdigo, teremos a seguinte situao na memria da aplicao:

Veja que, quando utilizamos umobjeto para guardar informaes, todos os atributos cam agrupados dentrode um nico objeto na memria, e no espalhados dentro de diversas variveis diferentes.

6.2 Extraindo comportamentos atravs de mtodos

Agora que conseguimos criar a primeira conta da aplicao, vamos tentar fazer algumas operaes. A pri-meira operao que queremos implementar a operao de tirar dinheiro da conta. Para isso, como vimosno captulo anterior, podemos utilizar o operador -= do C#:

Conta c = new Conta();c.numero = 1;

Captulo 6 - Classes e objetos - Extraindo comportamentos atravs de mtodos - Pgina 32


c.titular = "victor";c.saldo = 100;// a conta termina com saldo de 50.0c.saldo -= 50.0;

Mas o que aconteceria se tentssemos tirar mais 100.0 dessa conta?

c.saldo -= 100.0;

Ao executarmos essa segunda operao, a conta terminar com saldo de -50.0, pormnesse sistema as contasno podem car com saldo negativo! Portanto, antes de tirarmos dinheiro da conta, precisamos vericar seela possui saldo suciente.

if(c.saldo >= 100.0){

c.saldo -= 100.0;}

Repare que teremos que copiar e colar essa vericao em todos os pontos da aplicao em que desejamosfazer um saque, mas o que aconteceria se fosse necessrio cobrar uma taxa em todos os saques? Teramosque modicar todos os pontos em que o cdigo foi copiado. Seria mais interessante isolar esse cdigo dentrode um comportamento da Conta.

Alm de atributos, os objetos tambmpodempossuirmtodos. Osmtodos so blocos de cdigo que isolamlgicas de negcio do objeto. Ento podemos isolar a lgica do saque dentro de um mtodo Saca da classeConta.

Para declarar um mtodo chamado Saca na classe Conta, utilizamos a seguinte sintaxe:

class Conta{

// declarao dos atributos

public void Saca(){

// Implementao do mtodo}

}

Dentro desse mtodo Saca, colocaremos o cdigo da lgica de saque.

public void Saca(){

if(c.saldo >= 100.0)



{c.saldo -= 100.0;

}}

Porm, nesse cdigo temos dois problemas: no podemos utilizar a varivel c, pois ela foi declarada noformulrio e no dentro do mtodo e o valor do saque est constante.

Nesse mtodo Saca, queremos vericar o saldo da conta em que o mtodo foi invocado. Para acessarmos areferncia em que um determinado mtodo foi chamado, utilizamos a palavra this. Ento para acessarmoso saldo da conta, podemos utilizar this.saldo:

public void Saca(){

if(this.saldo >= 100.0){

this.saldo -= 100.0;}

}

Podemos utilizar o Saca dentro do formulrio com o seguinte cdigo:

Conta c = new Conta();// inicializa as informaes da contac.saldo = 100.0;

// Agora chama o mtodo Saca que foi definido na classec.Saca();

Agora vamos resolver o problema do valor xo do saque. Quando queremos passar um valor para um m-todo, precisamos passar esse valor dentro dos parnteses da chamada do mtodo:

Conta c = new Conta();// inicializa as informaes da contac.saldo = 100.0;

// Agora chama o mtodo Saca que foi definido na classec.Saca(10.0);

Para recebermos o valor que foi passado na chamada do Saca, precisamos declarar um argumento no m-todo. O argumento uma varivel declarada dentro dos parnteses do mtodo:

public void Saca(double valor){



if(this.saldo >= valor){

this.saldo -= valor;}

}

Ummtodo pode ter qualquer nmero de argumentos. Precisamos apenas separar a declarao das variveiscom uma vrgula.

6.3 Devolvendo valores de dentro do mtodo

Agora que colocamos o mtodo Saca dentro da classe Conta, no precisamos replicar o cdigo de validaodo saque em todos os pontos do cdigo, podemos simplesmente utilizar o mtodo criado, alm disso, seprecisarmos modicar a lgica do saque, podemos simplesmente atualizar o cdigo daquele mtodo, umnico ponto do sistema.

Mas da forma que foi implementado, o usurio desse mtodo no sabe se o saque foi ou no bem sucedido.Precisamos fazer com que o mtodo devolva um valor booleano indicando se a operao foi ou no bemsucedida. Devolveremos true caso a operao seja bem sucedida e false caso contrrio. Quando ummtododevolve um valor, o tipo do valor devolvido deve car antes do nome domtodo em sua declarao. Quandoum mtodo no devolve valor algum, utilizamos o tipo void.

// Estamos declarando que o mtodo devolve um valor do tipo boolpublic bool Saca(double valor){

// implementao do mtodo}

Dentro da implementao do mtodo, devolvemos um valor utilizamos a palavra return seguida do valorque deve ser devolvido. Ento a implementao do Saca ca da seguinte forma:

public bool Saca(double valor){


this.saldo -= valor;return true;

}else{

return false;}

}

Captulo 6 - Classes e objetos - Devolvendo valores de dentro do mtodo - Pgina 35


Quando o C# executa um return, ele imediatamente devolve o valor e sai do mtodo, ento podemos sim-plicar a implementao do Saca para:

public bool Saca(double valor){


this.saldo -= valor;return true;

}return false;

}

No formulrio podemos recuperar o valor devolvido por um mtodo.

Conta c = new Conta();// inicializa os atributos

// Se a conta tiver saldo suficiente, deuCerto conter o valor true// seno, ela conter falsebool deuCerto = c.Saca(100.0);

if(deuCerto){

MessageBox.Show("Saque realizado com sucesso");}else{


Ou podemos utilizar o retorno do mtodo diretamente dentro do if:

Conta c = new Conta();// inicializa os atributos

if(c.Saca(100.0)){

MessageBox.Show("Saque realizado com sucesso");}else{


Captulo 6 - Classes e objetos - Devolvendo valores de dentro do mtodo - Pgina 36


6.4 Valor padro dos atributos da classe

Agora que terminamos de implementar a lgica de saque da conta, vamos tambm implementar o mtodode depsito. Esse mtodo no devolver nenhum valor e receber um double como argumento:

public void Deposita(double valor){

this.saldo += valor;}

No formulrio principal da aplicao, podemos inicializar o saldo inicial com o mtodo Deposita:

Conta c = new Conta();c.Deposita(100.0);

Nesse cdigo estamos tentando depositar 100 reais em uma conta que acabou de ser criada e o mtodoDeposita tenta somar os 100.0 no valor inicial do atributo saldo da conta. Mas qual o valor inicial de umatributo?

Quando declaramos uma varivel no C#, ela comea com um valor indenido, logo no podemos utiliz-la enquanto seu valor no for inicializado, porm a linguagem trata os atributos de uma classe de formadiferenciada. Quando instanciamos uma classe, todos os seus atributos so inicializados para valores pa-dro. Valores numricos so inicializados para zero, o bool inicializado para false e atributos que guardamreferncias so inicializados para a referncia vazia (valor null do C#).

Ento, no exemplo, quando depositamos 100 reais na conta recm-criada, estamos somando 100 no saldoinicial da conta, que zero, e depois guardando o resultado de volta no saldo da conta.

Podemos mudar o valor padro de um determinado atributo colocando um valor inicial em sua declarao.Para inicializarmos a conta com saldo inicial de 100 reais ao invs de zero, podemos utilizar o seguinte cdigo:

class Conta{

public double saldo = 100.0;

// outros atributos e mtodos da classe}

Agora toda conta criada j comear com um saldo inicial de 100.0.

6.5 Mais um exemplo: Transfere

Agora vamos tentar implementar a operao de transferncia de dinheiro entre duas contas. Dentro da classeConta criaremos mais um mtodo chamado Transfere, esse mtodo receber o valor da transferncia e ascontas que participaro da operao:

Captulo 6 - Classes e objetos - Valor padro dos atributos da classe - Pgina 37


public void Transfere(double valor, Conta origem, Conta destino){

// implementao da transferncia}

Mas ser que realmente precisamos receber as duas contas como argumento do mtodo Transfere? Vamosver como esse mtodo ser utilizado dentro do cdigo do formulrio:

Conta victor = new Conta();// inicializao da contavictor.saldo = 1000;

Conta guilherme = new Conta();// inicializao da conta

// Agora vamos transferir o dinheiro da conta do victor para a do guilhermevictor.Transfere(10.0, victor, guilherme);

Repare que no uso do mtodo estamos repetindo duas vezes a varivel victor, porm isso no necessrio.Podemos utilizar o this para acessar a conta de origem dentro do mtodo, ento na verdade o mtodoTransfere precisa receber apenas a conta de destino:

public void Transfere(double valor, Conta destino){

// implementao da transferncia}

Antes de tirarmos dinheiro da conta de origem (this), precisamos vericar se ela tem saldo suciente, so-mente nesse caso queremos sacar o dinheiro da conta de origem e depositar na conta de destino:



this.saldo -= valor;destino.saldo += valor;

}}

Mas esse comportamento de vericar se a conta tem saldo suciente antes de realizar o saque o compor-tamento do mtodo Saca que foi implementado anteriormente, alm disso, somar um valor no saldo aoperao Deposita da conta. Portanto, podemos utilizar os mtodos Saca e Deposita existentes para imple-mentar o Transfere:

Captulo 6 - Classes e objetos - Mais um exemplo: Transfere - Pgina 38



if(this.Saca(valor)){

destino.Deposita(valor);}

}

6.6 Conveno de nomes

Quando criamos uma classe, importante lembrarmos que seu cdigo ser lido por outros desenvolvedoresda equipe e, por isso, recomendvel seguir padres de nomenclatura.

Quando criamos uma classe, a recomendao utilizar o Pascal Casing para nomear a classe:

Se o nome da classe composto por uma nica palavra, colocamos a primeira letra dessa palavra emmaiscula (conta se torna Conta);

Se o nome composto por diversas palavras, juntamos todas as palavras colocando a primeira letra decada palavra em maiscula (seguro de vida se torna SeguroDeVida).

No caso do nome demtodos, a conveno tambm utilizar o Pascal Casing (Saca eDeposita, por exemplo).

Para argumentos de mtodos, a recomendao utilizar o Pascal Casing porm com a primeira letra emminscula (valorDoSaque, por exemplo), uma conveno chamada Camel Casing.

Voc pode encontrar as recomendaes da Microso nesse link:

http://msdn.microsoft.com/en-us/library/ms229040(v=vs.110).aspx

6.7 Exerccios

1) O que uma classe tem?

S os atributos de uma entidade do sistema;

S atributos ou s mtodos de uma entidade do sistema;

S os mtodos de uma entidade do sistema;

Atributos e mtodos de uma entidade do sistema.

2) Vamos criar a classe Conta dentro do projeto inicial utilizando o Visual Studio.

No Visual Studio clique com o boto direito no nome do projeto e selecione a opo Add > Class...

Captulo 6 - Classes e objetos - Conveno de nomes - Pgina 39


Dentro da janela aberta pelo Visual Studio, precisamos denir qual o nome da classe que queremoscriar. Escolha o nome Conta:

Depois de colocar o nome da classe, clique no boto Add. Com isso, o Visual Studio criar um novoarquivo dentro do Projeto, o Conta.cs. Todo o cdigo da classe Conta car dentro desse arquivo:

class Conta{

// O cdigo da classe fica aqui dentro!}

Agora declare os seguintes atributos dentro da Conta: saldo (double), titular (string) e numero (int).

3) Qual dos comandos a seguir instancia uma nova Conta?

Conta conta = Conta();

Captulo 6 - Classes e objetos - Exerccios - Pgina 40


Conta conta = new Conta();

Conta conta = Conta.new();

4) Levando em considerao o cdigo:

Conta c = new Conta();c.saldo = 1000.0;

Qual das linhas a seguir adiciona 200 reais nesse saldo?

saldo += 200;

c.saldo += 200;

Conta c.saldo += 200;

Conta.saldo += 200;

5) Agora vamos testar a classe Conta que acabamos de criar. Coloque um novo boto no formulrio daaplicao. D um duplo clique nesse boto para denirmos qual ser o cdigo executado no clique doboto.


// ao do boto aqui.}

Dentro do cdigo desse boto, instancie uma nova Conta e tente fazer alguns testes preenchendo e mos-trando seus atributos atravs do MessageBox.Show. Por exemplo:


Conta contaVictor = new Conta();contaVictor.titular = "victor";contaVictor.numero = 1;contaVictor.saldo = 100.0;

MessageBox.Show(contaVictor.titular);}

Tente fazer testes com diversas contas e veja que cada instncia de conta possui seus prprios atributos.

6) Agora vamos implementar mtodos na classe Conta. Comearemos pelo mtodo Deposita, esse mtodono devolve nada e deve receber um argumento do tipo double que o valor que ser depositado naConta. A sua classe deve car parecida com a que segue:

// dentro do arquivo Conta.cs

class Conta



{// declarao dos atributos

public void Deposita(double valor){

// o que colocar aqui na implementao?}

}

Depois de implementar o mtodo Deposita, implemente tambm o mtodo Saca. Ele tambm no de-volve valor algum e recebe um double que o valor que ser sacado da conta.

7) Agora vamos testar os mtodos que acabamos de criar. Na ao do boto que utilizamos para testar aconta, vamos manipular o saldo utilizando os mtodos Deposita e Saca:


Conta contaVictor = new Conta();contaVictor.titular = "victor";contaVictor.numero = 1;contaVictor.Deposita(100);MessageBox.Show("Saldo: " + contaVictor.saldo);contaVictor.Saca(50.0);MessageBox.Show("Saldo: " + contaVictor.saldo);

}

Tente fazer depsitos e saques em vrias instncias diferentes de Conta, repare que dentro dos mtodos avarivel this possui o valor da referncia em que o mtodo foi invocado.

8) Qual a sada do cdigo a seguir:

Conta mauricio = new Conta();mauricio.saldo = 2000.0;

Conta guilherme = new Conta();guilherme.saldo = 5000.0;

mauricio.saldo -= 200.0;guilherme.saldo += 200.0;

MessageBox.Show("mauricio = " + mauricio.saldo);MessageBox.Show("guilherme = " + guilherme.saldo);

mauricio = 2200.0 e guilherme = 4800.0






9) Qual a sada do cdigo a seguir?

Conta mauricio = new Conta();mauricio.numero = 1;mauricio.titular = "Mauricio";mauricio.saldo = 100.0;

Conta mauricio2 = new Conta();mauricio2.numero = 1;mauricio2.titular = "Mauricio";mauricio2.saldo = 100.0;

if (mauricio == mauricio2){

MessageBox.Show("As contas so iguais");}else{

MessageBox.Show("As contas so diferentes");}

As contas so iguais

As contas so diferentes

No mostrado nenhuma mensagem

10) Qual a sada do cdigo a seguir:

Conta mauricio = new Conta();mauricio.saldo = 2000.0;

Conta copia = mauricio;copia.saldo = 3000.0;

MessageBox.show("mauricio = " + mauricio.saldo);MessageBox.show("copia = " + copia.saldo);

mauricio = 2000.0 e copia = 3000.0




11) (Opcional) Implemente o mtodo Transfere que recebe o valor da transferncia e a conta de destino.Faa com que ele reutilize as implementaes dos mtodos Saca e Deposita.



12) (Opcional)Vamos adicionar uma validao nomtodo Saca da Conta. Modique omtodo Saca para queele no realize o saque caso o saldo atual da conta seja menor do que o valor recebido como argumento.

13) (Opcional) Modique omtodo Saca com validao para que ele devolva o valor true caso o saque tenhasido realizado com sucesso e false caso contrrio. Depois modique o cdigo do boto de teste da contapara que ele utilize o valor devolvido pelo mtodo Saca para mostrar uma mensagem para o usurio.Caso o saque seja bem sucedido, queremos mostrar a mensagem Saque realizado com sucesso, se no,mostraremos Saldo insuciente

14) (Opcional) Agora altere o mtodo Saca da classe Conta. Limite o valor do saque para R$ 200,00 caso ocliente seja menor de idade.

Lembre-se que ainda necessrio validar se o valor a ser sacado menor ou igual ao saldo atual do clientee maior do que R$ 0,00.

6.8 Composio de classes

Quando abrimos uma conta no banco, temos que fornecer uma srie de informaes: nome, CPF, RG eendereo.

Vimos que quando queremos armazenar informaes em uma classe, devemos criar atributos. Mas em qualclasse colocar esses novos atributos? Claramente essas informaes no pertencem a uma Conta. Esses dadospertencem ao titular da conta, ou seja, essas informaes pertencem ao cliente do banco.

Ento devemos armazen-las em uma classe Cliente.

class Cliente{

public string nome;public string cpf;public string rg;public string endereco;

}

Sabemos tambmque toda conta est associada a um cliente, ou seja, a conta guarda uma referncia ao clienteassociado.

class Conta{

// outros atributos da Conta

public Cliente titular;

// comportamentos da conta}

Captulo 6 - Classes e objetos - Composio de classes - Pgina 44


Agora, quando vamos criar uma conta, podemos tambm colocar seu titular.

Cliente victor = new Cliente();victor.nome = "victor";

Conta umaConta = new Conta();umaConta.titular = victor;

Vimos tambm que o atributo titular guarda uma referncia(seta) para uma instncia de Cliente (objetona memria). Logo, a atribuio umaConta.titular = victor est copiando a referncia da varivel victorpara o atributo titular.

Podemos modicar os atributos do Cliente atravs da referncia guardada no atributo titular da Conta.

Cliente victor = new Cliente();victor.nome = "victor";

Conta umaConta = new Conta();umaConta.titular = victor;

umaConta.titular.rg = "12345678-9";

// Mostra o nome victorMessageBox.Show(umaConta.titular.nome);

// Mostra o texto 12345678-9MessageBox.Show(victor.rg);

6.9 Exerccios

1) Crie a classe Cliente contendo os atributos nome (string), rg (string), cpf (string) e endereco (string).Modique a classe Conta e faa com que seu atributo titular seja do tipo Cliente ao invs de string.

Tome cuidado. Aps essa modicao no poderemos atribuir o nome do cliente diretamente ao atributotitular da Conta. Para denir o nome do titular, precisaremos de um cdigo parecido com o que segue:

Conta conta = new Conta();Cliente cliente = new Cliente();conta.titular = cliente;conta.titular.nome = "Victor";

2) Qual a sada que ser impressa ao executar o seguinte trecho de cdigo?

Conta umaConta = new Conta();Cliente guilherme = new Cliente();



guilherme.nome = "Guilherme Silveira";umaConta.titular = guilherme;

MessageBox.Show(umaConta.titular.nome);

Guilherme Silveira

Ser mostrado uma caixa de mensagem sem nenhuma mensagem

O cdigo no compila

3) Qual a sada que ser impressa ao executar o seguinte trecho de cdigo?

Conta umaConta = new Conta();Cliente guilherme = new Cliente();guilherme.rg = "12345678-9";

umaConta.titular = guilherme;umaConta.titular.rg = "98765432-1";

MessageBox.Show(guilherme.rg);

98765432-1

12345678-9

rg

No ser impresso nada

4) (Opcional) Crie mais um atributo na classe Cliente que guarda a idade da pessoa. No nosso caso, a idade um nmero inteiro.

Tambm crie um comportamento (mtodo) com o nome EhMaiorDeIdade na classe Cliente que norecebe nenhumargumento e retorna umbooleano indicando se o cliente maior de idade ouno. Quandouma pessoa maior de idade no Brasil?


Captulo 7

Encapsulamento e Modicadores de Acesso

Nesse momento, nossa classe Conta possui um numero, saldo e cliente titular, alm de comportamentosque permitem sacar e depositar:

class Conta{

public int numero;public double saldo;

public Cliente titular;

public void Saca(double valor) {this.saldo -= valor;

}

public void Deposita(double valor) {this.saldo += valor;

}}

Se desejamos efetuar um saque ou um depsito em uma Conta qualquer, fazemos:

conta.Saca(100.0);conta.Deposita(250.0);

Mas o que acontece se um membro da equipe faz:

conta.saldo -= 100.0;


Nada nos impede de acessar os atributos diretamente. Em trs partes distintas do nosso soware temos talcdigo:

// em um arquivoconta.saldo -= 100.0;

// em outro arquivoconta.saldo -= 250.0;

// em outro arquivoconta.saldo -= 371.0;

Agora imagine que o bancomude a regra de saque: agora a cada saque realizado, o banco cobrar 0.10 centa-vos. Ou seja, se o usurio sacar 10.0 reais, necessrio tirar de sua conta 10.10 reais. Temos que alterar todosos pontos de nossa aplicao que acessam esse atributo! Mas nossa base de cdigo pode ser muito grande e muito comum esquecermos onde e quem est acessando esse atributo, deixando bugs toda vez que esque-cemos de alterar algum lugar. Se tivermos essa linha espalhada 300 vezes em nosso sistema, precisaremosencontrar todas essas 300 linhas e fazer a alterao. Muito complicado e custoso!

O que aconteceria ao usarmos o mtodo Saca():

// em um arquivoconta.Saca(100.0);

// em outro arquivoconta.Saca(250.0);

// em outro arquivoconta.Saca(371.0);

Como reetiramos a alterao na regra do saque de tirar 10 centavos? Precisamos alterar apenas uma vez omtodo Saca(), ao invs de alterar todas as linhas que acessam o atributo diretamente!

7.1 Encapsulamento

Quando liberamos o acesso aos atributos da classe Conta, estamos permitindo que qualquer programadorfaa a sua prpria implementao no segura da lgica de saque da forma que quiser. Se a modicao doatributo casse restrita classe que o declara, todos que quisessem sacar ou depositar dinheiro na conta te-riam de faz-lo atravs demtodos da classe. Nesse caso, se a regra de saquemudar no futuro, modicaremosapenas o mtodo Saca.

Na orientao a objetos, esconder os detalhes de implementao de uma classe um conceito conhecidocomo encapsulamento. Como os detalhes de implementao da classe esto escondidos, todo o acesso deve

Captulo 7 - Encapsulamento e Modicadores de Acesso - Encapsulamento - Pgina 48


ser feito atravs de seus mtodos pblicos. No permitimos aos outros saber COMO a classe faz o trabalhodela, mostrando apenasOQU ela faz.

Veja a linha conta.Saca(100.0);. Sabemos o qu esse mtodo faz pelo seu nome. Mas como ele faz otrabalho dele s saberemos se entrarmos dentro de sua implementao. Portanto, o comportamento estencapsulado nesse mtodo.

Mas ainda no resolvemos o problema de evitar que programadores faam uso diretamente do atributo.Qualquer um ainda pode executar o cdigo abaixo:

conta.saldo -= 371.0;

Para isso, precisamos esconder o atributo. Queremos deix-lo privado para que somente a prpria classeConta possa utiliz-lo. Nesse caso queremosmodicar o acesso ao atributo para que ele seja privado, private:

class Conta{

// outros atributos aquiprivate double saldo;


}


}}

Atributos e mtodos private so acessados apenas pela prpria classe. Ou seja, o mtodo Saca(), por exem-plo, consegue fazer alteraes nele. Mas outras classes no conseguem acess-lo diretamente! O compiladorno permite!

Os atributos de uma classe so detalhes de implementao, portantomarcaremos todos os atributos da contacom a palavra private:

class Conta{

private int numero;private double saldo;private Cliente titular;


}

Captulo 7 - Encapsulamento e Modicadores de Acesso - Encapsulamento - Pgina 49



}}

timo. Agora o programador forado a passar pelos mtodos para conseguir manipular o saldo. Se ten-tarmos, por exemplo, escrever no saldo da Conta a partir do cdigo de um formulrio, teremos um erro decompilao:

Conta c = new Conta();// A linha abaixo gera um erro de compilaoc.saldo = 100.0;

Mas agora temos outro problema. Se quisermos exibir o saldo no conseguiremos. O private bloqueia tantoa escrita, quanto a leitura!

7.2 Controlando o acesso com properties

Vimos que podemos proibir o acesso externo a um atributo utilizando o private doC#, mas o private tambmbloqueia a leitura do atributo, logo para recuperarmos seu valor, precisamos de um novo mtodo dentro daclasse que nos devolver o valor atual do atributo:

class Conta{

private double saldo;

private int numero;

// outros atributos e mtodos da conta

public double PegaSaldo(){

return this.saldo;}

}

Agora para mostrarmos o saldo para o usurio, utilizaramos o seguinte cdigo:

Conta conta = new Conta();// inicializa a conta

MessageBox.Show("saldo: " + conta.PegaSaldo());

Captulo 7 - Encapsulamento e Modicadores de Acesso - Controlando o acesso com properties - Pgina 50


Alm disso, a conta precisa de um nmero, mas como ele foi declarado como private, no podemos acess-lo diretamente. Precisaremos de um novo mtodo para fazer esse trabalho:

class Conta{

private int numero;

// outros atributos e mtodos da conta

public void ColocaNumero(int numero){

this.numero = numero;}

}

Para colocarmos o nmero na conta, teramos que executar esse cdigo:

Conta conta = new Conta();

conta.ColocaNumero(1100);

//utiliza a conta no cdigo

Veja que com isso ns conseguimos controlar todo o acesso a classe Conta, mas para escrevermos ou lermoso valor de um atributo precisamos utilizar os mtodos. O ideal seria utilizarmos uma sintaxe parecida coma de acesso a atributos, porm com o controle que o mtodo nos oferece. Para resolver esse problema, o C#nos oferece as properties (propriedades).

A declarao de uma propriedade parecida com a declarao de um atributo, porm precisamos falar o quedeve ser feito na leitura (get) e na escrita (set) da propriedade

class Conta{

private int numero;

public int Numero{

get{

// cdigo para ler a propriedade}

set{



// cdigo para escrever na propriedade}

}}

Na leitura da propriedade, queremos devolver o valor do atributo numero da Conta:

class Conta{

private int numero;

public int Numero{

get{

return this.numero;}

}}

Com isso, podemos ler a propriedade Numero com o seguinte cdigo:

Conta c = new Conta();MessageBox.Show("numero: " + c.Numero);

Veja que o acesso cou igual ao acesso de atributos, porm quando tentamos ler o valor de uma propriedadeestamos na verdade executando um bloco de cdigo (get da propriedade) da classe Conta. Para denirmoso nmero da conta, utilizaremos o cdigo:

Conta c = new Conta();c.Numero = 1;

Quando tentamos escrever em uma propriedade, o C# utiliza o bloco set para guardar seu valor. Dentrodo bloco set, o valor que foi atribudo propriedade ca dentro de uma varivel chamada value, entopodemos implementar o set da seguinte forma:

class Conta{

private int numero;

public int Numero{

// declarao do get



set{

this.numero = value;}

}}

Podemos tambm declarar uma propriedade que tem apenas o get, sem o set. Nesse caso, estamos decla-rando umapropriedade que pode ser lidamas no pode ser escrita. Comas properties conseguimos controlarcompletamente o acesso aos atributos da classe utilizando a sintaxe de acesso aos atributos.

7.3 Simplificando a declarao de propriedades com Auto-Implemented Properties

Utilizando as properties, conseguimos controlar o acesso s informaes da classe, porm, como vimos,declarar uma property bem trabalhoso. Precisamos de um atributo para guardar seu valor, alm disso,precisamos declarar o get e o set.

Para facilitar a declarao das properties, a partir do C# 3.0, temos as propriedades que so implemen-tadas automaticamente pelo compilador, as auto-implemented properties. Para declararmos uma auto-implemented property para expor o nmero da conta, utilizamos o seguinte cdigo:

class Conta{

public int Numero { get; set; }}

Esse cdigo faz com que o compilador declare um atributo do tipo int (cujo nome s conhecido pelocompilador) e gere o cdigo para a propriedade Numero com um get e um set que leem e escrevem noatributo declarado. Repare que ao utilizarmos as auto-implemented properties, s podemos acessar o valordo atributo declarado atravs da propriedade.

Toda vez que declaramos um auto-implemented property, precisamos sempre declarar um get e um setpara a propriedade, porm podemos controlar a visibilidade tanto do get quanto do set. Por exemplo, nocaso do saldo, queremos permitir que qualquer um leia o saldo da conta, porm apenas a prpria conta podealter-lo. Nesse caso, utilizamos o seguinte cdigo:

class Conta{

// outras propriedades

// get pblico e pode ser acessado por qualquer classe

Captulo 7 - Encapsulamento e Modicadores de Acesso - Simplicando a declarao de propriedades com Auto-ImplementedProperties - Pgina 53


// set privado e por isso s pode ser usado pela conta.public double Saldo { get; private set; }

// resto do cdigo da classe.}

Agora vamos ver um cdigo que tenta ler e escrever nas propriedades que declaramos:

Conta c = new Conta();

c.Numero = 1; // funciona pois o set do Numero pblicoMessageBox.Show("numero: " + c.Numero); // funciona pois o get do Numero pblico

c.Saldo = 100.0; // set do Saldo privado, ento temos um erroMessageBox.Show("saldo " + c.Saldo); // funciona pois o get do Saldo pblico.

Veja que tanto declarando properties explicitamente quanto utilizando as auto-implemented properties, te-mos o controle total sobre quais informaes sero expostas pela classe.

Ento devemos utilizar properties toda vez que queremos expor alguma informao da classe. Nunca deve-mos expor atributos da classe (utilizando o public), pois nunca queremos expor os detalhes de implemen-tao da classe.

7.4 Conveno de nome para property

A conveno de nomes denida para properties do C# amesma conveno de nomes utilizada para classes,ou seja, utilizando o Pascal Casing (Todas as palavras do nome so concatenadas e cada palavra tem a inicialmaiscula, por exemplo: numero do banco => NumeroDoBanco)

7.5 Exerccios

1) Qual o comportamento do atributo abaixo:

public int Numero { get; private set; }

O nmero pode ser lido, mas no pode ser alterado por outras classes.

O nmero no pode ser lido, mas pode ser alterado por outras classes.

O nmero no pode nem ser lido nem ser alterado por outras classes.

O nmero pode ser lido e alterado por outras classes.

2) Sobre o cdigo abaixo vlido armar que...

Captulo 7 - Encapsulamento e Modicadores de Acesso - Conveno de nome para property - Pgina 54


Conta c = new Conta();double valorADepositar = 200.0;c.Saldo += valorADepositar;

A operao de depsito foi implementada corretamente.

A operao de depsito no est encapsulada, podendo gerar problemas futuros de manuteno.

A operao de depsito no est encapsulada, facilitando a manuteno futura do cdigo.

3) O que encapsulamento?

deixar bem claro para todos COMO a classe faz o trabalho dela.

a utilizao de Properties em qualquer uma de suas variaes.

manipular e alterar atributos diretamente, sem passar por um mtodo especco.

esconder COMO a classe/mtodo faz sua tarefa. Caso a regra mude, temos que alterar apenas umponto do cdigo.

4) Qual o problema do atributo abaixo:

public double Sa

Apostila C#

Documents

Transcript of Apostila C#