Apostila Caelum C# DotNet fn13, Manual de Introdução à Programação de Computadores. Faculdade de Tecnologia do Estado de São Paulo (FATEC)
fabipec
fabipec1 de setembro de 2015

Apostila Caelum C# DotNet fn13, Manual de Introdução à Programação de Computadores. Faculdade de Tecnologia do Estado de São Paulo (FATEC)

PDF (2 MB)
207 páginas
7Números de download
1000+Número de visitas
1Número de comentários
Descrição
Apostila Caelum de C#
20 pontos
Pontos de download necessários para baixar
este documento
baixar o documento
Pré-visualização3 páginas / 207

Esta é apenas uma pré-visualização

3 shown on 207 pages

baixar o documento

Esta é apenas uma pré-visualização

3 shown on 207 pages

baixar o documento

Esta é apenas uma pré-visualização

3 shown on 207 pages

baixar o documento

Esta é apenas uma pré-visualização

3 shown on 207 pages

baixar o documento

Conheça mais da Caelum.

Cursos Online www.caelum.com.br/online

Blog Caelum blog.caelum.com.br

Newsletter www.caelum.com.br/newsletter

Facebook www.facebook.com/caelumbr

Twitter twitter.com/caelum

Casa do Código Livros para o programador

www.casadocodigo.com.br

Sobre esta apostila Esta apostila daCaelumvisa ensinar de umamaneira elegante, mostrando apenas o que é necessário e quando é necessário, no momento certo, poupando o leitor de assuntos que não costumam ser de seu interesse em determinadas fases do aprendizado.

A Caelum espera que você aproveite esse material. Todos os comentários, críticas e sugestões serão muito bem-vindos.

Essa apostila é constantemente atualizada e disponibilizada no site da Caelum. Sempre consulte o site para novas versões e, ao invés de anexar o PDF para enviar a um amigo, indique o site para que ele possa sempre baixar as últimas versões. Você pode conferir o código de versão da apostila logo no nal do índice.

Baixe sempre a versão mais nova em: www.caelum.com.br/apostilas

Esse material é parte integrante do treinamento C e Orientação a Objetos e distribuído gratuitamente exclu- sivamente pelo site da Caelum. Todos os direitos são reservados à Caelum. A distribuição, cópia, revenda e utilização para ministrar treinamentos são absolutamente vedadas. Para uso comercial deste material, por favor, consulte a Caelum previamente.

www.caelum.com.br

1

Sumário

1 Como aprender C# 1 1.1 O que é realmente importante? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Sobre os exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.3 Tirando dúvidas e indo além . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 O que é C# e .Net 4 2.1 Um pouco sobre a história do C# e .Net . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Máquina virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.3 Execução do código na CLR e o JIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.4 O ambiente de desenvolvimento do C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.5 Executando aplicações sem o Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.6 O primeiro programa em C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.8 O que aconteceu durante a execução? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3 Variáveis e tipos primitivos 14 3.1 Operações com variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.2 Tipos Primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.3 Armazenando texto em variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 3.4 Documentando o código através de comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 3.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Estruturas de controle 20 4.1 Tomando decisões no código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.2 Mais sobre condições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 4.3 Exercícios opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5 Estruturas de repetição 25 5.1 Repetindo um bloco de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 5.2 Para saber mais do while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 5.3 Para saber mais incremento e decremento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 5.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6 Classes e objetos 29 6.1 Organizando o código com Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.2 Extraindo comportamentos através de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.3 Devolvendo valores de dentro do método . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 6.4 Valor padrão dos atributos da classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.5 Mais um exemplo: Transfere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.6 Convenção de nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

i

6.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.8 Composição de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 6.9 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

7 Encapsulamento e Modicadores de Acesso 47 7.1 Encapsulamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 7.2 Controlando o acesso com properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 7.3 Simplicando a declaração de propriedades com Auto-Implemented Properties . . . . . . . . 53 7.4 Convenção de nome para property . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.6 Para saber mais: Visibilidade Internal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

8 Construtores 57 8.1 Múltiplos construtores dentro da classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 8.2 Para saber mais — Initializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 8.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

9 Introdução ao Visual Studio comWindows Form 62 9.1 Introdução prática aos atalhos do Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 9.2 A classe Convert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 9.3 Operações na conta: saque e depósito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 9.4 Controlando o nome da ação de um botão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 9.5 Renomeando Variáveis, Métodos e Classes com o Visual Studio . . . . . . . . . . . . . . . . . . 72 9.6 Para saber mais — organizando o formulário com Label e GroupBox . . . . . . . . . . . . . . . 73 9.7 Resumo dos atalhos do Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 9.8 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 9.9 Para saber mais — tipos implícitos e a palavra VAR . . . . . . . . . . . . . . . . . . . . . . . . . 75 9.10 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

10 Herança 79 10.1 Reaproveitando código com a Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.2 Reaproveitando a implementação da classe base . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 10.3 Polimorsmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 10.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 10.5 Para saber mais — o que é herdado? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

11 Trabalhando com arrays 91 11.1 Para saber mais — inicialização de Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.2 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.3 Organizando as contas com o ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

12 Cadastro de novas contas 100 12.1 Utilizando o AdicionaConta no load do formulário . . . . . . . . . . . . . . . . . . . . . . . . . 104

ii

12.2 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

13 Classes abstratas 110 13.1 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

14 Interfaces 114 14.1 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

15 Métodos e atributos estáticos 122 15.1 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 15.2 Para saber mais classes estáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

16 Exceções 127 16.1 Retorno do método para controlar erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 16.2 Controlando erros com exceções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 16.3 Tratando múltiplas exceções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 16.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

17 Namespaces 136 17.1 Para saber mais - Declaração de namespace aninhados . . . . . . . . . . . . . . . . . . . . . . . 139 17.2 Para saber mais - Alias para namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 17.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

18 Classe Object 144 18.1 Implementando a comparação de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 18.2 Melhorando a implementação do Equals com o is . . . . . . . . . . . . . . . . . . . . . . . . . . 147 18.3 Integrando o Object com o ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 18.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

19 Trabalhando com listas 153 19.1 Facilitando o trabalho com coleções através das listas . . . . . . . . . . . . . . . . . . . . . . . . 153 19.2 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

20 Lidando com conjuntos 157 20.1 Otimizando a busca através de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 20.2 Conjuntos Ordenados com o SortedSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 20.3 A interface de todos os conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 20.4 Comparação entre listas e conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 20.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 20.6 Buscas rápidas utilizando Dicionários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 20.7 Iterando no dicionário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 20.8 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

21 LINQ e Lambda 170

iii

21.1 Filtros utilizando o LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 21.2 Simplicando a declaração do lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 21.3 Outros métodos do LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 21.4 Utilizando o LINQ com outros tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 21.5 Melhorando as buscas utilizando a sintaxe de queries . . . . . . . . . . . . . . . . . . . . . . . . 173 21.6 Para saber mais — projeções e objetos anônimos . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 21.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 21.8 Ordenando coleções com LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 21.9 Exercícios - Ordenação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

22 System.IO 180 22.1 Leitura de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 22.2 Escrevendo em arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 22.3 Gerenciando os arquivos com o using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 22.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 22.5 Para saber mais — onde colocar os arquivos da aplicação . . . . . . . . . . . . . . . . . . . . . . 188

23 Manipulação de strings 190 23.1 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

24 Apêndice — estendendo comportamentos através de métodos extras 195 24.1 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

Índice Remissivo 200 Versão: 17.0.6

iv

Capítulo 1

Como aprender C#

1.1 O que é realmente importante?

Muitos livros, ao passar dos capítulos, mencionam todos os detalhes da linguagem, juntamente com seus princípios básicos. Isso acaba criando muita confusão, em especial porque o estudante não consegue dife- renciar exatamente o que é essencial aprender no início, daquilo que pode ser deixado para estudar mais tarde.

Se uma classe abstrata deve ou não ter ao menos um método abstrato, se o if somente aceita argumentos booleanos e todos os detalhes sobre classes internas, realmente não devem ser preocupações para aquele cujo objetivo primário é aprender C#. Esse tipo de informação será adquirida com o tempo e não é necessária no início.

Neste curso, separamos essas informações em quadros especiais, já que são informações extra. Ou então, apenas citamos em algum exercício e deixamos para o leitor procurar informações adicionais, se for de seu interesse.

Por m, falta mencionar algo sobre a prática, que deve ser tratada seriamente: todos os exercícios são muito importantes e os desaos podem ser feitos após o término do curso. De qualquer maneira, recomendamos aos alunos estudarem em casa e praticarem bastante código e variações.

1.2 Sobre os exercícios

Os exercícios do curso variam, de práticos até pesquisas na internet, ou mesmo consultas sobre assuntos avançados em determinados tópicos, para incitar a curiosidade do aprendiz na tecnologia.

Existe também, em determinados capítulos, uma série de desaos. Eles focammais no problema computaci- onal que na linguagem, porém são uma excelente forma de treinar a sintaxe e, principalmente, familiarizar o

Material do Treinamento C e Orientação a Objetos

aluno com as bibliotecas padrão do C#, além de proporcionar um ganho na velocidade de desenvolvimento.

1.3 Tirando dúvidas e indo além

Para tirar dúvidas de exercícios, ou de C# em geral, recomendamos o fórum do GUJ Respostas:

http://www.guj.com.br

Lá sua dúvida será respondida prontamente. OGUJ foi fundado por desenvolvedores da Caelum e hoje conta com mais de um milhão de mensagens.

O principal recurso ocial para encontrar documentação, tutoriais e até mesmo livros sobre .NET e C# é a MicrosoŸ Developers Network, ou MSDN:

http://msdn.microsoŸ.com

Destacamos a seção de tutoriais de C# (em inglês), no endereço:

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

Há também fóruns ociais em português 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 dúvidas que surgirem durante o curso.

Se o que você está buscando são livros de apoio, sugerimos conhecer a editora Casa do Código:

http://www.CasaDoCodigo.com.br

Em língua portuguesa, há alguns livros sobre o assunto:

Andrew Stellman. Use a Cabeça! C#. 2ª Edição. Alta Books.

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

Harvey Deitel, Paul Deitel. C# Como Programar. 1ª Edição. Pearson.

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

Em língua inglesa, há uma edição 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 aplicação do C# naWeb:

http://www.caelum.com.br

Capítulo 1 - Como aprender C# - Tirando dúvidas e indo além - Página 2

Material do Treinamento C e Orientação a Objetos

Há também cursos online que vão ajudá-lo a ir além, com muita interação com os instrutores:

http://www.Alura.com.br

Capítulo 1 - Como aprender C# - Tirando dúvidas e indo além - Página 3

Capítulo 2

O que é C# e .Net

2.1 Um pouco sobre a história do C# e .Net

Entender umpouco da história doC# e do .Net é essencial para enxergar osmotivos que a levaram ao sucesso.

No nal da década de 1990 aMicrosoŸ tinha diversas tecnologias e linguagens de programação para resolver muitos problemas diferentes. Toda vez que um programador precisava migrar para uma nova linguagem, era necessário aprender tanto a nova linguagem quanto suas bibliotecas e conceitos. Para solucionar esses problemas, a MicrosoŸ recorreu à linguagem Java.

O Java agradou os engenheiros daMicrosoŸ pois com ela podíamos construir programas que eram indepen- dentes do ambiente de execução, além de possuir diversas bibliotecas com soluções prontas para diversos problemas. Para lançar produtos baseados no Java, a MicrosoŸ assinou um acordo de licenciamento com a Sun para utilizar o Java em ambiente Windows.

Porém, a linguagem Java possuía um grave problema: ela não se comunicava bem com o as bibliotecas de código nativo (código de máquina) que já existiam. Para resolver isso, a MicrosoŸ decidiu criar a sua pró- pria implementação do Java chamado J++ que possuía extensões proprietárias que resolviam o problema de comunicação com o código nativo existente. Para o desenvolvimento dessa nova implementação do Java, a MicrosoŸ contratou um engenheiro chamado Anders Hejlsberg, um dos principais nomes por trás do Delphi.

O J++ era uma versão da linguagem Java que só podia ser executada no ambiente MicrosoŸ. Seu código não podia ser executado em mais nenhum ambiente Java, o que violava o licenciamento feito com a Sun e, por isso, a MicrosoŸ foi processada. Uma das mais conhecidas batalhas judiciais da época.

Sem o J++, a MicrosoŸ foi obrigada a repensar sua estratégia sobre como lidar com as diferentes linguagens e tecnologias utilizadas internamente. A empresa começou a trabalhar em um nova plataforma que seria a

Material do Treinamento C e Orientação a Objetos

base de todas as suas soluções, que posteriormente foi chamada de .Net. Esse novo ambiente de desenvol- vimento da MicrosoŸ foi desde o início projetado para trabalhar com diversas linguagens de programação, assim diversas linguagens diferentes compartilhariam o mesmo conjunto de bibliotecas. Com isso, para um programador migrar de uma linguagem para outra ele precisaria apenas aprender a linguagem sem se preo- cupar com as bibliotecas e APIs.

Além de uma plataforma a MicrosoŸ também precisava de uma linguagem de programação. Um novo pro- jeto de linguagem de programação foi iniciado, o projeto COOL (C-like Object Oriented Language). Anders Hejlsberg 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 os problemas existentes e incorporar soluções.

Em 2002, o projeto COOL foi lançado como linguagem C# 1.0 junto com o ambiente .Net 1.0. Atualmente a linguagem C# está em sua versão 5.0 e o .Net na versão 4.5.1, tendo evoluído com expressiva velocidade, adotando novidades na sua sintaxe que a diferenciaram bastante do Java e outras concorrentes.

2.2 Máquina virtual

Em uma linguagem de programação como C e Pascal, temos a seguinte situação quando vamos compilar um programa:

O código fonte é compilado para código de máquina especíco de uma plataforma e sistema operacional. Muitas vezes o próprio código fonte é desenvolvido visando uma única plataforma!

Esse código executável (binário) resultante será executado pelo sistema operacional e, por esse motivo, ele deve saber conversar com o sistema operacional em questão. Isto é, temos um código executável diferente para cada sistema operacional diferente.

Precisamos reescrever ummesmo pedaço da aplicação para diferentes sistemas operacionais, já que eles não são compatíveis.

O C# utiliza o conceito de máquina virtual. Entre o sistema operacional e a aplicação existe uma camada extra responsável por “traduzir”—mas não apenas isso—o que sua aplicação deseja fazer para as respectivas chamadas do sistema operacional onde ela está rodando no momento.

Repare que umamáquina virtual é um conceito bemmais amplo que o de um interpretador. Como o próprio nome diz, uma máquina virtual é como um “computador de mentira": tem tudo que um computador tem. Em outras palavras, ela é responsável por gerenciar memória, threads, a pilha de execução etc.

Sua aplicação roda sem nenhum envolvimento com o sistema operacional! Sempre conversando apenas com a máquina virtual do C#, a Common Language Runtime (CLR). A CLR é o ambiente de execução para todas as linguagens da plataforma .Net, não apenas para o C#. Certamente isso não foi uma revolução. O Java trouxe esse conceito para o mercado e já havia muitas linguagens com esses recursos, apesar de que eram encontradas mais no meio acadêmico.

Capítulo 2 - O que é C# e .Net - Máquina virtual - Página 5

Material do Treinamento C e Orientação a Objetos

O CLR isola totalmente a aplicação do sistema operacional. Se uma aplicação rodando no CLR termina abruptamente, ela não afetará as outras máquinas virtuais e nem o sistema operacional. Essa camada de isolamento também é interessante quando pensamos em um servidor que não pode se sujeitar a rodar código que possa interferir na boa execução de outras aplicações.

Como amáquina virtual deve trabalhar com diversas linguagens de programação diferentes, a CLR não pode executar diretamente o código do C#, ela precisa executar uma linguagem intermediária comum a todas as linguagens da plataforma .Net, aCIL (Common Intermediate Language). Para gerar o CIL que será executado pela CLR, precisamos passar o código C# por um compilador da linguagem, como o programa csc.exe. O compilador lê o arquivo com o código fonte do programa e o traduz para o código intermediário que será executado pela máquina virtual.

Common Language Infrastructure

A infraestrutura necessária para executar os códigos escritos para a plataforma .Net é chamada de CLI (Common Language Infrastructure). A CLI engloba a máquina virtual do C# (CLR), a linguagem intermediária (CIL) e os tipos base utilizados nos programas.

2.3 Execução do código na CLR e o JIT

Para executarmos uma aplicação C#, precisamos passar o código CIL do programa para a CLR, a máquina virtual do .Net. A CLR por sua vez precisa executar o código da aplicação no sistema operacional do usuário e, para isso, precisa emitir o código de máquina correto para o ambiente em que o programa está sendo executado. Mas a CLR não interpreta o CIL do programa, isso seria muito lento, ao invés disso, quando o programa C# é carregado na memória, a CLR converte automaticamente o código CIL para código de máquina, esse processo é feito por um compilador Just in Time (JIT) da CLR.

Esse carregamento utilizando o JIT faz comque o código escrito na linguagemC# execute comodesempenho máximo, o mesmo de um programa escrito em linguagens que compilam diretamente para o código de máquina, mas com a vantagem de executar no ambiente integrado do .Net.

2.4 O ambiente de desenvolvimento do C#

Nesse curso escreveremos todo o código utilizando o Visual Studio Express Edition, a versão gratuita da ferramenta de desenvolvimento de aplicações distribuída pela própria MicrosoŸ. Apesar das explicações serem feitas com base na versão express, tudo funcionará da mesma forma dentro das versões pagas da ferramenta.

O Visual Studio Express Edition pode ser encontrado no site:

http://bit.ly/1fb6Ay8

Capítulo 2 - O que é C# e .Net - Execução do código na CLR e o JIT - Página 6

Material do Treinamento C e Orientação a Objetos

A versão que utilizaremos na apostila é a Visual Studio 2013 for Windows Desktop.

Durante a instalação do Visual Studio, o .Net Framework também será automaticamente instalado em sua máquina, então ela estará pronta executar as aplicações escritas em C#.

2.5 Executando aplicações sem o Visual Studio

Como vimos anteriormente, para executarmos uma aplicação C# precisamos da máquina virtual da lin- guagem além das bibliotecas do .Net Framework. Ao instalarmos o Visual Studio, todo esse ambiente de execução de programas é automaticamente instalado em nossas máquinas, mas e se quisermos executar o programa em um computador que não tenha o Visual Studio instalado, o computador de um cliente, por exemplo?

Nesse caso precisamos instalar apenas o ambiente de execução no computador do cliente. Para isso podemos utilizar um pacote de instalação fornecido pela própria MicrosoŸ, esses são os .Net Framework Redistribu- table. O pacote de instalação para a última versão do .Net Framework (4.5.1 lançada em 2013) pode ser encontrada no seguinte site:

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

C# em outros ambientes

Podemos também executar o código C# dentro de ambientes não windows utilizando imple- mentações livres do Common Language Infrastructure. Uma implementação do ambiente de execução para ambientes não 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 começar a desenvolver a primeira apli- cação utilizando o Visual Studio. Para criarmos um programa C# utilizando o Visual Studio precisamos inicialmente de um novo projeto.

Dentro do Visual Studio 2013, aperte o atalho Ctrl + Shift + N para abrir o assistente de criação de novo projeto.

Capítulo 2 - O que é C# e .Net - Executando aplicações sem o Visual Studio - Página 7

Material do Treinamento C e Orientação a Objetos

No canto esquerdo da janela do assistente de criação de novo projeto, podemos escolher a linguagem de programação que desejamos utilizar, escolha a opção Visual C#. Como tipo de projeto escolha a opção Windows Form Application, com isso estamos criando um novo projeto de interface gráca utilizando o C#.

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

Capítulo 2 - O que é C# e .Net - O primeiro programa em C# - Página 8

Material do Treinamento C e Orientação a Objetos

Queremos inicialmente colocar umbotão no formulário que, quando clicado, abrirá uma caixa demensagem doWindows.

Para colocarmos o botão no formulário, precisamos abrir uma nova janela do Visual Studio chamada Tool- box, que ca no canto esquerdo da janela do formulário. O Toolbox também pode ser aberto utilizando-se o atalho Ctrl + W, X. Dentro da janela do Toolbox, no grupo Common Controls, clique no componente button e arraste-o para o formulário.

Agora dê um duplo clique no botão que acabamos de adicionar para programarmos o que deve acontecer quando o botão for clicado. O Visual Studio abrirá o código do formulário. Não se preocupe com todo o código complicado que está escrito nesse arquivo, entenderemos o signicado de cada uma dessas linhas mais a frente no curso.

Capítulo 2 - O que é C# e .Net - O primeiro programa em C# - Página 9

Material do Treinamento C e Orientação a Objetos

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 código que nos interessa no momento é:

private void button1_Click(object sender, EventArgs e) {

}

Todo código que for colocado dentro das chaves será executado quando o botão for clicado.

No clique do botão, queremos executar o comando que mostra uma caixa de mensagens para o usuário.

MessageBox.Show(mensagem)

No C#, todo comando deve ser terminado pelo caractere ;. Portanto, o código para mostrar a caixa de mensagem ca da seguinte forma:

MessageBox.Show(mensagem);

Queremos que, ao clicar no botão, amensagem Hello World seja exibida emuma caixa demensagens. Então, utilizaremos o seguinte código:

Capítulo 2 - O que é C# e .Net - O primeiro programa em C# - Página 10

Material do Treinamento C e Orientação a Objetos

private void button1_Click(object sender, EventArgs e) {

MessageBox.Show(Hello World); }

Como a mensagem é somente um texto, o compilador do C# nos força a colocá-la entre aspas duplas. Por- tanto, o código do clique do botão cará assim:

private void button1_Click(object sender, EventArgs e) {

MessageBox.Show("Hello World"); }

O código 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(); }

private void button1_Click(object sender, EventArgs e) {

MessageBox.Show("Hello World"); }

} }

Não se preocupe com as linhas de código que não foram explicadas. Entenderemos o que elas fazem durante o curso.

Aperte F5 para executar o código do formulário. O resultado deve ser algo parecido com a imagem a seguir:

Capítulo 2 - O que é C# e .Net - O primeiro programa em C# - Página 11

Material do Treinamento C e Orientação a Objetos

2.7 Exercícios

1) Qual a mensagem que será exibida na caixa de texto criada pelo seguinte código?

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

• Hello World

• Curso de C# da Caelum

• Olá Mundo

• Caelum

• Nenhuma das opções

2.8 O que aconteceu durante a execução?

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 aplicação, ele chama o compilador da linguagem C# passando os arquivos de texto que contém o código da aplicação (código fonte do programa). Caso o có- digo fonte não tenha nenhum erro de sintaxe, o compilador gera o código intermediário (CIL, Common Intermediate Language) que é entendido pela máquina virtual da linguagemC#, a CLR (Common Language Runtime). O código CIL é colocado em um arquivo executável (arquivo com extensão .exe) dentro da pasta do projeto. Esse arquivo que é resultado da compilação do programa é chamado de Assembly dentro da linguagem C#.

Depois da compilação, o Visual Studio executa o assembly gerado na máquina virtual do C#. A CLR por sua vez carrega o código CIL que foi gerado pelo compilador e o executa no sistema operacional, mas se a CLR

Capítulo 2 - O que é C# e .Net - Exercícios - Página 12

Material do Treinamento C e Orientação a Objetos

interpretasse o código CIL para linguagem de máquina, o desempenho do C# não seria muito bom, e por isso, quando um programa C# é carregado pela CLR ele já é automaticamente convertido para linguagem de máquina por um processo conhecido como JIT (Just-in-time). Então no C#, o código sempre é executado com o mesmo desempenho do código de máquina.

Capítulo 2 - O que é C# e .Net - O que aconteceu durante a execução? - Página 13

Capítulo 3

Variáveis e tipos primitivos

Namaioria dos programas que escrevemos, não estamos interessados em apenas mostrar uma caixa demen- sagens para o usuário. Queremos também armazenar e processar informações.

Em um sistema bancário, por exemplo, estaríamos interessados em armazenar o saldo de uma conta e o nome do correntista. Para armazenar esses dados, precisamos pedir para o C# reservar regiões de memória que serão utilizadas para armazenar informações. Essas regiões de memória são conhecidas como variáveis.

As variáveis guardam informações de um tipo especíco. Podemos, por exemplo, guardar umnúmero inteiro representando o número da conta, um texto para representar o nome do correntista ou um número real para representar o saldo atual da conta. Para utilizar uma variável, devemos primeiramente declará-la no texto do programa.

Na declaração de uma variável, devemos dizer seu tipo (inteiro, texto ou real, por exemplo) e, além disso, qual é o nome que usaremos para referenciá-la no texto do programa. Para declarar uma variável do tipo inteiro que representa o número de uma conta, utilizamos o seguinte código:

int numeroDaConta;

Repare no ; no nal da linha. Como a declaração de uma variável é um comando da linguagem C#, precisa- mos do ; para terminá-lo.

Além do tipo int (para representar inteiros), temos também os tipos double e float (para números reais), string (para textos), entre outros.

Depois de declarada, uma variável pode ser utilizada para armazenar valores. Por exemplo, se estivéssemos interessados em guardar o valor 1 na variável numeroDaConta que declaramos anteriormente, utilizaríamos o seguinte código:

numeroDaConta = 1;

Material do Treinamento C e Orientação a Objetos

Lê-se “numeroDaConta recebe 1”. Quando, no momento da declaração da variável, sabemos qual será seu valor, podemos utilizar a seguinte sintaxe para declarar e atribuir o valor para a variável.

double saldo = 100.0;

3.1 Operações com variáveis

Agora que já sabemos como guardar informações no programa, estamos interessados em executar operações nesses valores. Pode ser interessante para um correntista saber qual será o saldo de sua conta após um saque de 10 reais. Para realizar essa operação, devemos subtrair 10 reais do saldo da conta:

double saldo = 100.0; saldo = saldo - 10.0;

Nesse código, estamos guardando na variável saldo o valor da conta 100.0 (saldo antigo) menos 10.0 então seu valor nal será de 90.0. Da mesma forma que podemos subtrair valores, podemos também fazer somas (com o operador +), multiplicações (operador *) e divisões (operador /).

Podemos ainda guardar o valor do saque em uma variável:

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

Depois de realizar o saque, queremos mostrar para o usuário qual é o saldo atual da conta. Para mostrarmos essa informação, utilizaremos novamente o MessageBox.Show:

MessageBox.Show("O saldo da conta após o saque é: " + saldo);

Veja que, no código do saque, estamos repetindo o nome da variável saldo dos dois lados da atribuição. Quando temos esse tipo de código, podemos utilizar uma abreviação 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 que vimos anteriormente: saldo = saldo - valorDoSaque. Além do -=, temos também os operadores += (para somas), *= (para multiplicações) e /= (para divisões).

Capítulo 3 - Variáveis e tipos primitivos - Operações com variáveis - Página 15

Material do Treinamento C e Orientação a Objetos

3.2 Tipos Primitivos

Vimos que noC# toda variável possui um tipo, utilizamos o int quando queremos armazenar valores inteiros e double para números reais. Agora vamos descobrir quais são os outros tipos de variáveis do C#.

Os tipos listados nessa tabela são conhecidos como tipos primitivos ou value types da linguagem C#. Toda vez que atribuímos umvalor para uma variável de um tipo primitivo, o C# copia o valor atribuído para dentro da variável.

Agora que conhecemos os tipos primitivos da linguagem C#, vamos ver como é que eles interagem dentro de uma aplicação. Suponha que temos um código que declara uma variável do tipo inteiro e depois tenta copiar seu conteúdo para uma variável long:

int valor = 1; long valorGrande = valor;

Nesse caso, como o tamanho de uma variável long é maior do que o de uma variável int, o C# sabe que podemos copiar o seu conteúdo sem perder informações e, por isso, esse é um código que compila sem nenhum erro. Agora vamos tentar copiar o int para uma variável do tipo short:

int valor = 1; short valorPequeno = valor;

Capítulo 3 - Variáveis e tipos primitivos - Tipos Primitivos - Página 16

Material do Treinamento C e Orientação a Objetos

Nesse código, tentamos copiar o conteúdo de uma variável maior para dentro de uma de tamanho menor. Essa cópia pode ser perigosa pois o valor que está na variável do tipo int pode não caber na variável short e, por isso, o compilador do C# gera um erro de compilação quando tentamos fazer essa conversão.

Para forçarmos o compilador do C# a fazer uma conversão perigosa, precisamos utilizar uma operação do C# chamada casting falando para qual tipo queremos fazer a conversão.

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

3.3 Armazenando texto em variáveis

Além dos tipos primitivos, o C# também possui um tipo especíco 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 variáveis do tipo string utilizando o operador + da linguagem. A soma de strings é uma operação conhecida como concatenação.

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

MessageBox.Show(mensagem + nome);

Esse código imprime o texto Olá victor em uma caixa demensagens. Podemos utilizar a concatenação para adicionar o conteúdo de qualquer variável em uma string:

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

MessageBox.Show(mensagem);

Esse segundo código imprime o texto sua idade é: 25.

3.4 Documentando o código através de comentários

Quando queremos documentar o signicado de algum código dentro de um programa C#, podemos utilizar comentários. Para fazermos um comentário de uma linha, utilizamos o //. Tudo que estiver depois do // é considerado comentário e, por isso, ignorado pelo compilador da linguagem.

Capítulo 3 - Variáveis e tipos primitivos - Armazenando texto em variáveis - Página 17

Material do Treinamento C e Orientação a Objetos

double saldo = 100.0; // Isso é um comentário e será ignorado pelo compilador

Muitas vezes precisamos escrever diversas linhas de comentários para, por exemplo, documentar uma lógica complexa da aplicação. Nesses casos podemos utilizar o comentário de múltiplas linhas que é inicializado por um /* e terminado pelo */. Tudo que estiver entre a abertura e o fechamento do comentário é ignorado pelo compilador da linguagem:

/* Isso é um comentário de múltiplas linhas

*/

3.5 Exercícios

Faça o código dos exercícios do capítulo dentro de botões no formulário do projeto inicial, cada exercício deve car na ação de um botão diferente.

1) Crie 3 variáveis 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 média delas. Exiba o resultado em umMessageBox.

2) O que acontece com o código abaixo?

int pi = 3.14;

• O código compila, e “pi” guarda o número 3

• O código compila, e “pi” guarda 3.14 (inteiros podem guardar casas decimais)

• O código não compila, pois 3.14 não “cabe” dentro de um inteiro

3) Execute o trecho de código a seguir. O que acontece com ele?

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

Repare o (int). Estamos “forçando” a conversão do double para um inteiro.

Qual o valor de piQuebrado nesse caso?

• 3.14

• 0

• 3

Capítulo 3 - Variáveis e tipos primitivos - Exercícios - Página 18

comentários (1)

Esta é apenas uma pré-visualização

3 shown on 207 pages

baixar o documento